tile_selector_widget.cc

Go to the documentation of this file.

#include "app/gui/widgets/tile_selector_widget.h"
#include "util/i18n/tr.h"
 
#include <algorithm>
#include <cmath>
#include <cstdio>
 
#include "absl/strings/str_format.h"
#include "app/gui/automation/widget_id_registry.h"
#include "app/gui/core/drag_drop.h"
#include "app/gui/core/icons.h"
 
namespace yaze::gui {
 
namespace {
 
std::string_view TrimAsciiWhitespace(std::string_view s) {
  while (!s.empty() && (s.front() == ' ' || s.front() == '\t' ||
                        s.front() == '\n' || s.front() == '\r')) {
    s.remove_prefix(1);
  }
  while (!s.empty() && (s.back() == ' ' || s.back() == '\t' ||
                        s.back() == '\n' || s.back() == '\r')) {
    s.remove_suffix(1);
  }
  return s;
}
 
// Parse tile-id text using hex by default, with explicit decimal support via
// "d:<value>".
bool ParseTileIdText(std::string_view input, int* out_value) {
  if (!out_value) {
    return false;
  }
 
  std::string_view trimmed = TrimAsciiWhitespace(input);
  if (trimmed.empty()) {
    return false;
  }
 
  bool decimal_mode = false;
  if (trimmed.size() >= 2 && (trimmed[0] == 'd' || trimmed[0] == 'D') &&
      trimmed[1] == ':') {
    decimal_mode = true;
    trimmed.remove_prefix(2);
  } else if (trimmed.size() >= 2 && trimmed[0] == '0' &&
             (trimmed[1] == 'x' || trimmed[1] == 'X')) {
    trimmed.remove_prefix(2);
  }
 
  if (trimmed.empty()) {
    return false;
  }
 
  std::string text(trimmed);
  unsigned int parsed = 0;
  char trailing = '\0';
  const char* format = decimal_mode ? "%u%c" : "%x%c";
  if (std::sscanf(text.c_str(), format, &parsed, &trailing) != 1) {
    return false;
  }
 
  *out_value = static_cast<int>(parsed);
  return true;
}
 
}  // namespace
 
TileSelectorWidget::TileSelectorWidget(std::string widget_id)
    : config_(),
      total_tiles_(config_.total_tiles),
      widget_id_(std::move(widget_id)) {}
 
TileSelectorWidget::TileSelectorWidget(std::string widget_id, Config config)
    : config_(config),
      total_tiles_(config.total_tiles),
      widget_id_(std::move(widget_id)) {
  SetDisplayScale(config.display_scale);
}
 
void TileSelectorWidget::AttachCanvas(Canvas* canvas) {
  canvas_ = canvas;
}
 
void TileSelectorWidget::SetTileCount(int total_tiles) {
  const int previous_total = total_tiles_;
  total_tiles_ = std::max(total_tiles, 0);
  if (display_order_active_ && total_tiles_ != previous_total) {
    SetDisplayOrder(std::move(display_order_));
  }
  if (!IsValidTileId(selected_tile_id_)) {
    selected_tile_id_ = 0;
  }
  if (last_jump_result_ == JumpToTileResult::kOutOfRange &&
      IsValidTileId(selected_tile_id_)) {
    last_jump_result_ = JumpToTileResult::kSuccess;
  }
}
 
void TileSelectorWidget::SetDisplayScale(float display_scale) {
  if (display_scale <= 0.0f || config_.tile_size <= 0) {
    return;
  }
  // Whole-pixel cells keep the grid, highlight and hit testing on the atlas's
  // tile edges at every row; fractional cells drift as the grid scrolls.
  const float tile_size = static_cast<float>(config_.tile_size);
  const float cell = std::max(1.0f, std::floor(tile_size * display_scale));
  config_.display_scale = cell / tile_size;
}
 
float TileSelectorWidget::TileCellSize() const {
  return config_.tile_size * config_.display_scale;
}
 
void TileSelectorWidget::SetTilesPerRow(int tiles_per_row) {
  if (tiles_per_row > 0) {
    config_.tiles_per_row = tiles_per_row;
  }
}
 
void TileSelectorWidget::SetSelectedTile(int tile_id) {
  if (IsValidTileId(tile_id)) {
    selected_tile_id_ = tile_id;
    last_jump_result_ = JumpToTileResult::kSuccess;
  }
}
 
namespace {
 
float GridWidthFor(const TileSelectorWidget::Config& config) {
  const float cell =
      std::max(1.0f, std::floor(config.tile_size * config.display_scale));
  return config.tiles_per_row * cell + config.draw_offset.x * 2;
}
 
}  // namespace
 
void TileSelectorWidget::SetDisplayOrder(std::vector<int> order) {
  cell_of_tile_.assign(total_tiles_, -1);
  display_order_.clear();
  display_order_.reserve(order.size());
  for (const int tile_id : order) {
    if (IsValidTileId(tile_id) && cell_of_tile_[tile_id] < 0) {
      cell_of_tile_[tile_id] = static_cast<int>(display_order_.size());
      display_order_.push_back(tile_id);
    }
  }
  display_order_active_ = true;
}
 
void TileSelectorWidget::ClearDisplayOrder() {
  display_order_active_ = false;
  display_order_.clear();
  cell_of_tile_.clear();
}
 
int TileSelectorWidget::CellCount() const {
  return display_order_active_ ? static_cast<int>(display_order_.size())
                               : total_tiles_;
}
 
int TileSelectorWidget::TileAtCell(int cell) const {
  if (cell < 0 || cell >= CellCount()) {
    return -1;
  }
  return display_order_active_ ? display_order_[cell] : cell;
}
 
int TileSelectorWidget::CellOfTile(int tile_id) const {
  if (!IsValidTileId(tile_id)) {
    return -1;
  }
  return display_order_active_ ? cell_of_tile_[tile_id] : tile_id;
}
 
ImVec2 TileSelectorWidget::GetGridContentSize() const {
  const int num_rows =
      (CellCount() + config_.tiles_per_row - 1) / config_.tiles_per_row;
  return ImVec2(GridWidthFor(config_),
                num_rows * TileCellSize() + config_.draw_offset.y * 2);
}
 
float TileSelectorWidget::CurrentScrollbarSize() {
  // ImGuiStyle's default; used when no context exists (layout unit tests).
  constexpr float kImGuiDefaultScrollbarSize = 14.0f;
  return ImGui::GetCurrentContext() ? ImGui::GetStyle().ScrollbarSize
                                    : kImGuiDefaultScrollbarSize;
}
 
float TileSelectorWidget::PreferredViewportWidth(const Config& config,
                                                 float scrollbar_size) {
  // Filter-bar controls wrap compactly when the available width is tight
  // (see DrawFilterBar); they must not inflate the preferred width.
  return GridWidthFor(config) + scrollbar_size;
}
 
float TileSelectorWidget::GetPreferredViewportWidth() const {
  return PreferredViewportWidth(config_, CurrentScrollbarSize());
}
 
TileSelectorWidget::RenderResult TileSelectorWidget::Render(gfx::Bitmap& atlas,
                                                            bool atlas_ready) {
  RenderResult result;
 
  if (!canvas_) {
    return result;
  }
 
  const float tile_display_size = TileCellSize();
  const ImVec2 content_size = GetGridContentSize();
 
  // Set content size for ImGui child window (must be called before
  // DrawBackground)
  ImGui::SetCursorPos(ImVec2(0, 0));
  ImGui::Dummy(content_size);
  ImGui::SetCursorPos(ImVec2(0, 0));
 
  // Handle pending scroll (deferred from ScrollToTile call outside render
  // context)
  if (pending_scroll_tile_id_ >= 0) {
    if (CellOfTile(pending_scroll_tile_id_) >= 0) {
      const ImVec2 target = TileOrigin(pending_scroll_tile_id_);
      if (pending_scroll_use_imgui_) {
        const ImVec2 window_size = ImGui::GetWindowSize();
        float scroll_x =
            target.x - (window_size.x / 2.0f) + (tile_display_size / 2.0f);
        float scroll_y =
            target.y - (window_size.y / 2.0f) + (tile_display_size / 2.0f);
        scroll_x = std::max(0.0f, scroll_x);
        scroll_y = std::max(0.0f, scroll_y);
        ImGui::SetScrollX(scroll_x);
        ImGui::SetScrollY(scroll_y);
      }
    }
    pending_scroll_tile_id_ = -1;  // Clear pending scroll
  }
 
  canvas_->DrawBackground();
 
  if (atlas_ready && atlas.is_active()) {
    if (display_order_active_) {
      DrawOrderedTiles(atlas, tile_display_size);
    } else {
      canvas_->DrawBitmap(atlas, static_cast<int>(config_.draw_offset.x),
                          static_cast<int>(config_.draw_offset.y),
                          config_.display_scale);
    }
 
    result = HandleInteraction(tile_display_size);
 
    // Hover tooltip: show tile ID and zoomed preview
    if (config_.show_hover_tooltip && ImGui::IsItemHovered()) {
      int hovered_tile = ResolveTileAtCursor(tile_display_size);
      if (IsValidTileId(hovered_tile)) {
        ImGui::BeginTooltip();
        ImGui::Text(tr("Tile %d (0x%03X)"), hovered_tile, hovered_tile);
        if (hover_detail_) {
          const std::string detail = hover_detail_(hovered_tile);
          if (!detail.empty()) {
            ImGui::TextUnformatted(detail.c_str());
          }
        }
 
        // Extract and draw a zoomed preview of the hovered tile
        int tile_col = hovered_tile % config_.tiles_per_row;
        int tile_row = hovered_tile / config_.tiles_per_row;
        int src_x = tile_col * config_.tile_size;
        int src_y = tile_row * config_.tile_size;
 
        // Use ImGui texture coords for the atlas to show the tile zoomed
        auto* texture_id = atlas.texture();
        if (texture_id != nullptr) {
          float atlas_w = static_cast<float>(atlas.width());
          float atlas_h = static_cast<float>(atlas.height());
          if (atlas_w > 0 && atlas_h > 0) {
            ImVec2 uv0(src_x / atlas_w, src_y / atlas_h);
            ImVec2 uv1((src_x + config_.tile_size) / atlas_w,
                       (src_y + config_.tile_size) / atlas_h);
            float preview_size = config_.tile_size * 4.0f;
            ImGui::Image((ImTextureID)(intptr_t)texture_id,
                         ImVec2(preview_size, preview_size), uv0, uv1);
          }
        }
 
        ImGui::EndTooltip();
      }
    }
 
    if (config_.show_tile_ids) {
      DrawTileIdLabels(tile_display_size);
    }
 
    DrawGridLines(tile_display_size);
    DrawHighlight(tile_display_size);
  }
 
  canvas_->DrawContextMenu();
  canvas_->DrawOverlay();
 
  return result;
}
 
CanvasMenuItem TileSelectorWidget::CopyTileIdMenuItem() const {
  CanvasMenuItem item("Copy Tile ID", ICON_MD_CONTENT_COPY, [this]() {
    if (IsValidTileId(selected_tile_id_)) {
      ImGui::SetClipboardText(
          absl::StrFormat("0x%03X", selected_tile_id_).c_str());
    }
  });
  item.enabled_condition = [this]() {
    return IsValidTileId(selected_tile_id_);
  };
  return item;
}
 
TileSelectorWidget::RenderResult TileSelectorWidget::HandleInteraction(
    float tile_display_size) {
  RenderResult result;
 
  if (!ImGui::IsItemHovered()) {
    return result;
  }
 
  const bool clicked = ImGui::IsMouseClicked(ImGuiMouseButton_Left);
  const bool double_clicked =
      ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left);
  const bool right_clicked = ImGui::IsMouseClicked(ImGuiMouseButton_Right);
 
