dungeon_workbench_content.cc

Go to the documentation of this file.

#include "app/editor/dungeon/workspace/dungeon_workbench_content.h"
#include "util/i18n/tr.h"
 
#include <algorithm>
#include <array>
#include <cctype>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <sstream>
#include <utility>
#include <vector>
 
#include "absl/strings/str_format.h"
#include "app/editor/agent/agent_ui_theme.h"
#include "app/editor/dungeon/dungeon_canvas_viewer.h"
#include "app/editor/dungeon/dungeon_project_labels.h"
#include "app/editor/dungeon/dungeon_room_selector.h"
#include "app/editor/dungeon/dungeon_selection_snapshot.h"
#include "app/editor/dungeon/inspectors/door_editor_content.h"
#include "app/editor/dungeon/inspectors/dungeon_entity_inspector.h"
#include "app/editor/dungeon/selectors/object_selector_content.h"
#include "app/editor/dungeon/ui/window/custom_collision_panel.h"
#include "app/editor/dungeon/ui/window/dungeon_entrances_panel.h"
#include "app/editor/dungeon/ui/window/dungeon_map_panel.h"
#include "app/editor/dungeon/ui/window/item_editor_panel.h"
#include "app/editor/dungeon/ui/window/minecart_track_editor_panel.h"
#include "app/editor/dungeon/ui/window/room_tag_editor_panel.h"
#include "app/editor/dungeon/ui/window/sprite_editor_panel.h"
#include "app/editor/dungeon/ui/window/water_fill_panel.h"
#include "app/editor/dungeon/ui/workbench/dungeon_workbench_chrome.h"
#include "app/editor/dungeon/widgets/dungeon_status_bar.h"
#include "app/editor/dungeon/widgets/dungeon_workbench_toolbar.h"
#include "app/editor/dungeon/workspace/dungeon_pit_damage_view_model.h"
#include "app/editor/dungeon/workspace/dungeon_workbench_inspector_helpers.h"
#include "app/editor/dungeon/workspace/dungeon_workbench_layout.h"
#include "app/editor/dungeon/workspace/room_matrix_content.h"
#include "app/gui/automation/widget_auto_register.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/input.h"
#include "app/gui/core/layout_helpers.h"
#include "app/gui/core/platform_keys.h"
#include "app/gui/core/style_guard.h"
#include "app/gui/core/ui_config.h"
#include "app/gui/widgets/themed_widgets.h"
#include "core/features.h"
#include "core/project.h"
#include "imgui/imgui.h"
#include "rom/rom.h"
#include "util/file_util.h"
#include "zelda3/dungeon/door_types.h"
#include "zelda3/dungeon/dungeon_rom_addresses.h"
#include "zelda3/dungeon/object_layer_semantics.h"
#include "zelda3/dungeon/pit_damage_table.h"
#include "zelda3/dungeon/room_entrance.h"
#include "zelda3/dungeon/room_layer_manager.h"
#include "zelda3/dungeon/room_object.h"
#include "zelda3/resource_labels.h"
#include "zelda3/sprite/sprite.h"
 