  if (clicked || double_clicked || right_clicked) {
    const int hovered_tile = ResolveTileAtCursor(tile_display_size);
    if (IsValidTileId(hovered_tile) && IsInFilterRange(hovered_tile)) {
      result.tile_clicked = clicked;
      result.tile_double_clicked = double_clicked;
      result.tile_right_clicked = right_clicked;
      if (hovered_tile != selected_tile_id_) {
        selected_tile_id_ = hovered_tile;
        result.selection_changed = true;
      }
      result.selected_tile = selected_tile_id_;
    }
  }
 
  // Emit drag source for the selected tile when dragging is enabled
  if (config_.enable_drag && IsValidTileId(selected_tile_id_)) {
    result.tile_dragging =
        BeginTileDragSource(selected_tile_id_, config_.drag_source_map_id);
  }
 
  return result;
}
 
int TileSelectorWidget::ResolveTileAtCursor(float tile_display_size) const {
  if (!canvas_ || tile_display_size <= 0.0f) {
    return -1;
  }
 
  const ImVec2 screen_pos = ImGui::GetIO().MousePos;
  const ImVec2 origin = canvas_->zero_point();
  const ImVec2 scroll = canvas_->scrolling();
 
  // Convert screen position to canvas content position (accounting for scroll)
  ImVec2 local =
      ImVec2(screen_pos.x - origin.x - config_.draw_offset.x - scroll.x,
             screen_pos.y - origin.y - config_.draw_offset.y - scroll.y);
 
  if (local.x < 0.0f || local.y < 0.0f) {
    return -1;
  }
 
  const int column = static_cast<int>(local.x / tile_display_size);
  const int row = static_cast<int>(local.y / tile_display_size);
  if (column >= config_.tiles_per_row) {
    return -1;
  }
 
  return TileAtCell(row * config_.tiles_per_row + column);
}
 
ImVec2 TileSelectorWidget::GridScreenOrigin() const {
  const ImVec2 origin = canvas_->zero_point();
  const ImVec2 scroll = canvas_->scrolling();
  return ImVec2(origin.x + scroll.x + config_.draw_offset.x,
                origin.y + scroll.y + config_.draw_offset.y);
}
 
std::pair<int, int> TileSelectorWidget::VisibleRows(
    float tile_display_size) const {
  ImDrawList* draw_list = canvas_ ? canvas_->draw_list() : nullptr;
  if (!draw_list || tile_display_size <= 0.0f || config_.tiles_per_row <= 0) {
    return {0, 0};
  }
  const int num_rows =
      (CellCount() + config_.tiles_per_row - 1) / config_.tiles_per_row;
  const float grid_top = GridScreenOrigin().y;
  const int first_row = std::clamp(
      static_cast<int>(std::floor((draw_list->GetClipRectMin().y - grid_top) /
                                  tile_display_size)),
      0, num_rows);
  const int last_row = std::clamp(
      static_cast<int>(std::ceil((draw_list->GetClipRectMax().y - grid_top) /
                                 tile_display_size)),
      0, num_rows);
  return {first_row, last_row};
}
 
void TileSelectorWidget::DrawOrderedTiles(gfx::Bitmap& atlas,
                                          float tile_display_size) const {
  ImDrawList* draw_list = canvas_ ? canvas_->draw_list() : nullptr;
  if (!draw_list || atlas.texture() == nullptr || atlas.width() <= 0 ||
      atlas.height() <= 0 || config_.tile_size <= 0) {
    return;
  }
  const int atlas_columns = std::max(1, atlas.width() / config_.tile_size);
  const float atlas_w = static_cast<float>(atlas.width());
  const float atlas_h = static_cast<float>(atlas.height());
  const ImVec2 grid_min = GridScreenOrigin();
  const auto [first_row, last_row] = VisibleRows(tile_display_size);
  const int last_cell = std::min(last_row * config_.tiles_per_row, CellCount());
  for (int cell = first_row * config_.tiles_per_row; cell < last_cell; ++cell) {
    const int tile_id = display_order_[cell];
    const float src_x =
        static_cast<float>((tile_id % atlas_columns) * config_.tile_size);
    const float src_y =
        static_cast<float>((tile_id / atlas_columns) * config_.tile_size);
    const ImVec2 dst_min(
        grid_min.x + (cell % config_.tiles_per_row) * tile_display_size,
        grid_min.y + (cell / config_.tiles_per_row) * tile_display_size);
    draw_list->AddImage(
        (ImTextureID)(intptr_t)atlas.texture(), dst_min,
        ImVec2(dst_min.x + tile_display_size, dst_min.y + tile_display_size),
        ImVec2(src_x / atlas_w, src_y / atlas_h),
        ImVec2((src_x + config_.tile_size) / atlas_w,
               (src_y + config_.tile_size) / atlas_h));
  }
}
 