namespace yaze::editor {
 
namespace {
 
// Object type category names based on ID range
const char* GetObjectCategory(int object_id) {
  if (object_id < 0x100)
    return "Standard";
  if (object_id < 0x200)
    return "Extended";
  if (object_id >= 0xF80)
    return "Special";
  return "Unknown";
}
 
const char* GetObjectStreamName(int layer_value) {
  switch (layer_value) {
    case 0:
      return "Primary";
    case 1:
      return "BG2 overlay";
    case 2:
      return "BG1 overlay";
    default:
      return "Unknown";
  }
}
 
const char* GetSpecialLayerName(int layer_value) {
  switch (layer_value) {
    case 0:
      return "Upper layer (BG1)";
    case 1:
      return "Lower layer (BG2)";
    default:
      return "Unknown";
  }
}
 
float ClampWorkbenchPaneWidth(float desired_width, float min_width,
                              float max_width) {
  return std::clamp(desired_width, min_width, std::max(min_width, max_width));
}
 
constexpr float kCompactLeftSidebarMinWidth = 224.0f;
constexpr float kCompactRightSidebarMinWidth = 272.0f;
constexpr float kCompactLeftSidebarScale = 0.72f;
constexpr float kCompactRightSidebarScale = 0.84f;
float GetCompactSidebarWidth(bool right_sidebar, float min_sidebar_width) {
  return std::max(
      right_sidebar ? kCompactRightSidebarMinWidth
                    : kCompactLeftSidebarMinWidth,
      min_sidebar_width * (right_sidebar ? kCompactRightSidebarScale
                                         : kCompactLeftSidebarScale));
}
 
DungeonWorkbenchTestRect CaptureLastItemRectForTesting() {
  DungeonWorkbenchTestRect rect;
  rect.visible = true;
  const ImVec2 min = ImGui::GetItemRectMin();
  const ImVec2 max = ImGui::GetItemRectMax();
  rect.min_x = min.x;
  rect.min_y = min.y;
  rect.max_x = max.x;
  rect.max_y = max.y;
  return rect;
}
 
}  // namespace
 
DungeonWorkbenchToolRequestTarget ResolveDungeonWorkbenchToolRequestTarget(
    bool standalone_window_open) {
  return standalone_window_open
             ? DungeonWorkbenchToolRequestTarget::kStandaloneWindow
             : DungeonWorkbenchToolRequestTarget::kEmbeddedInspector;
}
 
DungeonWorkbenchResponsiveLayout ResolveDungeonWorkbenchResponsiveLayout(
    float total_width, float min_canvas_width, float min_sidebar_width,
    float splitter_width, bool want_left, bool want_right) {
  DungeonWorkbenchResponsiveLayout result;
  result.show_left = want_left;
  result.show_right = want_right;
 
  auto required_width = [&](bool left, bool right, bool compact_left,
                            bool compact_right) {
    float required = min_canvas_width;
    required +=
        left ? (compact_left ? GetCompactSidebarWidth(false, min_sidebar_width)
                             : min_sidebar_width)
             : 0.0f;
    required +=
        right ? (compact_right ? GetCompactSidebarWidth(true, min_sidebar_width)
                               : min_sidebar_width)
              : 0.0f;
    if (left) {
      required += splitter_width;
    }
    if (right) {
      required += splitter_width;
    }
    return required;
  };
 
  if (result.show_left &&
      total_width <
          required_width(result.show_left, result.show_right, false, false)) {
    result.compact_left = true;
  }
  if (result.show_right &&
      total_width < required_width(result.show_left, result.show_right,
                                   result.compact_left, false)) {
    result.compact_right = true;
  }
  // Keep the entrance selector, object browser, and room navigation available
  // when only one pane fits. Toolbar pane toggles still allow either alone.
  if (result.show_right &&
      total_width < required_width(result.show_left, result.show_right,
                                   result.compact_left, result.compact_right)) {
    result.show_right = false;
    result.compact_right = false;
  }
  if (result.show_left &&
      total_width < required_width(result.show_left, result.show_right,
                                   result.compact_left, result.compact_right)) {
    result.show_left = false;
    result.compact_left = false;
  }
 
  return result;
}
 
DungeonWorkbenchPaneLayout ResolveDungeonWorkbenchPaneLayout(
    float total_width, float min_canvas_width, float min_sidebar_width,
    float splitter_width, float stored_left_width, float stored_right_width,
    bool want_left, bool want_right) {
  DungeonWorkbenchPaneLayout layout;
  layout.responsive = ResolveDungeonWorkbenchResponsiveLayout(
      total_width, min_canvas_width, min_sidebar_width, splitter_width,
      want_left, want_right);
 
  const float compact_left_width =
      GetCompactSidebarWidth(false, min_sidebar_width);
  const float compact_right_width =
      GetCompactSidebarWidth(true, min_sidebar_width);
  layout.min_left_width =
      layout.responsive.compact_left ? compact_left_width : min_sidebar_width;
  layout.min_right_width =
      layout.responsive.compact_right ? compact_right_width : min_sidebar_width;
 
  float left_width = layout.responsive.show_left
                         ? (layout.responsive.compact_left ? compact_left_width
                                                           : stored_left_width)
                         : 0.0f;
  float right_width =
      layout.responsive.show_right
          ? (layout.responsive.compact_right ? compact_right_width
                                             : stored_right_width)
          : 0.0f;
 
  const float max_left_width =
      total_width - right_width - min_canvas_width -
      (layout.responsive.show_left ? splitter_width : 0.0f) -
      (layout.responsive.show_right ? splitter_width : 0.0f);
  const float max_right_width =
      total_width - left_width - min_canvas_width -
      (layout.responsive.show_left ? splitter_width : 0.0f) -
      (layout.responsive.show_right ? splitter_width : 0.0f);
  if (layout.responsive.show_left) {
    left_width = ClampWorkbenchPaneWidth(
        left_width, layout.min_left_width,
        std::max(layout.min_left_width, max_left_width));
  } else {
    left_width = 0.0f;
  }
  if (layout.responsive.show_right) {
    right_width = ClampWorkbenchPaneWidth(
        right_width, layout.min_right_width,
        std::max(layout.min_right_width, max_right_width));
  } else {
    right_width = 0.0f;
  }
 
  float center_width = total_width - left_width - right_width;
  if (layout.responsive.show_left) {
    center_width -= splitter_width;
  }
  if (layout.responsive.show_right) {
    center_width -= splitter_width;
  }
  if (center_width < min_canvas_width) {
    float deficit = min_canvas_width - center_width;
    if (layout.responsive.show_left) {
      const float shrink =
          std::min(deficit, left_width - layout.min_left_width);
      left_width -= shrink;
      deficit -= shrink;
    }
    if (deficit > 0.0f && layout.responsive.show_right) {
      const float shrink =
          std::min(deficit, right_width - layout.min_right_width);
      right_width -= shrink;
      deficit -= shrink;
    }
    center_width = std::max(
        1.0f, total_width - left_width - right_width -
                  (layout.responsive.show_left ? splitter_width : 0.0f) -
                  (layout.responsive.show_right ? splitter_width : 0.0f));
  }
 
  layout.left_width = left_width;
  layout.center_width = center_width;
  layout.right_width = right_width;
  return layout;
}
 
DungeonWorkbenchContent::DungeonWorkbenchContent(
    DungeonRoomSelector* room_selector, int* current_room_id,
    std::function<void(int)> on_room_selected,
    std::function<void(int, RoomSelectionIntent)> on_room_selected_with_intent,
    std::function<void(int)> on_save_room,
    std::function<void()> on_save_all_rooms,
    std::function<DungeonCanvasViewer*()> get_viewer,
    std::function<DungeonCanvasViewer*(int)> get_compare_viewer,
    std::function<const std::deque<int>&()> get_recent_rooms,
    std::function<void(int)> forget_recent_room,
    std::function<void(bool)> set_workflow_mode, Rom* rom)
    : room_selector_(room_selector),
      current_room_id_(current_room_id),
      on_room_selected_(std::move(on_room_selected)),
      on_room_selected_with_intent_(std::move(on_room_selected_with_intent)),
      on_save_room_(std::move(on_save_room)),
      on_save_all_rooms_(std::move(on_save_all_rooms)),
      get_viewer_(std::move(get_viewer)),
      get_compare_viewer_(std::move(get_compare_viewer)),
      get_recent_rooms_(std::move(get_recent_rooms)),
      forget_recent_room_(std::move(forget_recent_room)),
      set_workflow_mode_(std::move(set_workflow_mode)),
      rom_(rom) {}
 
DungeonWorkbenchContent::~DungeonWorkbenchContent() = default;
 
std::string DungeonWorkbenchContent::GetId() const {
  return "dungeon.workbench";
}
std::string DungeonWorkbenchContent::GetDisplayName() const {
  return "Dungeon Workbench";
}
std::string DungeonWorkbenchContent::GetIcon() const {
  return ICON_MD_WORKSPACES;
}
std::string DungeonWorkbenchContent::GetEditorCategory() const {
  return "Dungeon";
}
int DungeonWorkbenchContent::GetPriority() const {
  return 10;
}
 
void DungeonWorkbenchContent::SetRom(Rom* rom) {
  rom_ = rom;
  room_dungeon_cache_.clear();
  room_dungeon_cache_built_ = false;
}
 
void DungeonWorkbenchContent::SetEmbeddedToolPanels(
    RoomTagEditorPanel* room_tags, CustomCollisionPanel* custom_collision,
    WaterFillPanel* water_fill, MinecartTrackEditorPanel* minecart_tracks) {
  room_tag_panel_ = room_tags;
  custom_collision_panel_ = custom_collision;
  water_fill_panel_ = water_fill;
  minecart_track_panel_ = minecart_tracks;
}
 
void DungeonWorkbenchContent::SetEmbeddedEditorPanels(
    WindowContent* object_selector, WindowContent* door_editor,
    WindowContent* sprite_editor, WindowContent* item_editor,
    WindowContent* room_graphics, WindowContent* palette_editor) {
  object_selector_content_ = object_selector;
  door_editor_content_ = door_editor;
  sprite_editor_content_ = sprite_editor;
  item_editor_content_ = item_editor;
  room_graphics_content_ = room_graphics;
  palette_editor_content_ = palette_editor;
}
 
void DungeonWorkbenchContent::FocusRoomInspector() {
  layout_state_.show_right_inspector = true;
  CloseToolInspector();
}
 
void DungeonWorkbenchContent::FocusSelectionInspector() {
  FocusRoomInspector();
}
 
void DungeonWorkbenchContent::FocusRoomMatrix() {
  layout_state_.show_left_sidebar = true;
  sidebar_mode_ = SidebarMode::Objects;
}
 
void DungeonWorkbenchContent::FocusEntranceBrowser() {
  FocusRoomInspector();
}
 
void DungeonWorkbenchContent::ShowConnectedGraph() {
  layout_state_.show_connected_canvas_view = true;
  split_view_enabled_ = false;
}
 
void DungeonWorkbenchContent::RequestDungeonMapPopup() {
  open_dungeon_map_popup_ = true;
}
 
void DungeonWorkbenchContent::RequestProposalPreview() {
  show_proposal_preview_ = true;
}
 
bool DungeonWorkbenchContent::LoadProposalOverlay(const std::string& path) {
  std::snprintf(proposal_path_, sizeof(proposal_path_), "%s", path.c_str());
  std::ifstream file(path, std::ios::binary);
  if (!file) {
    proposal_error_ = absl::StrFormat("Cannot open %s", path);
    return false;
  }
  std::stringstream buffer;
  buffer << file.rdbuf();
  auto overlay = ParseDungeonProposalOverlay(buffer.str());
  if (!overlay.ok()) {
    // Keep the previously loaded overlay visible; show why the new one failed.
    proposal_error_ = std::string(overlay.status().message());
    return false;
  }
  proposal_layer_visible_.clear();
  for (const auto& layer : overlay->layers) {
    proposal_layer_visible_.push_back(layer.visible ? 1 : 0);
  }
  proposal_overlay_ = std::move(*overlay);
  proposal_error_.clear();
  return true;
}
 
void DungeonWorkbenchContent::DrawProposalPreviewWindow(
    DungeonCanvasViewer& viewer) {
  if (!show_proposal_preview_) {
    return;
  }
  ImGui::SetNextWindowSize(ImVec2(1120.0f, 700.0f), ImGuiCond_FirstUseEver);
  if (!ImGui::Begin(ICON_MD_PREVIEW " Proposal Preview##DungeonProposalPreview",
                    &show_proposal_preview_)) {
    ImGui::End();
    return;
  }
 
  // File row.
  util::FileDialogOptions json_options;
  json_options.filters.push_back({"Proposal Overlay", "json"});
  json_options.filters.push_back({"All Files", "*"});
  if (ImGui::Button(ICON_MD_FOLDER_OPEN " Open...")) {
    const std::string path =
        util::FileDialogWrapper::ShowOpenFileDialog(json_options);
    if (!path.empty()) {
      (void)LoadProposalOverlay(path);
    }
  }
  ImGui::SameLine();
  ImGui::BeginDisabled(proposal_path_[0] == '\0');
  if (ImGui::Button(ICON_MD_REFRESH " Reload")) {
    (void)LoadProposalOverlay(proposal_path_);
  }
  ImGui::EndDisabled();
  ImGui::SameLine();
  ImGui::SetNextItemWidth(-1.0f);
  if (ImGui::InputTextWithHint("##ProposalPath", tr("overlay .json path"),
                               proposal_path_, sizeof(proposal_path_),
                               ImGuiInputTextFlags_EnterReturnsTrue)) {
    (void)LoadProposalOverlay(proposal_path_);
  }
  if (!proposal_error_.empty()) {
    gui::StyleColorGuard error_color(ImGuiCol_Text,
                                     ImVec4(1.0f, 0.45f, 0.4f, 1.0f));
    ImGui::TextWrapped("%s", proposal_error_.c_str());
  }
 
  if (!proposal_overlay_.has_value()) {
    ImGui::Spacing();
    ImGui::TextWrapped(
        "%s",
        tr("Open a proposal overlay (.json) to render its rooms from the "
           "loaded ROM with the proposed changes drawn on top. This window "
           "is read-only: it never edits rooms or the ROM."));
    ImGui::End();
    return;
  }
  const DungeonProposalOverlay& overlay = *proposal_overlay_;
 
  if (!overlay.title.empty()) {
    ImGui::TextUnformatted(overlay.title.c_str());
  }
  if (!overlay.status.empty()) {
    ImGui::SameLine();
    ImGui::TextDisabled("(%s)", overlay.status.c_str());
  }
  ImGui::TextDisabled("%s",
                      tr("Read-only preview. Nothing here edits the ROM."));
 
  // Layer and view controls.
  ImGui::Checkbox(tr("Show proposal"), &proposal_show_overlay_);
  ImGui::BeginDisabled(!proposal_show_overlay_);
  for (size_t i = 0; i < overlay.layers.size(); ++i) {
    const auto& layer = overlay.layers[i];
    ImGui::SameLine();
    const uint32_t c = layer.color_rgba;
    ImGui::ColorButton(
        absl::StrFormat("##ProposalLayerSwatch%d", i).c_str(),
        ImVec4(((c >> 24) & 0xFF) / 255.0f, ((c >> 16) & 0xFF) / 255.0f,
               ((c >> 8) & 0xFF) / 255.0f, 1.0f),
        ImGuiColorEditFlags_NoTooltip, ImVec2(12, 12));
    ImGui::SameLine(0, 4);
    bool visible =
        i < proposal_layer_visible_.size() && proposal_layer_visible_[i] != 0;
    if (ImGui::Checkbox(
            absl::StrFormat("%s##ProposalLayer%d", layer.label, i).c_str(),
            &visible) &&
        i < proposal_layer_visible_.size()) {
      proposal_layer_visible_[i] = visible ? 1 : 0;
    }
  }
  ImGui::EndDisabled();
 
  ImGui::SetNextItemWidth(160.0f);
  ImGui::SliderFloat(tr("Zoom"), &proposal_scale_, 0.5f, 2.0f, "%.2fx");
  if (on_room_selected_) {
    for (const auto& room : overlay.rooms) {
      ImGui::SameLine();
      if (ImGui::SmallButton(
              absl::StrFormat("Open $%02X##ProposalOpenRoom", room.room_id)
                  .c_str())) {
        on_room_selected_(room.room_id);
      }
    }
  }
 
  // Rooms with the overlay. Reserve space for notes below.
  const float notes_height =
      overlay.notes.empty()
          ? 0.0f
          : std::min(140.0f, ImGui::GetTextLineHeightWithSpacing() *
                                 (overlay.notes.size() + 1.5f));
  if (ImGui::BeginChild("##ProposalPreviewBody", ImVec2(0.0f, -notes_height),
                        true, ImGuiWindowFlags_HorizontalScrollbar)) {
    viewer.DrawProposalPreview(overlay, proposal_layer_visible_,
                               proposal_show_overlay_, proposal_scale_);
  }
  ImGui::EndChild();
 
  if (!overlay.notes.empty() &&
      ImGui::BeginChild("##ProposalPreviewNotes", ImVec2(0.0f, 0.0f), false)) {
    for (const auto& note : overlay.notes) {
      ImGui::BulletText("%s", note.c_str());
    }
  }
  if (!overlay.notes.empty()) {
    ImGui::EndChild();
  }
  ImGui::End();
}
 
void DungeonWorkbenchContent::OpenObjectSelectorTool() {
  OpenTool(WorkbenchTool::ObjectSelector);
}
 
void DungeonWorkbenchContent::OpenDoorTool() {
  OpenTool(WorkbenchTool::DoorEditor);
}
 
void DungeonWorkbenchContent::OpenSpriteTool() {
  OpenTool(WorkbenchTool::SpriteEditor);
}
 
void DungeonWorkbenchContent::OpenItemTool() {
  OpenTool(WorkbenchTool::ItemEditor);
}
 
void DungeonWorkbenchContent::OpenRoomGraphicsTool() {
  OpenTool(WorkbenchTool::RoomGraphics);
}
 
void DungeonWorkbenchContent::OpenPaletteTool() {
  OpenTool(WorkbenchTool::Palette);
}
 
void DungeonWorkbenchContent::OpenRoomTagsTool() {
  OpenTool(WorkbenchTool::RoomTags);
}
 
void DungeonWorkbenchContent::OpenCustomCollisionTool() {
  OpenTool(WorkbenchTool::CustomCollision);
}
 
void DungeonWorkbenchContent::OpenWaterFillTool() {
  OpenTool(WorkbenchTool::WaterFill);
}
 
void DungeonWorkbenchContent::OpenMinecartTool() {
  OpenTool(WorkbenchTool::MinecartTracks);
}
 
void DungeonWorkbenchContent::OpenObjectCoverageTool() {
  OpenTool(WorkbenchTool::ObjectCoverage);
}
 
bool DungeonWorkbenchContent::IsToolInspectorActiveForTesting() const {
  return inspector_mode_ == InspectorMode::Tools;
}
 
const char* DungeonWorkbenchContent::GetInspectorModeIdForTesting() const {
  switch (inspector_mode_) {
    case InspectorMode::Inspect:
      return "inspect";
    case InspectorMode::Tools:
      return "tools";
  }
  return "unknown";
}
 
const char* DungeonWorkbenchContent::GetActiveToolIdForTesting() const {
  return GetWorkbenchToolId(active_tool_);
}
 
const char* DungeonWorkbenchContent::GetSidebarModeIdForTesting() const {
  switch (sidebar_mode_) {
    case SidebarMode::Objects:
      return "objects";
    case SidebarMode::Sprites:
      return "sprites";
    case SidebarMode::Doors:
      return "doors";
    case SidebarMode::Items:
      return "items";
  }
  return "unknown";
}
 
void DungeonWorkbenchContent::DrawSidebarPane(float width, float height,
                                              float button_size, bool compact) {
  const bool sidebar_open = ImGui::BeginChild("##DungeonWorkbenchSidebar",
                                              ImVec2(width, height), false);
  if (sidebar_open) {
    DrawSidebarHeader(button_size, compact);
    DrawSidebarContent();
  }
  ImGui::EndChild();
}
 
void DungeonWorkbenchContent::DrawSidebarHeader(float button_size,
                                                bool compact) {
  const bool can_open_overview = true;
  const float collapse_w =
      workbench::CalcIconButtonWidth(ICON_MD_CHEVRON_LEFT, button_size);
  const float menu_w = can_open_overview ? workbench::CalcIconButtonWidth(
                                               ICON_MD_MORE_HORIZ, button_size)
                                         : 0.0f;
  const float spacing = ImGui::GetStyle().ItemSpacing.x;
  const float action_cluster_w =
      collapse_w + (can_open_overview ? (spacing + menu_w) : 0.0f);
 
  workbench::DrawPaneHeader(
      "##DungeonWorkbenchSidebarHeader", ICON_MD_WIDGETS, "Place", "Place",
      nullptr, compact, action_cluster_w, [&]() {
        if (can_open_overview) {
          if (workbench::DrawHeaderIconAction("SidebarQuickActions",
                                              ICON_MD_MORE_HORIZ, button_size,
                                              "Open room review tools", true)) {
            ImGui::OpenPopup("##WorkbenchSidebarQuickActions");
          }
          if (ImGui::BeginPopup("##WorkbenchSidebarQuickActions")) {
            if (ImGui::MenuItem(ICON_MD_VIEW_QUILT " Dungeon overview")) {
              ShowConnectedGraph();
            }
            if (ImGui::MenuItem(ICON_MD_MAP " Dungeon Map")) {
              RequestDungeonMapPopup();
            }
            if (ImGui::MenuItem(ICON_MD_PREVIEW " Proposal Preview...")) {
              RequestProposalPreview();
            }
            ImGui::Separator();
            const bool can_open_shortcuts =
                static_cast<bool>(open_keyboard_shortcuts_);
            // Default "Keyboard Shortcuts" chord: platform Ctrl/Cmd+Shift+/.
            const std::string keyboard_shortcuts =
                gui::FormatCtrlShiftShortcut(ImGuiKey_Slash);
            if (ImGui::MenuItem(ICON_MD_KEYBOARD " Keyboard Shortcuts",
                                keyboard_shortcuts.c_str(), false,
                                can_open_shortcuts) &&
                open_keyboard_shortcuts_) {
              open_keyboard_shortcuts_();
            }
            ImGui::EndPopup();
          }
          ImGui::SameLine();
        }
        if (workbench::DrawHeaderIconAction("CollapseRooms",
                                            ICON_MD_CHEVRON_LEFT, button_size,
                                            "Collapse navigation pane")) {
          layout_state_.show_left_sidebar = false;
        }
      });
 
  DrawSidebarModeTabs();
  ImGui::Separator();
}
 
void DungeonWorkbenchContent::DrawSidebarModeTabs() {
  struct PlacementChoice {
    const char* label;
    WorkbenchTool tool;
    SidebarMode mode;
  };
  constexpr PlacementChoice choices[] = {
      {"Objects", WorkbenchTool::ObjectSelector, SidebarMode::Objects},
      {"Sprites", WorkbenchTool::SpriteEditor, SidebarMode::Sprites},
      {"Doors", WorkbenchTool::DoorEditor, SidebarMode::Doors},
      {"Items", WorkbenchTool::ItemEditor, SidebarMode::Items}};
  float choice_width = 0.0f;
  for (const auto& choice : choices)
    choice_width = std::max(choice_width, ImGui::CalcTextSize(choice.label).x);
  choice_width += ImGui::GetStyle().FramePadding.x * 2.0f +
                  ImGui::GetStyle().CellPadding.x * 2.0f;
  const int columns =
      ImGui::GetContentRegionAvail().x >= choice_width * 4.0f ? 4 : 2;
  if (ImGui::BeginTable("##PlacementKinds", columns,
                        ImGuiTableFlags_SizingStretchSame |
                            ImGuiTableFlags_NoPadInnerX |
                            ImGuiTableFlags_NoPadOuterX)) {
    for (const auto& choice : choices) {
      ImGui::TableNextColumn();
      gui::StyleColorGuard selected_guard(
          ImGuiCol_Button, ImGui::GetStyleColorVec4(sidebar_mode_ == choice.mode
                                                        ? ImGuiCol_ButtonActive
                                                        : ImGuiCol_Button));
      const bool pressed = ImGui::Button(
          choice.label,
          ImVec2(ImGui::GetContentRegionAvail().x, ImGui::GetFrameHeight()));
      gui::AutoRegisterLastItem("button",
                                absl::StrFormat("Place %s", choice.label));
      if (sidebar_mode_ == choice.mode) {
        const ImVec2 min = ImGui::GetItemRectMin();
        const ImVec2 max = ImGui::GetItemRectMax();
        ImGui::GetWindowDrawList()->AddLine(
            ImVec2(min.x, max.y - 1), ImVec2(max.x, max.y - 1),
            ImGui::GetColorU32(ImGuiCol_CheckMark), 2.0f);
      }
      if (pressed)
        OpenTool(choice.tool);
    }
    ImGui::EndTable();
  }
}
 
void DungeonWorkbenchContent::DrawSidebarContent() {
  ImGui::PushID("WorkbenchSidebarMode");
  const auto draw_external = [this](const char* id) {
    if (!is_standalone_tool_open_ || !is_standalone_tool_open_(id))
      return false;
    ImGui::TextWrapped("Open in a separate window.");
    if (ImGui::Button("Focus Window") && open_and_focus_standalone_tool_)
      open_and_focus_standalone_tool_(id);
    return true;
  };
  const float available = std::max(1.0f, ImGui::GetContentRegionAvail().y);
  const float separator = 6.0f;
  const float upper =
      std::max(1.0f, (available - separator) * navigator_tools_fraction_);
  if (ImGui::BeginChild("##NavigatorTools", ImVec2(0, upper), false)) {
    WindowContent* content = nullptr;
    switch (sidebar_mode_) {
      case SidebarMode::Objects:
        content = object_selector_content_;
        break;
      case SidebarMode::Sprites:
        content = sprite_editor_content_;
        break;
      case SidebarMode::Doors:
        content = door_editor_content_;
        break;
      case SidebarMode::Items:
        content = item_editor_content_;
        break;
    }
    if (!content) {
      ImGui::TextDisabled("Placement library unavailable");
    } else if (!draw_external(content->GetId().c_str())) {
      if (auto* selector = dynamic_cast<ObjectSelectorContent*>(content))
        selector->DrawInWorkbench();
      else if (auto* sprites = dynamic_cast<SpriteEditorPanel*>(content))
        sprites->DrawInWorkbench();
      else if (auto* doors = dynamic_cast<DoorEditorContent*>(content))
        doors->DrawInWorkbench();
      else if (auto* items = dynamic_cast<ItemEditorPanel*>(content))
        items->DrawInWorkbench();
      else
        content->Draw(nullptr);
    }
  }
  ImGui::EndChild();
  const ImVec2 divider = ImGui::GetCursorScreenPos();
  ImGui::InvisibleButton("##NavigatorSplit", ImVec2(-1, separator));
  if (ImGui::IsItemHovered() || ImGui::IsItemActive())
    ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeNS);
  if (ImGui::IsItemActive())
    navigator_tools_fraction_ = std::clamp(
        navigator_tools_fraction_ + ImGui::GetIO().MouseDelta.y / available,
        0.20f, 0.65f);
  ImGui::GetWindowDrawList()->AddLine(
      ImVec2(divider.x, divider.y + separator * 0.5f),
      ImVec2(ImGui::GetItemRectMax().x, divider.y + separator * 0.5f),
      ImGui::GetColorU32(ImGuiCol_Separator));
  if (ImGui::BeginChild("##NavigatorMatrix", ImVec2(0, 0), false)) {
    if (!draw_external("dungeon.room_matrix")) {
      if (room_matrix_content_)
        room_matrix_content_->Draw(nullptr);
      else
        ImGui::TextDisabled("Room Matrix unavailable");
    }
  }
  ImGui::EndChild();
  ImGui::PopID();
}
 