void TileSelectorWidget::DrawGridLines(float tile_display_size) const {
  ImDrawList* draw_list = canvas_ ? canvas_->draw_list() : nullptr;
  if (!draw_list || !canvas_->GetConfig().enable_grid ||
      tile_display_size <= 0.0f || config_.tiles_per_row <= 0) {
    return;
  }
 
  const int num_rows =
      (CellCount() + config_.tiles_per_row - 1) / config_.tiles_per_row;
  const ImVec2 grid_min = GridScreenOrigin();
  const ImVec2 grid_max(grid_min.x + config_.tiles_per_row * tile_display_size,
                        grid_min.y + num_rows * tile_display_size);
 
  // Only the rows inside the scrolling child's clip rect are emitted.
  const auto [first_row, last_row] = VisibleRows(tile_display_size);
  if (first_row >= last_row) {
    return;
  }
 
  constexpr ImU32 kGridColor = IM_COL32(200, 200, 200, 50);
  const float top = grid_min.y + first_row * tile_display_size;
  const float bottom = grid_min.y + last_row * tile_display_size;
  for (int column = 0; column <= config_.tiles_per_row; ++column) {
    const float x = grid_min.x + column * tile_display_size;
    draw_list->AddLine(ImVec2(x, top), ImVec2(x, bottom), kGridColor);
  }
  for (int row = first_row; row <= last_row; ++row) {
    const float y = grid_min.y + row * tile_display_size;
    draw_list->AddLine(ImVec2(grid_min.x, y), ImVec2(grid_max.x, y),
                       kGridColor);
  }
}
 
void TileSelectorWidget::DrawHighlight(float tile_display_size) const {
  ImDrawList* draw_list = canvas_ ? canvas_->draw_list() : nullptr;
  const int cell = CellOfTile(selected_tile_id_);
  if (!draw_list || cell < 0) {
    return;
  }
 
  const int column = cell % config_.tiles_per_row;
  const int row = cell / config_.tiles_per_row;
  const ImVec2 grid_min = GridScreenOrigin();
  const ImVec2 tile_min(grid_min.x + column * tile_display_size,
                        grid_min.y + row * tile_display_size);
  const ImVec2 tile_max(tile_min.x + tile_display_size,
                        tile_min.y + tile_display_size);
  draw_list->AddRect(tile_min, tile_max,
                     ImGui::ColorConvertFloat4ToU32(config_.highlight_color),
                     0.0f, 0, 1.5f);
}
 
void TileSelectorWidget::DrawTileIdLabels(float) const {
  // Future enhancement: draw ImGui text overlay with tile indices.
}
 
void TileSelectorWidget::ScrollToTile(int tile_id, bool use_imgui_scroll) {
  if (!canvas_ || !IsValidTileId(tile_id)) {
    return;
  }
 
  // Defer scroll until next render (when we're in the correct ImGui window
  // context)
  pending_scroll_tile_id_ = tile_id;
  pending_scroll_use_imgui_ = use_imgui_scroll;
}
 
ImVec2 TileSelectorWidget::TileOrigin(int tile_id) const {
  const int cell = CellOfTile(tile_id);
  if (cell < 0) {
    return ImVec2(-1, -1);
  }
  const float tile_display_size = TileCellSize();
  const int column = cell % config_.tiles_per_row;
  const int row = cell / config_.tiles_per_row;
  return ImVec2(config_.draw_offset.x + column * tile_display_size,
                config_.draw_offset.y + row * tile_display_size);
}
 
TileSelectorWidget::JumpToTileResult TileSelectorWidget::JumpToTileFromInput(
    std::string_view input) {
  int tile_id = -1;
  if (!ParseTileIdText(input, &tile_id)) {
    last_jump_result_ = JumpToTileResult::kInvalidFormat;
    return last_jump_result_;
  }
 
  if (!IsValidTileId(tile_id)) {
    last_jump_result_ = JumpToTileResult::kOutOfRange;
    return last_jump_result_;
  }
 
  selected_tile_id_ = tile_id;
  ScrollToTile(tile_id, true);
  last_jump_result_ = JumpToTileResult::kSuccess;
  return last_jump_result_;
}
 