void DungeonWorkbenchContent::Draw(bool* p_open) {
  (void)p_open;
  const auto& theme = AgentUI::GetTheme();
 
  if (!rom_ || !rom_->is_loaded()) {
    ImGui::TextDisabled(ICON_MD_INFO " Load a ROM to edit dungeon rooms.");
    return;
  }
  if (!room_selector_ || !current_room_id_ || !get_viewer_) {
    ImGui::TextColored(theme.text_error_red, tr("Dungeon Workbench not wired"));
    return;
  }
 
  DungeonCanvasViewer* primary_viewer = get_viewer_ ? get_viewer_() : nullptr;
  DungeonCanvasViewer* compare_viewer =
      get_compare_viewer_ ? get_compare_viewer_(compare_room_id_) : nullptr;
  const float splitter_w = gui::UIConfig::kSplitterWidth;
  const float total_w = std::max(ImGui::GetContentRegionAvail().x, 1.0f);
  // Relaxed from 320 px to 260 px so the Inspect pane can breathe at widths
  // where the previous floor forced a too-wide right rail. Room browser on the
  // left also benefits since its matrix cells scale down gracefully.
  const float min_sidebar_w =
      std::max(gui::UIConfig::kContentMinWidthSidebar, 260.0f);
  const float min_canvas_w = std::max(420.0f, min_sidebar_w + 96.0f);
  const DungeonWorkbenchPaneLayout pane_layout =
      ResolveDungeonWorkbenchPaneLayout(
          total_w, min_canvas_w, min_sidebar_w, splitter_w,
          layout_state_.left_width, layout_state_.right_width,
          layout_state_.show_left_sidebar, layout_state_.show_right_inspector);
  const bool show_left = pane_layout.responsive.show_left;
  const bool show_right = pane_layout.responsive.show_right;
 
  if (current_room_id_) {
    DungeonWorkbenchToolbarParams params;
    params.layout = &layout_state_;
    params.current_room_id = current_room_id_;
    params.previous_room_id = &previous_room_id_;
    params.split_view_enabled = &split_view_enabled_;
    params.compare_room_id = &compare_room_id_;
    params.primary_viewer = primary_viewer;
    params.compare_viewer = compare_viewer;
    params.on_room_selected = on_room_selected_;
    params.get_recent_rooms = get_recent_rooms_;
    if (on_room_selected_with_intent_) {
      params.on_open_room_panel = [this](int room_id) {
        on_room_selected_with_intent_(room_id,
                                      RoomSelectionIntent::kOpenStandalone);
      };
    }
    params.forget_recent_room = forget_recent_room_;
    params.set_workflow_mode = set_workflow_mode_;
    params.on_save_room = on_save_room_;
    params.draw_tools = [this]() {
      DrawInspectorToolPicker();
    };
    params.draw_save_content = [this]() {
      DrawApplyScopeControls(current_room_id_ ? *current_room_id_ : -1);
    };
    params.on_request_dungeon_map = [this]() {
      RequestDungeonMapPopup();
    };
    params.compare_search_buf = compare_search_buf_;
    params.compare_search_buf_size = sizeof(compare_search_buf_);
    params.draw_entrance_context = [this](float width) {
      if (entrance_navigator_content_)
        entrance_navigator_content_->DrawGraphicsContext(width);
    };
    const bool request_panel_workflow = DungeonWorkbenchToolbar::Draw(params);
    if (request_panel_workflow && set_workflow_mode_) {
      // Defer panel visibility mutation until toolbar child/table scopes closed.
      set_workflow_mode_(false);
      return;
    }
  }
 
  const float btn = gui::LayoutHelpers::GetTouchSafeWidgetHeight();
  const float total_h = std::max(ImGui::GetContentRegionAvail().y, 1.0f);
  const float left_w = pane_layout.left_width;
  const float right_w = pane_layout.right_width;
  const float center_w = pane_layout.center_width;
  if (show_left && !pane_layout.responsive.compact_left) {
    layout_state_.left_width = left_w;
  }
  if (show_right && !pane_layout.responsive.compact_right) {
    layout_state_.right_width = right_w;
  }
 
  // Mirror toggle: when inspector_on_left_, swap render order so the inspector
  // visually sits on the left of the canvas (ZScream-style). Width state is
  // preserved (right_width is always the inspector's, left_width always the
  // sidebar's) so splitter drags still affect the correct pane regardless of
  // which side it's on.
  if (inspector_on_left_) {
    if (show_right) {
      DrawInspectorPane(right_w, total_h, btn,
                        pane_layout.responsive.compact_right, primary_viewer);
      ImGui::SameLine(0.0f, 0.0f);
      if (DrawDungeonWorkbenchVerticalSplitter(
              "##DungeonWorkbenchLeftSplitter", total_h,
              &layout_state_.right_width, pane_layout.min_right_width,
              total_w - left_w - min_canvas_w - (show_left ? splitter_w : 0.0f),
              false)) {
        layout_state_.show_right_inspector = false;
      }
      ImGui::SameLine(0.0f, 0.0f);
    }
    DrawCanvasPane(center_w, total_h, primary_viewer);
    if (show_left) {
      ImGui::SameLine(0.0f, 0.0f);
      if (DrawDungeonWorkbenchVerticalSplitter(
              "##DungeonWorkbenchRightSplitter", total_h,
              &layout_state_.left_width, pane_layout.min_left_width,
              total_w - right_w - min_canvas_w -
                  (show_right ? splitter_w : 0.0f),
              true)) {
        layout_state_.show_left_sidebar = false;
      }
      ImGui::SameLine(0.0f, 0.0f);
      DrawSidebarPane(left_w, total_h, btn,
                      pane_layout.responsive.compact_left);
    }
  } else {
    if (show_left) {
      DrawSidebarPane(left_w, total_h, btn,
                      pane_layout.responsive.compact_left);
    }
    if (show_left) {
      ImGui::SameLine(0.0f, 0.0f);
      if (DrawDungeonWorkbenchVerticalSplitter(
              "##DungeonWorkbenchLeftSplitter", total_h,
              &layout_state_.left_width, pane_layout.min_left_width,
              total_w - right_w - min_canvas_w -
                  (show_right ? splitter_w : 0.0f),
              false)) {
        layout_state_.show_left_sidebar = false;
      }
    }
 
    if (show_left) {
      ImGui::SameLine(0.0f, 0.0f);
    }
    DrawCanvasPane(center_w, total_h, primary_viewer);
 
    if (show_right) {
      ImGui::SameLine(0.0f, 0.0f);
      if (DrawDungeonWorkbenchVerticalSplitter(
              "##DungeonWorkbenchRightSplitter", total_h,
              &layout_state_.right_width, pane_layout.min_right_width,
              total_w - left_w - min_canvas_w - (show_left ? splitter_w : 0.0f),
              true)) {
        layout_state_.show_right_inspector = false;
      }
      ImGui::SameLine(0.0f, 0.0f);
    }
    if (show_right) {
      DrawInspectorPane(right_w, total_h, btn,
                        pane_layout.responsive.compact_right, primary_viewer);
    }
  }
  if (primary_viewer) {
    DrawDungeonMapPopup(*primary_viewer);
  }
}
 