bool TileSelectorWidget::DrawFilterBar() {
  ImGui::PushID(widget_id_.c_str());
  const bool compact = ImGui::GetContentRegionAvail().x < 115.0f;
  const char* label =
      compact ? (filter_range_active_ ? ICON_MD_FILTER_ALT "*" : ICON_MD_SEARCH)
              : (filter_range_active_ ? "Find / Filter*" : "Find / Filter");
  if (ImGui::Button(label)) {
    ImGui::OpenPopup("TileLookup");
  }
  WidgetIdRegistry::Instance().RegisterWidget(widget_id_ + "/button:Lookup",
                                              "button", ImGui::GetItemID());
  if (ImGui::IsItemHovered()) {
    ImGui::SetTooltip("Jump to a tile ID or filter a range%s",
                      filter_range_active_ ? " (range filter active)" : "");
  }
  bool jumped = false;
  ImGui::SetNextWindowSizeConstraints(ImVec2(300.0f, 0.0f),
                                      ImVec2(380.0f, 500.0f));
  if (ImGui::BeginPopup("TileLookup")) {
    jumped = DrawFilterControls();
    if (jumped) {
      ImGui::CloseCurrentPopup();
    }
    ImGui::EndPopup();
  }
  ImGui::PopID();
  return jumped;
}
 