void DungeonWorkbenchContent::DrawCanvasPane(
    float width, float height, DungeonCanvasViewer* primary_viewer) {
  const bool canvas_open = ImGui::BeginChild(
      "##DungeonWorkbenchCanvas", ImVec2(width, height), false,
      ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse);
  if (canvas_open) {
    if (primary_viewer) {
      // Reserve a fixed strip at the bottom for the status bar so neither
      // single-room, split, nor connected-mode rendering can run past it and
      // clip against the outer window chrome. Inner scrolling (wheel zoom in
      // connected mode, canvas pan in single-room) happens inside this body
      // child — the outer ##DungeonWorkbenchCanvas never needs a scrollbar.
      const float status_bar_reserved =
          std::max(
              ImGui::GetFontSize() + ImGui::GetStyle().FramePadding.y * 2.0f,
              gui::UIConfig::kStatusBarHeight) +
          ImGui::GetStyle().ItemSpacing.y;
 
      const bool connected_mode = layout_state_.show_connected_canvas_view;
      ImGuiWindowFlags body_flags =
          ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse;
      if (connected_mode) {
        // Body child owns the connected-mode scroll container; matrix no
        // longer nests its own BeginChild for scrolling.
        const ImVec2 content_size =
            primary_viewer->GetConnectedContentSize(*current_room_id_);
        const float scale = primary_viewer->ConnectedCanvasScale();
        ImGui::SetNextWindowContentSize(
            ImVec2(content_size.x * scale, content_size.y * scale));
        body_flags = ImGuiWindowFlags_HorizontalScrollbar |
                     ImGuiWindowFlags_NoScrollWithMouse;
      }
      const bool body_open = ImGui::BeginChild(
          "##DungeonCanvasBody", ImVec2(0.0f, -status_bar_reserved), false,
          body_flags);
      if (body_open) {
        if (connected_mode) {
          split_view_enabled_ = false;
          if (primary_viewer->DrawConnectedRoomMatrix(*current_room_id_)
                  .has_value()) {
            layout_state_.show_connected_canvas_view = false;
          }
        } else if (split_view_enabled_) {
          DrawSplitView(*primary_viewer);
        } else {
          primary_viewer->DrawDungeonCanvas(*current_room_id_);
        }
        if (on_primary_canvas_drawn_) {
          on_primary_canvas_drawn_(*primary_viewer);
        }
      }
      ImGui::EndChild();
 
      const char* tool_mode =
          primary_viewer->object_interaction().mode_manager().GetModeName();
      bool room_dirty = false;
      if (auto* rooms = primary_viewer->rooms();
          rooms && current_room_id_ && *current_room_id_ >= 0) {
        if (const auto* room = rooms->GetIfMaterialized(*current_room_id_)) {
          room_dirty = room->HasUnsavedChanges();
        }
      }
      auto status =
          DungeonStatusBar::BuildState(*primary_viewer, tool_mode, room_dirty);
      status.workflow_mode = layout_state_.show_connected_canvas_view
                                 ? workflow_mode_names::kConnected
                                 : nullptr;
      status.workflow_primary = true;
      if (can_undo_)
        status.can_undo = can_undo_();
      if (can_redo_)
        status.can_redo = can_redo_();
      if (undo_desc_) {
        static std::string s_undo_desc;
        s_undo_desc = undo_desc_();
        status.undo_desc = s_undo_desc.empty() ? nullptr : s_undo_desc.c_str();
      }
      if (redo_desc_) {
        static std::string s_redo_desc;
        s_redo_desc = redo_desc_();
        status.redo_desc = s_redo_desc.empty() ? nullptr : s_redo_desc.c_str();
      }
      if (undo_depth_)
        status.undo_depth = undo_depth_();
      status.on_undo = on_undo_;
      status.on_redo = on_redo_;
      if (!layout_state_.show_connected_canvas_view) {
        status.on_selection = [this]() {
          FocusSelectionInspector();
        };
      }
      DungeonStatusBar::Draw(status);
    } else {
      ImGui::TextDisabled(tr("No active viewer"));
    }
  }
  ImGui::EndChild();
  // Floating, independent window; drawn here so it stays available while the
  // navigation sidebar is collapsed.
  if (primary_viewer) {
    DrawProposalPreviewWindow(*primary_viewer);
  }
}
 
void DungeonWorkbenchContent::DrawInspectorPane(float width, float height,
                                                float button_size, bool compact,
                                                DungeonCanvasViewer* viewer) {
  const bool inspector_open = ImGui::BeginChild("##DungeonWorkbenchInspector",
                                                ImVec2(width, height), true);
  if (inspector_open) {
    DrawInspectorHeader(button_size, compact);
    if (viewer) {
      DrawInspector(*viewer, compact);
    } else {
      ImGui::TextDisabled(tr("No active viewer"));
    }
  }
  ImGui::EndChild();
}
 
void DungeonWorkbenchContent::DrawInspectorHeader(float button_size,
                                                  bool compact) {
  // Chevron flips with mirror state so the collapse arrow always points
  // toward the inspector's exit edge (off-right when on right, off-left when
  // on left).
  const char* collapse_icon =
      inspector_on_left_ ? ICON_MD_CHEVRON_LEFT : ICON_MD_CHEVRON_RIGHT;
  const float collapse_w =
      workbench::CalcIconButtonWidth(collapse_icon, button_size);
  const float swap_w =
      workbench::CalcIconButtonWidth(ICON_MD_SWAP_HORIZ, button_size);
  const float spacing = ImGui::GetStyle().ItemSpacing.x;
  const float action_cluster_w = swap_w + collapse_w + spacing;
 
  const bool tools_mode = inspector_mode_ == InspectorMode::Tools;
  workbench::DrawPaneHeader(
      "##DungeonWorkbenchInspectorHeader",
      tools_mode ? ICON_MD_BUILD : ICON_MD_TUNE,
      tools_mode ? "Tools" : "Inspect",
      tools_mode ? GetWorkbenchToolShortLabel(active_tool_) : "Inspect",
      nullptr, compact, action_cluster_w, [&]() {
        if (workbench::DrawHeaderIconAction(
                "SwapInspectorSide", ICON_MD_SWAP_HORIZ, button_size,
                inspector_on_left_ ? "Move inspector to the right side"
                                   : "Move inspector to the left side "
                                     "(ZScream layout)")) {
          inspector_on_left_ = !inspector_on_left_;
          if (on_inspector_side_changed_) {
            on_inspector_side_changed_(inspector_on_left_);
          }
        }
        ImGui::SameLine(0.0f, spacing);
        if (workbench::DrawHeaderIconAction("CollapseInspector", collapse_icon,
                                            button_size,
                                            "Collapse inspector")) {
          layout_state_.show_right_inspector = false;
        }
      });
}
 
void DungeonWorkbenchContent::DrawSplitView(
    DungeonCanvasViewer& primary_viewer) {
  if (!current_room_id_ || !split_view_enabled_ || compare_room_id_ < 0) {
    if (split_view_enabled_) {
      split_view_enabled_ = false;
    }
    return;
  }
 
  // Choose a sensible default compare room (most-recent non-current).
  if (compare_room_id_ < 0 || compare_room_id_ == *current_room_id_) {
    if (get_recent_rooms_) {
      for (int rid : get_recent_rooms_()) {
        if (rid != *current_room_id_) {
          compare_room_id_ = rid;
          break;
        }
      }
    }
  }
 
  if (compare_room_id_ < 0) {
    // Nothing to compare yet.
    split_view_enabled_ = false;
    primary_viewer.DrawDungeonCanvas(*current_room_id_);
    return;
  }
 
  constexpr ImGuiTableFlags kSplitFlags =
      ImGuiTableFlags_Resizable | ImGuiTableFlags_NoPadOuterX |
      ImGuiTableFlags_NoPadInnerX | ImGuiTableFlags_BordersInnerV;
 
  if (!ImGui::BeginTable("##DungeonWorkbenchSplit", 2, kSplitFlags)) {
    primary_viewer.DrawDungeonCanvas(*current_room_id_);
    return;
  }
 
  ImGui::TableSetupColumn("Active", ImGuiTableColumnFlags_WidthStretch);
  ImGui::TableSetupColumn("Compare", ImGuiTableColumnFlags_WidthStretch);
  ImGui::TableNextRow();
 
  DungeonCanvasViewer* compare_viewer =
      get_compare_viewer_ ? get_compare_viewer_(compare_room_id_) : nullptr;
 
  // Active pane (minimum height so canvas never collapses)
  ImGui::TableNextColumn();
  ImGui::AlignTextToFramePadding();
  const project::YazeProject* active_project = primary_viewer.project();
  ImGui::TextDisabled(
      ICON_MD_CROP_FREE " Active  [%03X] %s", *current_room_id_,
      dungeon_project_labels::GetRoomLabel(active_project, *current_room_id_)
          .c_str());
  ImGui::Separator();
  const bool split_active_open = gui::LayoutHelpers::BeginContentChild(
      "##SplitActive", ImVec2(1.0f, 1.0f), false,
      ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse);
  if (split_active_open) {
    primary_viewer.DrawDungeonCanvas(*current_room_id_);
  }
  gui::LayoutHelpers::EndContentChild();
 
  // Compare pane
  ImGui::TableNextColumn();
  ImGui::AlignTextToFramePadding();
  const project::YazeProject* compare_project =
      compare_viewer ? compare_viewer->project() : active_project;
  ImGui::TextDisabled(
      ICON_MD_COMPARE_ARROWS " Compare [%03X] %s", compare_room_id_,
      dungeon_project_labels::GetRoomLabel(compare_project, compare_room_id_)
          .c_str());
  ImGui::Separator();
  const bool split_compare_open = gui::LayoutHelpers::BeginContentChild(
      "##SplitCompare", ImVec2(1.0f, 1.0f), false,
      ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse);
  if (split_compare_open) {
    if (compare_viewer) {
      if (layout_state_.sync_split_view) {
        compare_viewer->canvas().ApplyScaleSnapshot(
            primary_viewer.canvas().GetConfig());
      }
      compare_viewer->DrawDungeonCanvas(compare_room_id_);
    } else {
      ImGui::TextDisabled(tr("No compare viewer"));
    }
  }
  gui::LayoutHelpers::EndContentChild();
 
  ImGui::EndTable();
}
 
void DungeonWorkbenchContent::BuildRoomDungeonCache() {
  room_dungeon_cache_.clear();
  room_dungeon_cache_built_ = true;  // Always set, even if ROM missing.
  if (!rom_ || !rom_->is_loaded() ||
      !zelda3::ResolveEntranceLayout(rom_->vector()).ok())
    return;
 
  // Short dungeon names for display in the inspector badge.
  // Indices 0-13 = vanilla ALTTP dungeons; higher indices = custom/Oracle.
  static const char* const kShortNames[] = {
      "Sewers", "HC",    "Eastern", "Desert", "A-Tower", "Swamp",  "PoD",
      "Misery", "Skull", "Ice",     "Hera",   "Thieves", "Turtle", "GT",
  };
  constexpr int kVanillaCount =
      static_cast<int>(sizeof(kShortNames) / sizeof(kShortNames[0]));
 
  auto AddRoom = [&](int room_id, int dungeon_id) {
    if (room_id < 0 || room_id >= zelda3::kNumberOfRooms)
      return;
    if (room_dungeon_cache_.contains(room_id))
      return;  // Entrance wins over spawn.
    if (dungeon_id >= 0 && dungeon_id < kVanillaCount) {
      room_dungeon_cache_[room_id] = kShortNames[dungeon_id];
    } else {
      char buf[16];
      snprintf(buf, sizeof(buf), "Dungeon %02X", dungeon_id);
      room_dungeon_cache_[room_id] = buf;
    }
  };
 
  // Standard entrances — authoritative dungeon assignment.
  for (int i = 0; i < zelda3::kNumRegularDungeonEntrances; ++i) {
    zelda3::RoomEntrance ent(rom_, static_cast<uint8_t>(i), false);
    if (!ent.load_status().ok() || ent.room_ < 0 ||
        ent.room_ >= zelda3::kNumberOfRooms)
      continue;
    int did = ent.dungeon_id_;
    if (did >= 0 && did < kVanillaCount) {
      room_dungeon_cache_[ent.room_] = kShortNames[did];
    } else {
      char buf[16];
      snprintf(buf, sizeof(buf), "Dungeon %02X", did);
      room_dungeon_cache_[ent.room_] = buf;
    }
  }
 
  // Spawn points — fill in rooms not covered by entrances.
  for (int i = 0; i < zelda3::kNumDungeonSpawnPoints; ++i) {
    zelda3::RoomEntrance ent(rom_, static_cast<uint8_t>(i), true);
    if (ent.load_status().ok())
      AddRoom(static_cast<int>(ent.room_), static_cast<int>(ent.dungeon_id_));
  }
}
 