bool TileSelectorWidget::DrawFilterControls() {
  bool jumped = false;
  const int max_tile_id = GetMaxTileId();
  const float available_width =
      std::max(ImGui::GetContentRegionAvail().x, 1.0f);
  const bool compact_layout = available_width < 420.0f;
  const float jump_input_width =
      compact_layout ? std::clamp(available_width * 0.28f, 56.0f, 88.0f)
                     : 64.0f;
  const float range_input_width =
      compact_layout
          ? std::clamp((available_width - 110.0f) * 0.5f, 56.0f, 88.0f)
          : 64.0f;
 
  constexpr ImGuiInputTextFlags kInputFlags =
      ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_AutoSelectAll;
 
  ImGui::PushID(widget_id_.c_str());
 
  // Jump-to-ID input
  ImGui::AlignTextToFramePadding();
  ImGui::TextUnformatted(tr("Go:"));
  ImGui::SameLine();
 
  ImGui::SetNextItemWidth(jump_input_width);
  if (ImGui::InputText("##TileFilterID", filter_buf_, sizeof(filter_buf_),
                       kInputFlags)) {
    switch (JumpToTileFromInput(filter_buf_)) {
      case JumpToTileResult::kSuccess:
        jumped = true;
        break;
      case JumpToTileResult::kInvalidFormat:
      case JumpToTileResult::kOutOfRange:
        break;
    }
  }
  WidgetIdRegistry::Instance().RegisterWidget(widget_id_ + "/input:TileID",
                                              "input", ImGui::GetItemID());
  if (ImGui::IsItemHovered()) {
    ImGui::SetTooltip(
        tr("Enter tile ID and press Enter:\n"
           "hex: 1A or 0x1A\n"
           "decimal: d:26"));
  }
 
  ImGui::SameLine();
  ImGui::TextDisabled(tr("/ 0x%03X"), max_tile_id);
 
  if (last_jump_result_ == JumpToTileResult::kInvalidFormat) {
    ImGui::TextUnformatted(tr("Invalid tile ID (hex or d:decimal)"));
  } else if (last_jump_result_ == JumpToTileResult::kOutOfRange) {
    ImGui::Text(tr("Out of range (max: 0x%03X)"), max_tile_id);
  }
 
  // Range filter inputs
  if (!compact_layout) {
    ImGui::SameLine(0, 12.0f);
  }
  ImGui::AlignTextToFramePadding();
  ImGui::TextUnformatted(tr("Range:"));
  ImGui::SameLine();
 
  bool range_changed = false;
  ImGui::SetNextItemWidth(range_input_width);
  if (ImGui::InputText("##RangeMin", filter_min_buf_, sizeof(filter_min_buf_),
                       kInputFlags)) {
    range_changed = true;
  }
  WidgetIdRegistry::Instance().RegisterWidget(widget_id_ + "/input:RangeMin",
                                              "input", ImGui::GetItemID());
  if (ImGui::IsItemHovered()) {
    ImGui::SetTooltip(
        tr("Min tile ID. Press Enter to apply.\n"
           "hex: 1A or 0x1A\n"
           "decimal: d:26"));
  }
  ImGui::SameLine();
  ImGui::TextUnformatted("-");
  ImGui::SameLine();
  ImGui::SetNextItemWidth(range_input_width);
  if (ImGui::InputText("##RangeMax", filter_max_buf_, sizeof(filter_max_buf_),
                       kInputFlags)) {
    range_changed = true;
  }
  WidgetIdRegistry::Instance().RegisterWidget(widget_id_ + "/input:RangeMax",
                                              "input", ImGui::GetItemID());
  if (ImGui::IsItemHovered()) {
    ImGui::SetTooltip(
        tr("Max tile ID. Press Enter to apply.\n"
           "hex: 1A or 0x1A\n"
           "decimal: d:26"));
  }
  if (!compact_layout) {
    ImGui::SameLine();
    ImGui::TextDisabled(tr("(hex, d:dec)"));
  }  // Compact: the input tooltips carry the format hint.
 
  if (range_changed) {
    int parsed_min = 0;
    int parsed_max = 0;
    bool has_min = ParseTileIdText(filter_min_buf_, &parsed_min);
    bool has_max = ParseTileIdText(filter_max_buf_, &parsed_max);
 
    if (has_min && has_max && parsed_min <= parsed_max) {
      SetRangeFilter(parsed_min, parsed_max);
      filter_range_error_ = false;
      if (filter_range_active_) {
        filter_out_of_range_ = false;
        ScrollToTile(filter_range_min_, true);
      } else {
        // SetRangeFilter returned early: both values exceeded total_tiles_.
        filter_out_of_range_ = true;
      }
    } else if (!has_min && !has_max) {
      ClearRangeFilter();
      filter_range_error_ = false;
      filter_out_of_range_ = false;
    } else if (has_min && has_max && parsed_min > parsed_max) {
      // Invalid range: min must be ≤ max
      filter_range_error_ = true;
      filter_out_of_range_ = false;
    }
  }
 
  // Clear button when range is active
  if (filter_range_active_) {
    if (!compact_layout) {
      ImGui::SameLine();
    }
    if (ImGui::SmallButton(tr("X##ClearRange"))) {
      ClearRangeFilter();
      filter_min_buf_[0] = '\0';
      filter_max_buf_[0] = '\0';
      filter_range_error_ = false;
    }
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip(tr("Clear range filter"));
    }
  }
 
  // Validation feedback (shown inline after the filter inputs)
  if (filter_range_error_) {
    if (!compact_layout) {
      ImGui::SameLine(0, 8.0f);
    }
    ImGui::TextColored(ImVec4(1.0f, 0.4f, 0.4f, 1.0f),
                       tr("Min must be <= Max"));
  } else if (filter_out_of_range_) {
    if (!compact_layout) {
      ImGui::SameLine(0, 8.0f);
    }
    ImGui::TextColored(ImVec4(1.0f, 0.4f, 0.4f, 1.0f),
                       tr("Out of range (max: 0x%03X)"), GetMaxTileId());
  } else if (filter_range_active_) {
    int range_count = filter_range_max_ - filter_range_min_ + 1;
    if (range_count <= 0) {
      if (!compact_layout) {
        ImGui::SameLine(0, 8.0f);
      }
      ImGui::TextDisabled(tr("(no tiles in range)"));
    }
  }
 
  ImGui::PopID();
 
  return jumped;
}
 
void TileSelectorWidget::SetRangeFilter(int min_id, int max_id) {
  if (min_id < 0)
    min_id = 0;
  if (max_id >= total_tiles_)
    max_id = total_tiles_ - 1;
  if (min_id > max_id)
    return;
 
  filter_range_active_ = true;
  filter_range_min_ = min_id;
  filter_range_max_ = max_id;
  filter_range_error_ = false;
}
 
void TileSelectorWidget::ClearRangeFilter() {
  filter_range_active_ = false;
  filter_range_min_ = 0;
  filter_range_max_ = 0;
  filter_range_error_ = false;
  filter_out_of_range_ = false;
}
 
bool TileSelectorWidget::IsValidTileId(int tile_id) const {
  return tile_id >= 0 && tile_id < total_tiles_;
}
 
bool TileSelectorWidget::IsInFilterRange(int tile_id) const {
  if (!filter_range_active_)
    return true;
  return tile_id >= filter_range_min_ && tile_id <= filter_range_max_;
}
 
}  // namespace yaze::gui