void DungeonWorkbenchContent::DrawInspector(DungeonCanvasViewer& viewer,
                                            bool compact) {
  // Gentle compaction only; inspector sections own their own internal
  // spacing (collapsing-header headers, action buttons), so let the theme
  // defaults shape inter-section breathing room here.
  gui::StyleVarGuard item_spacing_guard(
      ImGuiStyleVar_ItemSpacing,
      ImVec2(std::max(ImGui::GetStyle().ItemSpacing.x, 4.0f),
             std::max(4.0f, ImGui::GetStyle().ItemSpacing.y - 1.0f)));
  DrawInspectorShelf(viewer, compact);
}
 
void DungeonWorkbenchContent::SetAllSaveFlags(bool value) {
  auto& flags = core::FeatureFlags::get().dungeon;
  flags.kSaveObjects = value;
  flags.kSaveSprites = value;
  flags.kSaveRoomHeaders = value;
  flags.kSaveChests = value;
  flags.kSavePotItems = value;
  flags.kSaveEntrances = value;
  flags.kSavePalettes = value;
  flags.kSaveCollision = value;
  flags.kSaveBlocks = value;
  flags.kSaveTorches = value;
  flags.kSavePits = value;
}
 
void DungeonWorkbenchContent::DrawApplyScopeControls(int room_id) {
  auto& flags = core::FeatureFlags::get().dungeon;
  ImGui::TextUnformatted(tr("Room content to apply"));
  constexpr ImGuiTableFlags kFlags =
      ImGuiTableFlags_SizingStretchSame | ImGuiTableFlags_NoPadOuterX;
  if (ImGui::BeginTable("##WorkbenchSaveContentFlags", 2, kFlags,
                        ImVec2(320.0f, 0.0f))) {
    auto draw_checkbox = [](const char* label, bool* value) {
      ImGui::TableNextColumn();
      ImGui::Checkbox(label, value);
    };
    ImGui::TableNextRow();
    draw_checkbox("Room objects", &flags.kSaveObjects);
    draw_checkbox("Room sprites", &flags.kSaveSprites);
    ImGui::TableNextRow();
    draw_checkbox("Room properties", &flags.kSaveRoomHeaders);
    draw_checkbox("Chest contents", &flags.kSaveChests);
    ImGui::TableNextRow();
    draw_checkbox("Items under pots", &flags.kSavePotItems);
    draw_checkbox("Palettes", &flags.kSavePalettes);
    ImGui::TableNextRow();
    draw_checkbox("Custom collision", &flags.kSaveCollision);
    ImGui::TableNextColumn();
    ImGui::BeginDisabled();
    ImGui::Checkbox("Water Fill", &flags.kSaveWaterFillZones);
    ImGui::EndDisabled();
    if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) {
      ImGui::SetTooltip(
          "Water Fill saving is fixed when the project opens. Change "
          "save_dungeon_water_fill_zones in the .yaze file, then reopen the "
          "project.");
    }
    ImGui::TableNextRow();
    draw_checkbox("Push blocks", &flags.kSaveBlocks);
    draw_checkbox("Torches", &flags.kSaveTorches);
    ImGui::TableNextRow();
    draw_checkbox("Pit damage", &flags.kSavePits);
    draw_checkbox("Entrances", &flags.kSaveEntrances);
    ImGui::EndTable();
  }
 
  if (ImGui::SmallButton(tr("Select all##WorkbenchSaveContent"))) {
    SetAllSaveFlags(true);
  }
  ImGui::SameLine();
  if (ImGui::SmallButton(tr("Select none##WorkbenchSaveContent"))) {
    SetAllSaveFlags(false);
  }
 
  ImGui::Separator();
  const auto apply_room_label =
      absl::StrFormat(ICON_MD_SAVE " Apply room 0x%03X", room_id);
  if (on_save_room_ && room_id >= 0 &&
      workbench::DrawActionButton(apply_room_label.c_str(), ImVec2(-1, 0))) {
    on_save_room_(room_id);
  }
  if (on_save_all_rooms_ &&
      workbench::DrawActionButton(ICON_MD_SAVE_ALT " Apply all loaded rooms",
                                  ImVec2(-1, 0))) {
    on_save_all_rooms_();
  }
  ImGui::TextWrapped(
      tr("Apply uses the checked content. File > Save ROM "
         "writes the applied changes to disk."));
}
 
void DungeonWorkbenchContent::DrawPitDamageControls(int room_id) {
  pit_damage_control_rects_ = {};
  if (pit_damage_chooser_room_id_ >= 0 &&
      pit_damage_chooser_room_id_ != room_id) {
    if (ImGui::BeginPopup("##PitDamageSlotChooser")) {
      ImGui::CloseCurrentPopup();
      ImGui::EndPopup();
    }
    pit_damage_chooser_room_id_ = -1;
  }
  const auto& theme = AgentUI::GetTheme();
  zelda3::PitDamageTable* table =
      get_pit_damage_table_ ? get_pit_damage_table_() : nullptr;
  if (!table) {
    bool enabled = false;
    ImGui::BeginDisabled();
    ImGui::Checkbox(tr("Pit damage##PitDamageEnabled"), &enabled);
    ImGui::EndDisabled();
    if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) {
      ImGui::SetTooltip(tr("Available after room data loads."));
    }
    return;
  }
  const auto membership = BuildPitDamageMembershipState(
      table, room_id, pit_damage_replacement_room_id_,
      pit_damage_victim_room_id_);
  if (!membership.room_valid) {
    ImGui::TextDisabled(tr("No valid room selected."));
    return;
  }
 
  const uint16_t current_room = membership.room_id;
  bool room_deals_damage = membership.deals_damage;
  if (ImGui::Checkbox(tr("Pit damage##PitDamageEnabled"), &room_deals_damage)) {
    pit_damage_chooser_room_id_ = room_id;
    ImGui::OpenPopup("##PitDamageSlotChooser");
  }
  {
    gui::AutoWidgetScope automation_scope("Dungeon/Workbench");
    gui::AutoRegisterLastItem("checkbox", "PitDamageEnabled");
  }
  if (ImGui::IsItemHovered()) {
    ImGui::SetTooltip(
        "Choose which room gives up or receives a pit-damage slot when "
        "changing this room.");
  }
 
  if (membership.dirty) {
    ImGui::TextColored(theme.status_warning,
                       ICON_MD_EDIT " Pending pit damage change");
  }
 
  auto show_status = [&]() {
    if (pit_damage_status_message_.empty()) {
      return;
    }
    ImGui::PushTextWrapPos(0.0f);
    ImGui::TextColored(
        pit_damage_status_error_ ? theme.status_error : theme.status_success,
        "%s %s",
        pit_damage_status_error_ ? ICON_MD_WARNING : ICON_MD_CHECK_CIRCLE,
        pit_damage_status_message_.c_str());
    ImGui::PopTextWrapPos();
  };
 
  if (!ImGui::BeginPopup("##PitDamageSlotChooser")) {
    show_status();
    return;
  }
 
  // Toggling requests a membership change. Only the explicit confirmation
  // transfers a fixed-capacity slot; closing the chooser leaves it untouched.
  if (membership.deals_damage) {
    if (!membership.suggested_replacement_room.has_value()) {
      ImGui::PushTextWrapPos(0.0f);
      ImGui::TextDisabled(tr("No available non-damaging room slot."));
      ImGui::PopTextWrapPos();
      show_status();
      ImGui::EndPopup();
      return;
    }
    pit_damage_replacement_room_id_ = *membership.suggested_replacement_room;
 
    ImGui::TextUnformatted(tr("Move pit damage to room:"));
    ImGui::SetNextItemWidth(88.0f);
    auto edit_value = pit_damage_replacement_room_id_;
    if (auto res = gui::InputHexWordEx("##PitDamageReplacementRoom",
                                       &edit_value, 88.0f, true);
        res.ShouldApply()) {
      pit_damage_replacement_room_id_ =
          std::min<uint16_t>(edit_value, zelda3::kNumberOfRooms - 1);
    }
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip(
          tr("Replacement room must not already be in the table."));
    }
    const bool replace_clicked =
        ImGui::Button(tr("Disable pit damage##PitDamageReplaceCurrent"));
    pit_damage_control_rects_.replace_current = CaptureLastItemRectForTesting();
    if (replace_clicked) {
      auto status = RemoveCurrentRoomFromPitDamage(
          table, current_room, pit_damage_replacement_room_id_);
      pit_damage_status_error_ = !status.ok();
      pit_damage_status_message_ =
          status.ok()
              ? absl::StrFormat("Room 0x%03X removed; slot now 0x%03X",
                                current_room, pit_damage_replacement_room_id_)
              : std::string(status.message());
      if (status.ok()) {
        pit_damage_chooser_room_id_ = -1;
        ImGui::CloseCurrentPopup();
      }
    }
  } else {
    if (!membership.suggested_victim_room.has_value()) {
      ImGui::PushTextWrapPos(0.0f);
      ImGui::TextDisabled(tr("No existing pit-damage slot is available."));
      ImGui::PopTextWrapPos();
      show_status();
      ImGui::EndPopup();
      return;
    }
    pit_damage_victim_room_id_ = *membership.suggested_victim_room;
 
    ImGui::TextUnformatted(tr("Take pit damage from room:"));
    ImGui::SetNextItemWidth(88.0f);
    auto edit_value = pit_damage_victim_room_id_;
    if (auto res = gui::InputHexWordEx("##PitDamageVictimRoom", &edit_value,
                                       88.0f, true);
        res.ShouldApply()) {
      pit_damage_victim_room_id_ =
          std::min<uint16_t>(edit_value, zelda3::kNumberOfRooms - 1);
    }
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip(tr("This room will stop dealing pit damage."));
    }
    const bool add_clicked =
        ImGui::Button(tr("Enable pit damage##PitDamageAddCurrent"));
    pit_damage_control_rects_.add_current = CaptureLastItemRectForTesting();
    if (add_clicked) {
      auto status = AddCurrentRoomToPitDamage(table, current_room,
                                              pit_damage_victim_room_id_);
      pit_damage_status_error_ = !status.ok();
      pit_damage_status_message_ =
          status.ok()
              ? absl::StrFormat("Room 0x%03X added; replaced 0x%03X",
                                current_room, pit_damage_victim_room_id_)
              : std::string(status.message());
      if (status.ok()) {
        pit_damage_chooser_room_id_ = -1;
        ImGui::CloseCurrentPopup();
      }
    }
  }
 
  ImGui::SameLine();
  if (ImGui::Button(tr("Cancel##PitDamageCancel"))) {
    pit_damage_chooser_room_id_ = -1;
    ImGui::CloseCurrentPopup();
  }
  {
    gui::AutoWidgetScope automation_scope("Dungeon/Workbench");
    gui::AutoRegisterLastItem("button", "PitDamageCancel");
  }
  ImGui::EndPopup();
  show_status();
  ImGui::TextDisabled(tr("Include Pit damage under Save content."));
}
 
DungeonMapPanel* DungeonWorkbenchContent::GetEmbeddedDungeonMap(
    DungeonCanvasViewer& viewer) {
  if (!room_selector_ || !current_room_id_) {
    return nullptr;
  }
  if (!embedded_dungeon_map_) {
    embedded_dungeon_map_ = std::make_unique<DungeonMapPanel>(
        current_room_id_, &room_selector_->mutable_active_rooms(),
        on_room_selected_, viewer.rooms());
    embedded_dungeon_map_->SetRoomIntentCallback(on_room_selected_with_intent_);
    if (*current_room_id_ >= 0) {
      embedded_dungeon_map_->AddRoom(*current_room_id_);
    }
  }
  embedded_dungeon_map_->SetRooms(viewer.rooms());
  embedded_dungeon_map_->SetRenderContextCallback(prepare_room_render_context_);
  if (const auto* project = viewer.project()) {
    embedded_dungeon_map_->SetHackManifest(&project->hack_manifest);
  } else {
    embedded_dungeon_map_->SetHackManifest(nullptr);
  }
  return embedded_dungeon_map_.get();
}
 
void DungeonWorkbenchContent::DrawDungeonMapPopup(DungeonCanvasViewer& viewer) {
  constexpr const char* kPopupId = "Dungeon Map##WorkbenchDungeonMapPopup";
  if (open_dungeon_map_popup_) {
    const ImVec2 viewport = ImGui::GetMainViewport()->WorkSize;
    ImGui::SetNextWindowSize(ImVec2(std::min(1040.0f, viewport.x * 0.85f),
                                    std::min(780.0f, viewport.y * 0.85f)),
                             ImGuiCond_Appearing);
    ImGui::OpenPopup(kPopupId);
    open_dungeon_map_popup_ = false;
  }
 
  bool popup_open = true;
  if (ImGui::BeginPopupModal(kPopupId, &popup_open,
                             ImGuiWindowFlags_NoSavedSettings)) {
    if (!popup_open) {
      ImGui::CloseCurrentPopup();
      ImGui::EndPopup();
      return;
    }
    if (auto* map = GetEmbeddedDungeonMap(viewer)) {
      const ImVec2 map_size =
          ImVec2(std::max(1.0f, ImGui::GetContentRegionAvail().x),
                 std::max(1.0f, ImGui::GetContentRegionAvail().y -
                                    ImGui::GetFrameHeightWithSpacing()));
      if (ImGui::BeginChild("##WorkbenchDungeonMapBody", map_size, false)) {
        map->Draw(nullptr);
      }
      ImGui::EndChild();
    } else {
      ImGui::TextDisabled(tr("Dungeon map unavailable"));
    }
 
    if (workbench::DrawActionButton(ICON_MD_CLOSE " Close", ImVec2(-1, 0))) {
      ImGui::CloseCurrentPopup();
    }
    ImGui::EndPopup();
  }
}
 
void DungeonWorkbenchContent::OpenTool(WorkbenchTool tool) {
  if (tool == WorkbenchTool::None) {
    return;
  }
  active_tool_ = tool;
  if (minecart_track_panel_) {
    minecart_track_panel_->set_collision_stamping(false);
    minecart_track_panel_->set_canvas_editing(tool ==
                                              WorkbenchTool::MinecartTracks);
  }
 
  if (ResolveDungeonWorkbenchToolRequestTarget(IsStandaloneToolOpen(tool)) ==
      DungeonWorkbenchToolRequestTarget::kStandaloneWindow) {
    // A pinned or explicitly popped-out tool remains the presentation owner.
    // Re-open/focus it, and never draw the same WindowContent twice.
    CloseToolInspector();
    if (open_and_focus_standalone_tool_) {
      if (WindowContent* content = GetWorkbenchToolContent(tool)) {
        (void)open_and_focus_standalone_tool_(content->GetId());
      }
    }
    return;
  }
 
  if (tool == WorkbenchTool::ObjectSelector ||
      tool == WorkbenchTool::SpriteEditor ||
      tool == WorkbenchTool::DoorEditor || tool == WorkbenchTool::ItemEditor) {
    CloseToolInspector();
    sidebar_mode_ = tool == WorkbenchTool::SpriteEditor ? SidebarMode::Sprites
                    : tool == WorkbenchTool::DoorEditor ? SidebarMode::Doors
                    : tool == WorkbenchTool::ItemEditor ? SidebarMode::Items
                                                        : SidebarMode::Objects;
    layout_state_.show_left_sidebar = true;
    FocusSelectionInspector();
    return;
  }
 
  inspector_mode_ = InspectorMode::Tools;
  layout_state_.show_right_inspector = true;
}
 
WindowContent* DungeonWorkbenchContent::GetWorkbenchToolContent(
    WorkbenchTool tool) const {
  switch (tool) {
    case WorkbenchTool::RoomTags:
      return room_tag_panel_;
    case WorkbenchTool::CustomCollision:
      return custom_collision_panel_;
    case WorkbenchTool::WaterFill:
      return water_fill_panel_;
    case WorkbenchTool::MinecartTracks:
      return minecart_track_panel_;
    case WorkbenchTool::ObjectCoverage:
      return object_coverage_content_;
    case WorkbenchTool::ObjectSelector:
      return object_selector_content_;
    case WorkbenchTool::DoorEditor:
      return door_editor_content_;
    case WorkbenchTool::SpriteEditor:
      return sprite_editor_content_;
    case WorkbenchTool::ItemEditor:
      return item_editor_content_;
    case WorkbenchTool::RoomGraphics:
      return room_graphics_content_;
    case WorkbenchTool::Palette:
      return palette_editor_content_;
    case WorkbenchTool::None:
      return nullptr;
  }
  return nullptr;
}
 
bool DungeonWorkbenchContent::IsWorkbenchToolAvailable(
    WorkbenchTool tool) const {
  return GetWorkbenchToolContent(tool) != nullptr;
}
 
bool DungeonWorkbenchContent::IsStandaloneToolOpen(WorkbenchTool tool) const {
  WindowContent* content = GetWorkbenchToolContent(tool);
  if (!content || !is_standalone_tool_open_) {
    return false;
  }
  const std::string standalone_id = content->GetId();
  return !standalone_id.empty() && is_standalone_tool_open_(standalone_id);
}
 
void DungeonWorkbenchContent::CloseToolInspector() {
  if (inspector_mode_ == InspectorMode::Tools) {
    if (minecart_track_panel_) {
      minecart_track_panel_->set_collision_stamping(false);
      minecart_track_panel_->set_canvas_editing(false);
    }
    if (get_viewer_) {
      if (auto* viewer = get_viewer_()) {
        viewer->object_interaction().HandleMouseRelease();
        viewer->object_interaction().CancelPlacement();
        viewer->object_interaction().mode_manager().CancelCurrentMode();
      }
    }
  }
  inspector_mode_ = InspectorMode::Inspect;
}
 
bool DungeonWorkbenchContent::PopOutActiveTool() {
  WindowContent* content = GetWorkbenchToolContent(active_tool_);
  if (!content || !open_and_focus_standalone_tool_) {
    return false;
  }
 
  const std::string standalone_id = content->GetId();
  if (standalone_id.empty() ||
      !open_and_focus_standalone_tool_(standalone_id)) {
    return false;
  }
 
  CloseToolInspector();
  return true;
}
 
const char* DungeonWorkbenchContent::GetWorkbenchToolId(
    WorkbenchTool tool) const {
  switch (tool) {
    case WorkbenchTool::RoomTags:
      return "room_tags";
    case WorkbenchTool::CustomCollision:
      return "custom_collision";
    case WorkbenchTool::WaterFill:
      return "water_fill";
    case WorkbenchTool::MinecartTracks:
      return "minecart";
    case WorkbenchTool::ObjectCoverage:
      return "object_coverage";
    case WorkbenchTool::ObjectSelector:
      return "object_selector";
    case WorkbenchTool::DoorEditor:
      return "door";
    case WorkbenchTool::SpriteEditor:
      return "sprite";
    case WorkbenchTool::ItemEditor:
      return "item";
    case WorkbenchTool::RoomGraphics:
      return "room_graphics";
    case WorkbenchTool::Palette:
      return "palette";
    case WorkbenchTool::None:
      return "none";
  }
  return "unknown";
}
 
const char* DungeonWorkbenchContent::GetWorkbenchToolShortLabel(
    WorkbenchTool tool) const {
  switch (tool) {
    case WorkbenchTool::RoomTags:
      return "Room Tags";
    case WorkbenchTool::CustomCollision:
      return "Custom Collision";
    case WorkbenchTool::WaterFill:
      return "Water Fill";
    case WorkbenchTool::MinecartTracks:
      return "Minecart Tracks";
    case WorkbenchTool::ObjectCoverage:
      return "Object Coverage";
    case WorkbenchTool::ObjectSelector:
      return "Object Selector";
    case WorkbenchTool::DoorEditor:
      return "Door Tools";
    case WorkbenchTool::SpriteEditor:
      return "Sprite Tools";
    case WorkbenchTool::ItemEditor:
      return "Item Tools";
    case WorkbenchTool::RoomGraphics:
      return "Room Graphics";
    case WorkbenchTool::Palette:
      return "Palette";
    case WorkbenchTool::None:
      return "Tool";
  }
  return "Tool";
}
 
const char* DungeonWorkbenchContent::GetWorkbenchToolUnavailableMessage(
    WorkbenchTool tool) const {
  switch (tool) {
    case WorkbenchTool::RoomTags:
      return "Room tag tools are not available.";
    case WorkbenchTool::CustomCollision:
      return "Custom collision tools are not available.";
    case WorkbenchTool::WaterFill:
      return "Water fill tools are not available.";
    case WorkbenchTool::MinecartTracks:
      return "Minecart track tools are not available.";
    case WorkbenchTool::ObjectCoverage:
      return "Object coverage is not available.";
    case WorkbenchTool::ObjectSelector:
      return "Object selector is not available.";
    case WorkbenchTool::DoorEditor:
      return "Door tools are not available.";
    case WorkbenchTool::SpriteEditor:
      return "Sprite tools are not available.";
    case WorkbenchTool::ItemEditor:
      return "Item tools are not available.";
    case WorkbenchTool::RoomGraphics:
      return "Room graphics tools are not available.";
    case WorkbenchTool::Palette:
      return "Palette tools are not available.";
    case WorkbenchTool::None:
      return "No Workbench tool selected.";
  }
  return "Tool is not available.";
}
 
void DungeonWorkbenchContent::DrawWorkbenchTool(DungeonCanvasViewer& viewer,
                                                WorkbenchTool tool) {
  const int room_id = viewer.current_room_id();
  auto draw_window_content = [](WindowContent* content,
                                const char* unavailable_message) {
    if (!content) {
      ImGui::TextDisabled("%s", unavailable_message);
      return;
    }
    content->Draw(nullptr);
  };
 
  ImGui::PushID(GetWorkbenchToolId(tool));
  switch (tool) {
    case WorkbenchTool::RoomTags:
      if (!room_tag_panel_) {
        ImGui::TextDisabled("%s", GetWorkbenchToolUnavailableMessage(tool));
        break;
      }
      room_tag_panel_->SetCurrentRoomId(room_id);
      room_tag_panel_->Draw(nullptr);
      break;
    case WorkbenchTool::CustomCollision:
      if (!custom_collision_panel_) {
        ImGui::TextDisabled("%s", GetWorkbenchToolUnavailableMessage(tool));
        break;
      }
      custom_collision_panel_->SetCanvasViewer(&viewer);
      custom_collision_panel_->SetInteraction(&viewer.object_interaction());
      custom_collision_panel_->Draw(nullptr);
      break;
    case WorkbenchTool::WaterFill:
      if (!water_fill_panel_) {
        ImGui::TextDisabled("%s", GetWorkbenchToolUnavailableMessage(tool));
        break;
      }
      water_fill_panel_->SetCanvasViewer(&viewer);
      water_fill_panel_->SetInteraction(&viewer.object_interaction());
      water_fill_panel_->Draw(nullptr);
      break;
    case WorkbenchTool::MinecartTracks:
      if (!minecart_track_panel_) {
        ImGui::TextDisabled("%s", GetWorkbenchToolUnavailableMessage(tool));
        break;
      }
      minecart_track_panel_->Draw(nullptr);
      break;
    case WorkbenchTool::ObjectCoverage:
      draw_window_content(object_coverage_content_,
                          GetWorkbenchToolUnavailableMessage(tool));
      break;
    case WorkbenchTool::ObjectSelector:
      if (auto* selector =
              dynamic_cast<ObjectSelectorContent*>(object_selector_content_)) {
        selector->DrawInWorkbench();
      } else {
        draw_window_content(object_selector_content_,
                            GetWorkbenchToolUnavailableMessage(tool));
      }
      break;
    case WorkbenchTool::DoorEditor:
      draw_window_content(door_editor_content_,
                          GetWorkbenchToolUnavailableMessage(tool));
      break;
    case WorkbenchTool::SpriteEditor:
      draw_window_content(sprite_editor_content_,
                          GetWorkbenchToolUnavailableMessage(tool));
      break;
    case WorkbenchTool::ItemEditor:
      draw_window_content(item_editor_content_,
                          GetWorkbenchToolUnavailableMessage(tool));
      break;
    case WorkbenchTool::RoomGraphics:
      draw_window_content(room_graphics_content_,
                          GetWorkbenchToolUnavailableMessage(tool));
      break;
    case WorkbenchTool::Palette:
      draw_window_content(palette_editor_content_,
                          GetWorkbenchToolUnavailableMessage(tool));
      break;
    case WorkbenchTool::None:
      ImGui::TextDisabled("%s", GetWorkbenchToolUnavailableMessage(tool));
      break;
  }
  ImGui::PopID();
}
 
void DungeonWorkbenchContent::DrawInspectorToolPicker() {
  constexpr WorkbenchTool tools[] = {
      WorkbenchTool::RoomGraphics,  WorkbenchTool::Palette,
      WorkbenchTool::RoomTags,      WorkbenchTool::CustomCollision,
      WorkbenchTool::WaterFill,     WorkbenchTool::MinecartTracks,
      WorkbenchTool::ObjectCoverage};
  const bool pressed = ImGui::Button("Room tools");
  {
    gui::AutoWidgetScope scope("Dungeon/Workbench");
    gui::AutoRegisterLastItem("button", "tool_picker",
                              "Specialized room tools");
  }
  if (pressed)
    ImGui::OpenPopup("##WorkbenchToolPickerPopup");
  if (ImGui::BeginPopup("##WorkbenchToolPickerPopup")) {
    for (const auto tool : tools) {
      const bool available = IsWorkbenchToolAvailable(tool);
      const bool selected = ImGui::MenuItem(
          GetWorkbenchToolShortLabel(tool), nullptr,
          inspector_mode_ == InspectorMode::Tools && active_tool_ == tool,
          available);
      {
        gui::AutoWidgetScope scope("Dungeon/Workbench");
        gui::AutoRegisterLastItem(
            "menu_item", absl::StrFormat("tool_%s", GetWorkbenchToolId(tool)));
      }
      if (selected)
        OpenTool(tool);
    }
    ImGui::EndPopup();
  }
}
 
void DungeonWorkbenchContent::DrawInspectorToolPanel(
    DungeonCanvasViewer& viewer) {
  const bool back = ImGui::Button("Back to Inspect");
  {
    gui::AutoWidgetScope scope("Dungeon/Workbench");
    gui::AutoRegisterLastItem("button", "back_to_inspect");
  }
  if (back) {
    CloseToolInspector();
    return;
  }
  ImGui::SameLine();
  const bool can_pop_out =
      IsWorkbenchToolAvailable(active_tool_) && open_and_focus_standalone_tool_;
  ImGui::BeginDisabled(!can_pop_out);
  const bool pop_out = ImGui::Button("Pop out");
  {
    gui::AutoWidgetScope scope("Dungeon/Workbench");
    gui::AutoRegisterLastItem("button", "pop_out_tool");
  }
  ImGui::EndDisabled();
  if (pop_out && can_pop_out) {
    (void)PopOutActiveTool();
    return;
  }
  if (IsStandaloneToolOpen(active_tool_)) {
    ImGui::TextDisabled("%s is open in a separate window.",
                        GetWorkbenchToolShortLabel(active_tool_));
    return;
  }
  if (!IsWorkbenchToolAvailable(active_tool_)) {
    ImGui::TextDisabled("%s", GetWorkbenchToolUnavailableMessage(active_tool_));
    return;
  }
  ImGui::SeparatorText(GetWorkbenchToolShortLabel(active_tool_));
  const bool body_open = ImGui::BeginChild("##WorkbenchToolInspectorBody",
                                           ImVec2(0.0f, 0.0f), false);
  if (body_open)
    DrawWorkbenchTool(viewer, active_tool_);
  ImGui::EndChild();
}
 
void DungeonWorkbenchContent::DrawInspectorShelf(DungeonCanvasViewer& viewer,
                                                 bool /*compact*/) {
  if (inspector_mode_ == InspectorMode::Tools) {
    DrawInspectorToolPanel(viewer);
    return;
  }
 
  auto& interaction = viewer.object_interaction();
  const int room_id = viewer.current_room_id();
  ImGui::PushID("InspectedSelection");
  const bool placing_object = DrawObjectPlacementInspector(viewer);
  if (!placing_object && interaction.mode_manager().IsPlacementActive()) {
    ImGui::TextUnformatted(interaction.mode_manager().GetModeName());
    if (ImGui::Button("Done placing (Esc)")) {
      interaction.CancelPlacement();
    }
    {
      gui::AutoWidgetScope scope("Dungeon/Workbench");
      gui::AutoRegisterLastItem("button", "finish_placement");
    }
  } else if (!placing_object && (interaction.GetSelectionCount() > 0 ||
                                 interaction.HasEntitySelection())) {
    DrawInspectorShelfSelection(viewer);
  }
  ImGui::PopID();
  // A selected-element action may navigate or rebind the room.
  if (viewer.current_room_id() != room_id)
    return;
  ImGui::PushID("InspectedRoom");
  DrawInspectorShelfRoom(viewer);
  ImGui::PopID();
}
 
bool DungeonWorkbenchContent::DrawObjectPlacementInspector(
    DungeonCanvasViewer& viewer) {
  auto& interaction = viewer.object_interaction();
  const auto* active_preview = interaction.GetPlacementPreview();
  if (!active_preview) {
    return false;
  }
  // Setters may invalidate preview caches; draw from a stable value this frame.
  const auto object = *active_preview;
  const auto description = workbench::DescribeObjectSize(object);
  const auto& theme = AgentUI::GetTheme();
  ImGui::PushID("PlacementInspector");
  workbench::DrawInspectorSectionHeader(ICON_MD_ADD_CIRCLE " Placing object");
  {
    gui::StyleColorGuard name_color(ImGuiCol_Text, theme.text_primary);
    ImGui::TextWrapped("%s", zelda3::GetObjectName(object.id_).c_str());
  }
  ImGui::TextDisabled("0x%03X", object.id_);
 
  constexpr ImGuiTableFlags kFlags = ImGuiTableFlags_BordersInnerV |
                                     ImGuiTableFlags_RowBg |
                                     ImGuiTableFlags_NoPadOuterX;
  if (ImGui::BeginTable("Properties", 2, kFlags)) {
    ImGui::TableSetupColumn("Property", ImGuiTableColumnFlags_WidthFixed,
                            64.0f);
    ImGui::TableSetupColumn("Value", ImGuiTableColumnFlags_WidthStretch);
    uint8_t requested_size = object.size_;
    if (workbench::DrawObjectSizeControls(object, &requested_size)) {
      interaction.SetPlacementPreviewSize(requested_size);
    }
    const bool uses_stream = zelda3::UsesRoomObjectStream(object);
    gui::LayoutHelpers::PropertyRow(uses_stream ? "Stream" : "Layer", [&]() {
      int layer = object.GetLayerValue();
      const char* stream_names[] = {"Primary", "BG2 overlay", "BG1 overlay"};
      const char* layer_names[] = {"Upper layer (BG1)", "Lower layer (BG2)"};
      ImGui::SetNextItemWidth(-1);
      if (ImGui::Combo("##Layer", &layer,
                       uses_stream ? stream_names : layer_names,
                       uses_stream ? 3 : 2)) {
        interaction.SetPlacementPreviewLayer(layer);
      }
      gui::AutoWidgetScope scope("Dungeon/Workbench");
      gui::AutoRegisterLastItem("combo", "placement_layer",
                                "Layer for the next placed object");
    });
    ImGui::EndTable();
  }
 
  bool repeat = interaction.GetPlacementPolicy() ==
                DungeonObjectInteraction::PlacementPolicy::kRepeat;
  if (ImGui::Checkbox(tr("Keep placing copies"), &repeat)) {
    interaction.SetPlacementPolicy(
        repeat ? DungeonObjectInteraction::PlacementPolicy::kRepeat
               : DungeonObjectInteraction::PlacementPolicy::kOnce);
  }
  {
    gui::AutoWidgetScope scope("Dungeon/Workbench");
    gui::AutoRegisterLastItem("checkbox", "repeat_placement",
                              "Keep placing copies after each click");
  }
  ImGui::TextWrapped("%s", repeat
                               ? tr("Click the canvas to place each copy.")
                               : tr("Click the canvas to place, then edit."));
  if (!description.wheel_hint.empty()) {
    ImGui::TextWrapped("%s", description.wheel_hint.c_str());
  }
  if (workbench::DrawActionButton(ICON_MD_CHECK " Done placing (Esc)",
                                  ImVec2(-1, 0))) {
    interaction.CancelPlacement();
    if (interaction.GetSelectionCount() > 0) {
      FocusSelectionInspector();
    }
  }
  {
    gui::AutoWidgetScope scope("Dungeon/Workbench");
    gui::AutoRegisterLastItem(
        "button", "finish_placement",
        "Finish placement and inspect the selected object");
  }
  ImGui::Separator();
  ImGui::PopID();
  return true;
}
 
void DungeonWorkbenchContent::DrawSelectedObjectActions(
    DungeonCanvasViewer& viewer, size_t index) {
  auto& interaction = viewer.object_interaction();
  auto& handler = interaction.entity_coordinator().tile_handler();
  const int room_id = viewer.current_room_id();
  const std::vector<size_t> indices = {index};
  ImGui::Spacing();
  if (workbench::DrawActionButton(ICON_MD_ADD_CIRCLE " Place another",
                                  ImVec2(-1, 0))) {
    if (interaction.BeginPlacementFromSelection()) {
      OpenObjectSelectorTool();
    }
  }
  {
    gui::AutoWidgetScope scope("Dungeon/Workbench");
    gui::AutoRegisterLastItem("button", "place_another",
                              "Place another object with this size and layer");
  }
  constexpr ImGuiTableFlags kFlags =
      ImGuiTableFlags_SizingStretchSame | ImGuiTableFlags_NoPadOuterX;
  if (ImGui::BeginTable("##SelectedObjectActions", 2, kFlags)) {
    auto action = [](const char* label, const char* id) {
      ImGui::TableNextColumn();
      const bool clicked = workbench::DrawActionButton(label, ImVec2(-1, 0));
      gui::AutoWidgetScope scope("Dungeon/Workbench");
      gui::AutoRegisterLastItem("button", id, label);
      return clicked;
    };
    if (action(ICON_MD_CONTENT_COPY " Duplicate", "duplicate_object")) {
      (void)interaction.HandleDuplicateSelected();
    }
    if (action(ICON_MD_DELETE " Delete", "delete_object")) {
      handler.DeleteObjects(room_id, indices);
    }
    if (action(ICON_MD_FLIP_TO_FRONT " To front", "object_to_front")) {
      handler.SendToFront(room_id, indices);
    }
    if (action(ICON_MD_FLIP_TO_BACK " To back", "object_to_back")) {
      handler.SendToBack(room_id, indices);
    }
    ImGui::EndTable();
  }
}
 
void DungeonWorkbenchContent::DrawInspectorShelfSelection(
    DungeonCanvasViewer& viewer) {
  auto& interaction = viewer.object_interaction();
  const auto& theme = AgentUI::GetTheme();
 
  const int room_id = viewer.current_room_id();
  const size_t obj_count = interaction.GetSelectionCount();
  const bool has_entity = interaction.HasEntitySelection();
 
  if (!has_entity && obj_count == 0) {
    workbench::DrawInspectorSectionHeader(ICON_MD_INFO " Selection");
    ImGui::TextDisabled(tr("Click an object or entity to inspect"));
    return;
  }
 
  // ── Tile Object Selection ──
  if (obj_count > 0) {
    workbench::DrawInspectorSectionHeader(ICON_MD_WIDGETS " Object Selection");
    ImGui::TextColored(theme.text_primary, ICON_MD_WIDGETS " %zu object%s",
                       obj_count, obj_count == 1 ? "" : "s");
    if (obj_count == 1) {
      ImGui::SameLine();
      ImGui::TextDisabled(tr("Focused selection"));
    }
 
    const auto indices = interaction.GetSelectedObjectIndices();
 
    // Multi-object summary + inline bulk editor (O1)
    if (indices.size() > 1 && room_id >= 0 && viewer.rooms()) {
      auto& room = (*viewer.rooms())[room_id];
      auto& objects = room.GetTileObjects();
      workbench::DrawInspectorSectionHeader(ICON_MD_SUMMARIZE
                                            " Multi-selection");
      for (size_t i = 0; i < indices.size() && i < 8; ++i) {
        size_t idx = indices[i];
        if (idx < objects.size()) {
          auto& obj = objects[idx];
          std::string name = zelda3::GetObjectName(obj.id_);
          ImGui::BulletText(tr("0x%03X %s"), obj.id_, name.c_str());
        }
      }
      if (indices.size() > 8) {
        ImGui::TextDisabled(tr("  ... and %zu more"), indices.size() - 8);
      }
 
      // Bulk editor: nudge/layer/stacking/size + destructive duplicate/delete.
      // Operations route through tile_handler / interaction, so every action
      // captures its own undo snapshot.
      auto& tile_handler = interaction.entity_coordinator().tile_handler();
      const std::vector<size_t> selection_copy(indices.begin(), indices.end());
      bool has_room_stream_object = false;
      bool has_special_layer_object = false;
      for (const size_t index : selection_copy) {
        if (index >= objects.size()) {
          continue;
        }
        if (zelda3::UsesRoomObjectStream(objects[index])) {
          has_room_stream_object = true;
        } else {
          has_special_layer_object = true;
        }
      }
      const bool has_editable_size =
          workbench::HasEditableRoomObjectSize(objects, selection_copy);
 
      workbench::DrawInspectorSectionHeader(ICON_MD_OPEN_WITH " Bulk Edit");
 
      // Nudge grid (arrow buttons around a tile-delta drag).
      static int bulk_nudge_dx = 0;
      static int bulk_nudge_dy = 0;
      ImGui::TextDisabled(
          tr("Nudge selection (%d px steps)"),
          interaction.entity_coordinator().SelectionMoveStepPixels());
      ImGui::PushButtonRepeat(true);
      if (ImGui::Button(ICON_MD_ARROW_UPWARD "##BulkNudgeUp"))
        interaction.NudgeSelected(0, -1);
      ImGui::SameLine();
      if (ImGui::Button(ICON_MD_ARROW_DOWNWARD "##BulkNudgeDown"))
        interaction.NudgeSelected(0, 1);
      ImGui::SameLine();
      if (ImGui::Button(ICON_MD_ARROW_BACK "##BulkNudgeLeft"))
        interaction.NudgeSelected(-1, 0);
      ImGui::SameLine();
      if (ImGui::Button(ICON_MD_ARROW_FORWARD "##BulkNudgeRight"))
        interaction.NudgeSelected(1, 0);
      ImGui::PopButtonRepeat();
 
      ImGui::SetNextItemWidth(60);
      ImGui::DragInt("##BulkNudgeDx", &bulk_nudge_dx, 0.25f, -63, 63, "Δx:%d");
      ImGui::SameLine();
      ImGui::SetNextItemWidth(60);
      ImGui::DragInt("##BulkNudgeDy", &bulk_nudge_dy, 0.25f, -63, 63, "Δy:%d");
      ImGui::SameLine();
      if (ImGui::Button(tr("Apply##BulkNudgeApply")) &&
          (bulk_nudge_dx != 0 || bulk_nudge_dy != 0)) {
        interaction.NudgeSelected(bulk_nudge_dx, bulk_nudge_dy);
        bulk_nudge_dx = 0;
        bulk_nudge_dy = 0;
      }
 
      ImGui::Spacing();
      if (has_room_stream_object && !has_special_layer_object) {
        ImGui::TextDisabled(tr("Object stream (set all)"));
        if (ImGui::SmallButton(tr("Primary##BulkPlacement0")))
          tile_handler.UpdateObjectsLayer(room_id, selection_copy, 0);
        ImGui::SameLine();
        if (ImGui::SmallButton(tr("BG2 overlay##BulkPlacement1")))
          tile_handler.UpdateObjectsLayer(room_id, selection_copy, 1);
        ImGui::SameLine();
        if (ImGui::SmallButton(tr("BG1 overlay##BulkPlacement2")))
          tile_handler.UpdateObjectsLayer(room_id, selection_copy, 2);
      } else if (has_special_layer_object && !has_room_stream_object) {
        ImGui::TextDisabled(tr("Special layer (set all)"));
        if (ImGui::SmallButton(tr("Upper (BG1)##BulkPlacement0")))
          tile_handler.UpdateObjectsLayer(room_id, selection_copy, 0);
        ImGui::SameLine();
        if (ImGui::SmallButton(tr("Lower (BG2)##BulkPlacement1")))
          tile_handler.UpdateObjectsLayer(room_id, selection_copy, 1);
      } else {
        ImGui::TextDisabled(tr("Stored placement (mixed selection)"));
        if (ImGui::SmallButton(tr("Primary / Upper (BG1)##BulkPlacement0")))
          tile_handler.UpdateObjectsLayer(room_id, selection_copy, 0);
        ImGui::SameLine();
        if (ImGui::SmallButton(tr("BG2 overlay / Lower (BG2)##BulkPlacement1")))
          tile_handler.UpdateObjectsLayer(room_id, selection_copy, 1);
      }
 
      ImGui::Spacing();
      ImGui::TextDisabled(tr("Stacking"));
      if (ImGui::SmallButton(ICON_MD_FLIP_TO_FRONT " Front##BulkFront"))
        tile_handler.SendToFront(room_id, selection_copy);
      ImGui::SameLine();
      if (ImGui::SmallButton(ICON_MD_FLIP_TO_BACK " Back##BulkBack"))
        tile_handler.SendToBack(room_id, selection_copy);
      ImGui::SameLine();
      if (ImGui::SmallButton(ICON_MD_KEYBOARD_ARROW_UP "##BulkFwd"))
        tile_handler.MoveForward(room_id, selection_copy);
      ImGui::SameLine();
      if (ImGui::SmallButton(ICON_MD_KEYBOARD_ARROW_DOWN "##BulkBwd"))
        tile_handler.MoveBackward(room_id, selection_copy);
 
      ImGui::Spacing();
      ImGui::TextDisabled(tr("Size"));
      if (!has_editable_size) {
        ImGui::BeginDisabled();
      }
      if (ImGui::SmallButton(ICON_MD_REMOVE "##BulkSizeDec"))
        tile_handler.ResizeObjects(room_id, selection_copy, -1);
      ImGui::SameLine();
      if (ImGui::SmallButton(ICON_MD_ADD "##BulkSizeInc"))
        tile_handler.ResizeObjects(room_id, selection_copy, 1);
      if (!has_editable_size) {
        ImGui::EndDisabled();
      }
 
      ImGui::Spacing();
      if (ImGui::SmallButton(ICON_MD_CONTENT_COPY " Duplicate##BulkDup"))
        (void)interaction.HandleDuplicateSelected();
      ImGui::SameLine();
      {
        gui::StyleColorGuard danger_colors({
            {ImGuiCol_Button, theme.status_error},
            {ImGuiCol_ButtonHovered,
             ImVec4(theme.status_error.x + 0.1f, theme.status_error.y + 0.05f,
                    theme.status_error.z + 0.05f, 1.0f)},
        });
        if (ImGui::SmallButton(ICON_MD_DELETE " Delete##BulkDel"))
          ImGui::OpenPopup("##BulkDeleteConfirm");
      }
 
      if (ImGui::BeginPopup("##BulkDeleteConfirm")) {
        ImGui::TextColored(
            theme.status_error, ICON_MD_WARNING " Delete %zu object%s?",
            selection_copy.size(), selection_copy.size() == 1 ? "" : "s");
        ImGui::Separator();
        if (ImGui::Button(tr("Cancel##BulkDelCancel"))) {
          ImGui::CloseCurrentPopup();
        }
        ImGui::SameLine();
        {
          gui::StyleColorGuard confirm_colors({
              {ImGuiCol_Button, theme.status_error},
          });
          if (ImGui::Button(ICON_MD_DELETE " Confirm##BulkDelConfirm")) {
            tile_handler.DeleteObjects(room_id, selection_copy);
            ImGui::CloseCurrentPopup();
          }
        }
        ImGui::EndPopup();
      }
    }
 
    // Single-object detailed inspector
    if (indices.size() == 1 && room_id >= 0 && viewer.rooms()) {
      auto& room = (*viewer.rooms())[room_id];
      auto& objects = room.GetTileObjects();
      const size_t idx = indices.front();
      if (idx < objects.size()) {
        // Stream changes can reorder and replace the room's object vector.
        // Keep this frame's property values independent of that storage.
        const auto obj = objects[idx];
        const std::string obj_name = zelda3::GetObjectName(obj.id_);
        const int subtype = zelda3::GetObjectSubtype(obj.id_);
        const bool uses_room_stream = zelda3::UsesRoomObjectStream(obj);
        int displayed_layer = obj.GetLayerValue();
        const int pixel_x = obj.x_ * 8;
        const int pixel_y = obj.y_ * 8;
 
        // Name + category header
        workbench::DrawInspectorSectionHeader(ICON_MD_CATEGORY
                                              " Focused Object");
        ImGui::TextColored(theme.text_primary, "%s", obj_name.c_str());
        ImGui::TextDisabled(tr("%s (Type %d)  #%zu in list"),
                            GetObjectCategory(obj.id_), subtype, idx);
 
        // Property table
        constexpr ImGuiTableFlags kPropsFlags = ImGuiTableFlags_BordersInnerV |
                                                ImGuiTableFlags_RowBg |
                                                ImGuiTableFlags_NoPadOuterX;
        if (ImGui::BeginTable("##SelObjProps", 2, kPropsFlags)) {
          ImGui::TableSetupColumn("Prop", ImGuiTableColumnFlags_WidthFixed,
                                  56.0f);
          ImGui::TableSetupColumn("Val", ImGuiTableColumnFlags_WidthStretch);
 
          // ID
          gui::LayoutHelpers::PropertyRow("ID", [&]() {
            uint16_t obj_id = static_cast<uint16_t>(obj.id_ & 0x0FFF);
            if (auto res =
                    gui::InputHexWordEx("##SelObjId", &obj_id, 80.0f, true);
                res.ShouldApply()) {
              obj_id &= 0x0FFF;
              interaction.SetObjectId(idx, static_cast<int16_t>(obj_id));
            }
          });
 
          // Position
          gui::LayoutHelpers::PropertyRow("Pos", [&]() {
            int pos_x = obj.x_;
            int pos_y = obj.y_;
            ImGui::SetNextItemWidth(60);
            bool x_changed =
                ImGui::DragInt("##SelObjX", &pos_x, 0.1f, 0, 63, "X:%d");
            {
              gui::AutoWidgetScope automation_scope("Dungeon/Workbench");
              gui::AutoRegisterLastItem("drag_int", "selected_object_x",
                                        "Selected room object X coordinate");
            }
            ImGui::SameLine();
            ImGui::SetNextItemWidth(60);
            bool y_changed =
                ImGui::DragInt("##SelObjY", &pos_y, 0.1f, 0, 63, "Y:%d");
            {
              gui::AutoWidgetScope automation_scope("Dungeon/Workbench");
              gui::AutoRegisterLastItem("drag_int", "selected_object_y",
                                        "Selected room object Y coordinate");
            }
            if (x_changed || y_changed) {
              int delta_x = pos_x - obj.x_;
              int delta_y = pos_y - obj.y_;
              interaction.entity_coordinator().tile_handler().MoveObjects(
                  room_id, {idx}, delta_x, delta_y);
            }
          });
 
          uint8_t requested_size = obj.size_;
          if (workbench::DrawObjectSizeControls(obj, &requested_size)) {
            interaction.SetObjectSize(idx, requested_size);
          }
 
          gui::LayoutHelpers::PropertyRow(
              uses_room_stream ? "Stream" : "Layer", [&]() {
                int layer = displayed_layer;
                const char* stream_names[] = {"Primary", "BG2 overlay",
                                              "BG1 overlay"};
                const char* special_layer_names[] = {"Upper layer (BG1)",
                                                     "Lower layer (BG2)"};
                ImGui::SetNextItemWidth(-1);
                if (ImGui::Combo(
                        "##SelObjLayer", &layer,
                        uses_room_stream ? stream_names : special_layer_names,
                        uses_room_stream ? IM_ARRAYSIZE(stream_names)
                                         : IM_ARRAYSIZE(special_layer_names))) {
                  const int max_layer = uses_room_stream ? 2 : 1;
                  layer = std::clamp(layer, 0, max_layer);
                  if (interaction.SetObjectLayer(
                          idx,
                          static_cast<zelda3::RoomObject::LayerType>(layer))) {
                    displayed_layer = layer;
                  }
                }
              });
          gui::LayoutHelpers::PropertyRow("Route", [&]() {
            ImGui::TextDisabled(
                "%s", uses_room_stream ? GetObjectStreamName(displayed_layer)
                                       : GetSpecialLayerName(displayed_layer));
          });
 
          // Pixel coords (read-only info)
          gui::LayoutHelpers::PropertyRow("Pixel", [&]() {
            ImGui::TextDisabled("(%d, %d)", pixel_x, pixel_y);
          });
 
          ImGui::EndTable();
        }
        const auto description = workbench::DescribeObjectSize(obj);
        if (!description.wheel_hint.empty()) {
          ImGui::TextWrapped("%s", description.wheel_hint.c_str());
        }
        // Actions can reallocate the room's object vector; no object references
        // are used after this point.
        const auto current_indices = interaction.GetSelectedObjectIndices();
        if (current_indices.size() == 1) {
          DrawSelectedObjectActions(viewer, current_indices.front());
        }
      }
    }
  }
 
  if (has_entity) {
    workbench::DrawInspectorSectionHeader(ICON_MD_SELECT_ALL
                                          " Entity Selection");
    DrawDungeonEntityInspector(viewer);
  }
}
 
}  // namespace yaze::editor