input.cc

Go to the documentation of this file.

#include "input.h"
#include "util/i18n/tr.h"
 
#include <algorithm>
#include <array>
#include <cstring>
#include <functional>
#include <limits>
#include <string>
#include <unordered_map>
#include <variant>
 
#include "absl/strings/string_view.h"
#include "app/gfx/types/snes_tile.h"
#include "app/gui/imgui_memory_editor.h"
#include "imgui/imgui.h"
#include "imgui/imgui_internal.h"
 
#ifdef __EMSCRIPTEN__
#include <emscripten.h>
#endif
 
template <class... Ts>
struct overloaded : Ts... {
  using Ts::operator()...;
};
template <class... Ts>
overloaded(Ts...) -> overloaded<Ts...>;
 
namespace ImGui {
 
static inline ImGuiInputTextFlags InputScalar_DefaultCharsFilter(
    ImGuiDataType data_type, const char* format) {
  if (data_type == ImGuiDataType_Float || data_type == ImGuiDataType_Double)
    return ImGuiInputTextFlags_CharsScientific;
  const char format_last_char = format[0] ? format[strlen(format) - 1] : 0;
  return (format_last_char == 'x' || format_last_char == 'X')
             ? ImGuiInputTextFlags_CharsHexadecimal
             : ImGuiInputTextFlags_CharsDecimal;
}
 
// Helper: returns true if label is "invisible" (starts with "##")
static inline bool IsInvisibleLabel(const char* label) {
  return label && label[0] == '#' && label[1] == '#';
}
 
// Result struct for extended input functions
struct InputScalarResult {
  bool changed;         // Any change occurred
  bool immediate;       // Change was from button/wheel (apply immediately)
  bool text_changed;    // Change was from text input
  bool text_committed;  // Text input was committed (deactivated after edit)
};
 
bool InputScalarLeft(const char* label, ImGuiDataType data_type, void* p_data,
                     const void* p_step, const void* p_step_fast,
                     const char* format, float input_width,
                     ImGuiInputTextFlags flags, bool no_step = false) {
  InputScalarResult result = {};
  // Call extended version and return simple bool
  // (implementation below handles both)
 
  ImGuiWindow* window = ImGui::GetCurrentWindow();
  if (window->SkipItems)
    return false;
 
  ImGuiContext& g = *GImGui;
  ImGuiStyle& style = g.Style;
 
  if (format == NULL)
    format = DataTypeGetInfo(data_type)->PrintFmt;
 
  char buf[64];
  DataTypeFormatString(buf, IM_ARRAYSIZE(buf), data_type, p_data, format);
 
  if (g.ActiveId == 0 && (flags & (ImGuiInputTextFlags_CharsDecimal |
                                   ImGuiInputTextFlags_CharsHexadecimal |
                                   ImGuiInputTextFlags_CharsScientific)) == 0)
    flags |= InputScalar_DefaultCharsFilter(data_type, format);
  flags |= ImGuiInputTextFlags_AutoSelectAll;
 
  bool value_changed = false;
  const float button_size = GetFrameHeight();
 
  // Support invisible labels (##) by not rendering the label, but still using
  // it for ID
  bool invisible_label = IsInvisibleLabel(label);
 
  if (!invisible_label) {
    AlignTextToFramePadding();
    Text("%s", label);
    SameLine();
  }
 
  BeginGroup();  // The only purpose of the group here is to allow the caller
                 // to query item data e.g. IsItemActive()
  PushID(label);
  SetNextItemWidth(ImMax(
      1.0f, CalcItemWidth() - (button_size + style.ItemInnerSpacing.x) * 2));
 
  // Place the label on the left of the input field, unless invisible
  PushStyleVar(ImGuiStyleVar_ItemSpacing,
               ImVec2{style.ItemSpacing.x, style.ItemSpacing.y});
  PushStyleVar(ImGuiStyleVar_FramePadding,
               ImVec2{style.FramePadding.x, style.FramePadding.y});
 
  SetNextItemWidth(input_width);
  if (InputText("", buf, IM_ARRAYSIZE(buf),
                flags))  // PushId(label) + "" gives us the expected ID
                         // from outside point of view
    value_changed = DataTypeApplyFromText(buf, data_type, p_data, format);
  IMGUI_TEST_ENGINE_ITEM_INFO(
      g.LastItemData.ID, label,
      g.LastItemData.StatusFlags | ImGuiItemStatusFlags_Inputable);
 
  // The mouse wheel is applied by the typed yaze::gui wrappers
  // (ApplyHexMouseWheel), which know the value's type and range.
 
  // Step buttons
  if (!no_step) {
    const ImVec2 backup_frame_padding = style.FramePadding;
    style.FramePadding.x = style.FramePadding.y;
    ImGuiButtonFlags button_flags = ImGuiButtonFlags_PressedOnClick;
    if (flags & ImGuiInputTextFlags_ReadOnly)
      BeginDisabled();
    SameLine(0, style.ItemInnerSpacing.x);
    if (ButtonEx("-", ImVec2(button_size, button_size), button_flags)) {
      DataTypeApplyOp(data_type, '-', p_data, p_data,
                      g.IO.KeyCtrl && p_step_fast ? p_step_fast : p_step);
      value_changed = true;
    }
    SameLine(0, style.ItemInnerSpacing.x);
    if (ButtonEx("+", ImVec2(button_size, button_size), button_flags)) {
      DataTypeApplyOp(data_type, '+', p_data, p_data,
                      g.IO.KeyCtrl && p_step_fast ? p_step_fast : p_step);
      value_changed = true;
    }
 
    if (flags & ImGuiInputTextFlags_ReadOnly)
      EndDisabled();
 
    style.FramePadding = backup_frame_padding;
  }
  PopID();
  EndGroup();
  ImGui::PopStyleVar(2);
 
  if (value_changed)
    MarkItemEdited(g.LastItemData.ID);
 
  return value_changed;
}
 
// Extended version that tracks change source
InputScalarResult InputScalarLeftEx(const char* label, ImGuiDataType data_type,
                                    void* p_data, const void* p_step,
                                    const void* p_step_fast, const char* format,
                                    float input_width,
                                    ImGuiInputTextFlags flags,
                                    bool no_step = false) {
  InputScalarResult result = {false, false, false, false};
 
  ImGuiWindow* window = ImGui::GetCurrentWindow();
  if (window->SkipItems)
    return result;
 
  ImGuiContext& g = *GImGui;
  ImGuiStyle& style = g.Style;
 
  if (format == NULL)
    format = DataTypeGetInfo(data_type)->PrintFmt;
 
  char buf[64];
  DataTypeFormatString(buf, IM_ARRAYSIZE(buf), data_type, p_data, format);
 
  if (g.ActiveId == 0 && (flags & (ImGuiInputTextFlags_CharsDecimal |
                                   ImGuiInputTextFlags_CharsHexadecimal |
                                   ImGuiInputTextFlags_CharsScientific)) == 0)
    flags |= InputScalar_DefaultCharsFilter(data_type, format);
  flags |= ImGuiInputTextFlags_AutoSelectAll;
 
  const float button_size = GetFrameHeight();
 
  // Support invisible labels (##) by not rendering the label, but still using
  // it for ID
  bool invisible_label = IsInvisibleLabel(label);
 
  if (!invisible_label) {
    AlignTextToFramePadding();
    Text("%s", label);
    SameLine();
  }
 
  BeginGroup();
  PushID(label);
  SetNextItemWidth(ImMax(
      1.0f, CalcItemWidth() - (button_size + style.ItemInnerSpacing.x) * 2));
 
  PushStyleVar(ImGuiStyleVar_ItemSpacing,
               ImVec2{style.ItemSpacing.x, style.ItemSpacing.y});
  PushStyleVar(ImGuiStyleVar_FramePadding,
               ImVec2{style.FramePadding.x, style.FramePadding.y});
 
  SetNextItemWidth(input_width);
  if (InputText("", buf, IM_ARRAYSIZE(buf), flags)) {
    if (DataTypeApplyFromText(buf, data_type, p_data, format)) {
      result.text_changed = true;
      result.changed = true;
    }
  }
 
  // Check if text input was committed (deactivated after edit)
  if (IsItemDeactivatedAfterEdit()) {
    result.text_committed = true;
  }
 
  IMGUI_TEST_ENGINE_ITEM_INFO(
      g.LastItemData.ID, label,
      g.LastItemData.StatusFlags | ImGuiItemStatusFlags_Inputable);
 
  // The mouse wheel is applied by the typed yaze::gui wrappers
  // (ApplyHexMouseWheel), which report it as an immediate change.
 
  // Step buttons - immediate change
  if (!no_step) {
    const ImVec2 backup_frame_padding = style.FramePadding;
    style.FramePadding.x = style.FramePadding.y;
    ImGuiButtonFlags button_flags = ImGuiButtonFlags_PressedOnClick;
    if (flags & ImGuiInputTextFlags_ReadOnly)
      BeginDisabled();
    SameLine(0, style.ItemInnerSpacing.x);
    if (ButtonEx("-", ImVec2(button_size, button_size), button_flags)) {
      DataTypeApplyOp(data_type, '-', p_data, p_data,
                      g.IO.KeyCtrl && p_step_fast ? p_step_fast : p_step);
      result.changed = true;
      result.immediate = true;
    }
    SameLine(0, style.ItemInnerSpacing.x);
    if (ButtonEx("+", ImVec2(button_size, button_size), button_flags)) {
      DataTypeApplyOp(data_type, '+', p_data, p_data,
                      g.IO.KeyCtrl && p_step_fast ? p_step_fast : p_step);
      result.changed = true;
      result.immediate = true;
    }
 
    if (flags & ImGuiInputTextFlags_ReadOnly)
      EndDisabled();
 
    style.FramePadding = backup_frame_padding;
  }
  PopID();
  EndGroup();
  ImGui::PopStyleVar(2);
 
  if (result.changed)
    MarkItemEdited(g.LastItemData.ID);
 
  return result;
}
}  // namespace ImGui
 
namespace yaze {
namespace gui {
 
namespace {
 
constexpr size_t kMaxDeferredScalarBytes = sizeof(uint64_t);
 
struct DeferredScalarEdit {
  ImGuiDataType data_type = ImGuiDataType_COUNT;
  InputScalarTargetIdentity target_identity;
  alignas(uint64_t) std::array<uint8_t, kMaxDeferredScalarBytes> candidate = {};
  alignas(
      uint64_t) std::array<uint8_t, kMaxDeferredScalarBytes> source_model = {};
  int last_seen_frame = -1;
  bool editing = false;
  bool commit_blocked = false;
};
 
struct DeferredScalarStorage {
  ImGuiContext* context = nullptr;
  int last_frame = -1;
  std::unordered_map<ImGuiID, DeferredScalarEdit> edits;
};
 
thread_local DeferredScalarStorage g_deferred_scalar_storage;
 
void ResetDeferredScalarEdit(DeferredScalarEdit& edit, ImGuiDataType data_type,
                             const void* data, size_t data_size, int frame,
                             InputScalarTargetIdentity target_identity) {
  edit = {};
  edit.data_type = data_type;
  edit.target_identity = target_identity;
  std::memcpy(edit.candidate.data(), data, data_size);
  std::memcpy(edit.source_model.data(), data, data_size);
  edit.last_seen_frame = frame;
}
 
void PrepareDeferredScalarStorage(ImGuiContext* context, int frame) {
  auto& storage = g_deferred_scalar_storage;
  if (storage.context != context || frame < storage.last_frame) {
    storage.context = context;
    storage.edits.clear();
  }
 
  for (auto it = storage.edits.begin(); it != storage.edits.end();) {
    if (frame - it->second.last_seen_frame > 1) {
      it = storage.edits.erase(it);
    } else {
      ++it;
    }
  }
  storage.last_frame = frame;
}
 
bool IsValueWheelAdjustmentAllowedForCurrentItem(
    ImGuiHoveredFlags hover_flags = ImGuiHoveredFlags_AllowWhenBlockedByPopup) {
  if (!ImGui::IsItemHovered(hover_flags)) {
    return false;
  }
 
  const ImGuiIO& io = ImGui::GetIO();
  const bool platform_primary_held = io.KeyCtrl || io.KeySuper;
  return ImGui::IsItemActive() || platform_primary_held;
}
 
template <typename T>
bool ApplyHexMouseWheel(
    T* data, T min_value, T max_value,
    ImGuiHoveredFlags hover_flags = ImGuiHoveredFlags_AllowWhenBlockedByPopup) {
  if (!IsValueWheelAdjustmentAllowedForCurrentItem(hover_flags)) {
    return false;
  }
 
  const float wheel = ImGui::GetIO().MouseWheel;
  if (wheel == 0.0f) {
    return false;
  }
 
  using Numeric = long long;
  Numeric new_value = static_cast<Numeric>(*data) + (wheel > 0.0f ? 1 : -1);
  new_value = std::clamp(new_value, static_cast<Numeric>(min_value),
                         static_cast<Numeric>(max_value));
  if (static_cast<T>(new_value) != *data) {
    *data = static_cast<T>(new_value);
    ImGui::ClearActiveID();
    return true;
  }
  return false;
}
 
}  // namespace
 
const int kStepOneHex = 0x01;
const int kStepFastHex = 0x0F;
// ImGuiDataType_U64 reads its step through an 8-byte pointer.
const uint64_t kStepOneHex64 = 0x01;
const uint64_t kStepFastHex64 = 0x0F;
 
bool InputScalarDeferred(const char* label, ImGuiDataType data_type, void* data,
                         const char* format, ImGuiInputTextFlags flags,
                         InputScalarTargetIdentity target_identity) {
  ImGuiContext* context = ImGui::GetCurrentContext();
  ImGuiWindow* window = context ? ImGui::GetCurrentWindow() : nullptr;
  if (!context || !window || window->SkipItems || !label || !data ||
      data_type < 0 || data_type >= ImGuiDataType_COUNT) {
    return false;
  }
 
  const ImGuiDataTypeInfo* data_type_info = ImGui::DataTypeGetInfo(data_type);
  const size_t data_size = data_type_info->Size;
  if (data_size == 0 || data_size > kMaxDeferredScalarBytes) {
    return false;
  }
 
  const int frame = context->FrameCount;
  PrepareDeferredScalarStorage(context, frame);
 
  const ImGuiID item_id = ImGui::GetID(label);
  auto [it, inserted] = g_deferred_scalar_storage.edits.try_emplace(item_id);
  DeferredScalarEdit& edit = it->second;
  const bool target_changed =
      !inserted && !(edit.target_identity == target_identity);
  const bool reset_before_draw = inserted || edit.data_type != data_type ||
                                 (target_changed && !edit.editing);
  if (reset_before_draw) {
    ResetDeferredScalarEdit(edit, data_type, data, data_size, frame,
                            target_identity);
  } else if (target_changed) {
    // The same ImGui item now refers to a different semantic entity. Keep the
    // active text buffer alive for ImGui, but make this edit non-committable.
    edit.target_identity = target_identity;
    edit.commit_blocked = true;
  } else if (edit.editing &&
             std::memcmp(edit.source_model.data(), data, data_size) != 0) {
    // Keep feeding ImGui the same candidate until the item naturally
    // deactivates, but remember that it is no longer safe to commit.
    edit.commit_blocked = true;
  } else if (!edit.editing) {
    ResetDeferredScalarEdit(edit, data_type, data, data_size, frame,
                            target_identity);
  }
  edit.last_seen_frame = frame;
 
  const ImGuiInputTextFlags scalar_flags =
      flags & ~ImGuiInputTextFlags_EnterReturnsTrue;
  ImGui::InputScalar(label, data_type, edit.candidate.data(), nullptr, nullptr,
                     format, scalar_flags);
 
  if (ImGui::IsItemDeactivatedAfterEdit()) {
    // A newly restored widget may share an ID with ImGui's one-frame
    // deactivation backup. Never let that stale buffer become a fresh commit.
    if (reset_before_draw || edit.commit_blocked) {
      ResetDeferredScalarEdit(edit, data_type, data, data_size, frame,
                              target_identity);
      return false;
    }
    const bool changed =
        std::memcmp(data, edit.candidate.data(), data_size) != 0;
    if (changed) {
      std::memcpy(data, edit.candidate.data(), data_size);
    }
    ResetDeferredScalarEdit(edit, data_type, data, data_size, frame,
                            target_identity);
    return changed;
  }
 
  if (ImGui::IsItemActive()) {
    edit.editing = true;
  } else if (edit.editing) {
    // Escape or another non-commit deactivation discards the pending value.
    ResetDeferredScalarEdit(edit, data_type, data, data_size, frame,
                            target_identity);
  }
  return false;
}
 
bool InputHex(const char* label, uint64_t* data) {
  return ImGui::InputScalar(label, ImGuiDataType_U64, data, &kStepOneHex64,
                            &kStepFastHex64, "%06llX",
                            ImGuiInputTextFlags_CharsHexadecimal);
}
 
bool InputHex(const char* label, int* data, int num_digits, float input_width) {
  const std::string format = "%0" + std::to_string(num_digits) + "X";
  bool changed = ImGui::InputScalarLeft(
      label, ImGuiDataType_S32, data, &kStepOneHex, &kStepFastHex,
      format.c_str(), input_width, ImGuiInputTextFlags_CharsHexadecimal);
  // Hex fields hold addresses and IDs; stepping below zero would wrap to
  // FFFFFFFF.
  bool wheel_changed =
      ApplyHexMouseWheel<int>(data, 0, std::numeric_limits<int>::max());
  return changed || wheel_changed;
}
 
bool InputHexShort(const char* label, uint32_t* data) {
  return ImGui::InputScalar(label, ImGuiDataType_U32, data, &kStepOneHex,
                            &kStepFastHex, "%06X",
                            ImGuiInputTextFlags_CharsHexadecimal);
}
 
bool InputHexWord(const char* label, uint16_t* data, float input_width,
                  bool no_step) {
  bool changed = ImGui::InputScalarLeft(
      label, ImGuiDataType_U16, data, &kStepOneHex, &kStepFastHex, "%04X",
      input_width, ImGuiInputTextFlags_CharsHexadecimal, no_step);
  bool wheel_changed = ApplyHexMouseWheel<uint16_t>(
      data, 0u, std::numeric_limits<uint16_t>::max());
  return changed || wheel_changed;
}
 
bool InputHexWord(const char* label, int16_t* data, float input_width,
                  bool no_step) {
  bool changed = ImGui::InputScalarLeft(
      label, ImGuiDataType_S16, data, &kStepOneHex, &kStepFastHex, "%04X",
      input_width, ImGuiInputTextFlags_CharsHexadecimal, no_step);
  bool wheel_changed =
      ApplyHexMouseWheel<int16_t>(data, std::numeric_limits<int16_t>::min(),
                                  std::numeric_limits<int16_t>::max());
  return changed || wheel_changed;
}
 
bool InputHexByte(const char* label, uint8_t* data, float input_width,
                  bool no_step) {
  bool changed = ImGui::InputScalarLeft(
      label, ImGuiDataType_U8, data, &kStepOneHex, &kStepFastHex, "%02X",
      input_width, ImGuiInputTextFlags_CharsHexadecimal, no_step);
  bool wheel_changed = ApplyHexMouseWheel<uint8_t>(
      data, 0u, std::numeric_limits<uint8_t>::max());
  return changed || wheel_changed;
}
 
bool InputHexByte(const char* label, uint8_t* data, uint8_t max_value,
                  float input_width, bool no_step) {
  bool changed = ImGui::InputScalarLeft(
      label, ImGuiDataType_U8, data, &kStepOneHex, &kStepFastHex, "%02X",
      input_width, ImGuiInputTextFlags_CharsHexadecimal, no_step);
  if (changed && *data > max_value) {
    *data = max_value;
  }
  bool wheel_changed = ApplyHexMouseWheel<uint8_t>(data, 0u, max_value);
  return changed || wheel_changed;
}
 
// Extended versions that properly track change source
InputHexResult InputHexByteEx(const char* label, uint8_t* data,
                              float input_width, bool no_step) {
  auto result = ImGui::InputScalarLeftEx(
      label, ImGuiDataType_U8, data, &kStepOneHex, &kStepFastHex, "%02X",
      input_width, ImGuiInputTextFlags_CharsHexadecimal, no_step);
  if (ApplyHexMouseWheel<uint8_t>(data, 0u, std::numeric_limits<uint8_t>::max(),
                                  ImGuiHoveredFlags_None)) {
    result.changed = true;
    result.immediate = true;
  }
  InputHexResult hex_result;
  hex_result.changed = result.changed;
  hex_result.immediate = result.immediate;
  hex_result.text_committed = result.text_committed;
  return hex_result;
}
 
InputHexResult InputHexByteEx(const char* label, uint8_t* data,
                              uint8_t max_value, float input_width,
                              bool no_step) {
  auto result = ImGui::InputScalarLeftEx(
      label, ImGuiDataType_U8, data, &kStepOneHex, &kStepFastHex, "%02X",
      input_width, ImGuiInputTextFlags_CharsHexadecimal, no_step);
  if (result.changed && *data > max_value) {
    *data = max_value;
  }
  if (ApplyHexMouseWheel<uint8_t>(data, 0u, max_value,
                                  ImGuiHoveredFlags_None)) {
    result.changed = true;
    result.immediate = true;
  }
  InputHexResult hex_result;
  hex_result.changed = result.changed;
  hex_result.immediate = result.immediate;
  hex_result.text_committed = result.text_committed;
  return hex_result;
}
 
InputHexResult InputHexWordEx(const char* label, uint16_t* data,
                              float input_width, bool no_step) {
  auto result = ImGui::InputScalarLeftEx(
      label, ImGuiDataType_U16, data, &kStepOneHex, &kStepFastHex, "%04X",
      input_width, ImGuiInputTextFlags_CharsHexadecimal, no_step);
  if (ApplyHexMouseWheel<uint16_t>(data, 0u,
                                   std::numeric_limits<uint16_t>::max(),
                                   ImGuiHoveredFlags_None)) {
    result.changed = true;
    result.immediate = true;
  }
  InputHexResult hex_result;
  hex_result.changed = result.changed;
  hex_result.immediate = result.immediate;
  hex_result.text_committed = result.text_committed;
  return hex_result;
}
 
void Paragraph(const std::string& text) {
  ImGui::TextWrapped("%s", text.c_str());
}
 
// TODO: Setup themes and text/clickable colors
bool ClickableText(const std::string& text) {
  ImGui::BeginGroup();
  ImGui::PushID(text.c_str());
 
  // Calculate text size
  ImVec2 text_size = ImGui::CalcTextSize(text.c_str());
 
  // Get cursor position for hover detection
  ImVec2 pos = ImGui::GetCursorScreenPos();
  ImRect bb(pos, ImVec2(pos.x + text_size.x, pos.y + text_size.y));
 
  // Add item
  const ImGuiID id = ImGui::GetID(text.c_str());
  bool result = false;
  if (ImGui::ItemAdd(bb, id)) {
    bool hovered = ImGui::IsItemHovered();
    bool clicked = ImGui::IsItemClicked();
 
    // Render text with high-contrast appropriate color
    ImVec4 link_color = ImGui::GetStyleColorVec4(ImGuiCol_TextLink);
    ImVec4 bg_color = ImGui::GetStyleColorVec4(ImGuiCol_WindowBg);
 
    // Ensure good contrast against background
    float contrast_factor =
        (bg_color.x + bg_color.y + bg_color.z) < 1.5f ? 1.0f : 0.3f;
 
    ImVec4 color;
    if (hovered) {
      // Brighter color on hover for better visibility
      color = ImVec4(std::min(1.0f, link_color.x + 0.3f),
                     std::min(1.0f, link_color.y + 0.3f),
                     std::min(1.0f, link_color.z + 0.3f), 1.0f);
    } else {
      // Ensure link color has good contrast
      color = ImVec4(std::max(contrast_factor, link_color.x),
                     std::max(contrast_factor, link_color.y),
                     std::max(contrast_factor, link_color.z), 1.0f);
    }
 
    ImGui::GetWindowDrawList()->AddText(
        pos, ImGui::ColorConvertFloat4ToU32(color), text.c_str());
 
    result = clicked;
  }
 
  ImGui::PopID();
 
  // Advance cursor past the text
  ImGui::Dummy(text_size);
  ImGui::EndGroup();
 
  return result;
}
 
void ItemLabel(absl::string_view title, ItemLabelFlags flags) {
  ImGuiWindow* window = ImGui::GetCurrentWindow();
  const ImVec2 lineStart = ImGui::GetCursorScreenPos();
  const ImGuiStyle& style = ImGui::GetStyle();
  float fullWidth = ImGui::GetContentRegionAvail().x;
  float itemWidth = ImGui::CalcItemWidth() + style.ItemSpacing.x;
  ImVec2 textSize =
      ImGui::CalcTextSize(title.data(), title.data() + title.size());
  ImRect textRect;
  textRect.Min = ImGui::GetCursorScreenPos();
  if (flags & ItemLabelFlag::Right)
    textRect.Min.x = textRect.Min.x + itemWidth;
  textRect.Max = textRect.Min;
  textRect.Max.x += fullWidth - itemWidth;
  textRect.Max.y += textSize.y;
 
  ImGui::SetCursorScreenPos(textRect.Min);
 
  ImGui::AlignTextToFramePadding();
  // Adjust text rect manually because we render it directly into a drawlist
  // instead of using public functions.
  textRect.Min.y += window->DC.CurrLineTextBaseOffset;
  textRect.Max.y += window->DC.CurrLineTextBaseOffset;
 
  ImGui::ItemSize(textRect);
  if (ImGui::ItemAdd(
          textRect, window->GetID(title.data(), title.data() + title.size()))) {
    ImGui::RenderTextEllipsis(ImGui::GetWindowDrawList(), textRect.Min,
                              textRect.Max, textRect.Max.x, title.data(),
                              title.data() + title.size(), &textSize);
 
    if (textRect.GetWidth() < textSize.x && ImGui::IsItemHovered())
      ImGui::SetTooltip("%.*s", (int)title.size(), title.data());
  }
  if (flags & ItemLabelFlag::Left) {
    ImVec2 result;
    auto other = ImVec2{0, textSize.y + window->DC.CurrLineTextBaseOffset};
    result.x = textRect.Max.x - other.x;
    result.y = textRect.Max.y - other.y;
    ImGui::SetCursorScreenPos(result);
    ImGui::SameLine();
  } else if (flags & ItemLabelFlag::Right)
    ImGui::SetCursorScreenPos(lineStart);
}
 
bool ListBox(const char* label, int* current_item,
             const std::vector<std::string>& items, int height_in_items) {
  std::vector<const char*> items_ptr;
  items_ptr.reserve(items.size());
  for (const auto& item : items) {
    items_ptr.push_back(item.c_str());
  }
  int items_count = static_cast<int>(items.size());
  return ImGui::ListBox(label, current_item, items_ptr.data(), items_count,
                        height_in_items);
}
 
bool InputTileInfo(const char* label, gfx::TileInfo* tile_info) {
  ImGui::PushID(label);
  ImGui::BeginGroup();
  bool changed = false;
  changed |= InputHexWord(label, &tile_info->id_);
  changed |= InputHexByte("Palette", &tile_info->palette_);
  changed |= ImGui::Checkbox(tr("Priority"), &tile_info->over_);
  changed |= ImGui::Checkbox(tr("Vertical Flip"), &tile_info->vertical_mirror_);
  changed |=
      ImGui::Checkbox(tr("Horizontal Flip"), &tile_info->horizontal_mirror_);
  ImGui::EndGroup();
  ImGui::PopID();
  return changed;
}
 
ImGuiID GetID(const std::string& id) {
  return ImGui::GetID(id.c_str());
}
 
ImGuiKey MapKeyToImGuiKey(char key) {
  switch (key) {
    case 'A':
      return ImGuiKey_A;
    case 'B':
      return ImGuiKey_B;
    case 'C':
      return ImGuiKey_C;
    case 'D':
      return ImGuiKey_D;
    case 'E':
      return ImGuiKey_E;
    case 'F':
      return ImGuiKey_F;
    case 'G':
      return ImGuiKey_G;
    case 'H':
      return ImGuiKey_H;
    case 'I':
      return ImGuiKey_I;
    case 'J':
      return ImGuiKey_J;
    case 'K':
      return ImGuiKey_K;
    case 'L':
      return ImGuiKey_L;
    case 'M':
      return ImGuiKey_M;
    case 'N':
      return ImGuiKey_N;
    case 'O':
      return ImGuiKey_O;
    case 'P':
      return ImGuiKey_P;
    case 'Q':
      return ImGuiKey_Q;
    case 'R':
      return ImGuiKey_R;
    case 'S':
      return ImGuiKey_S;
    case 'T':
      return ImGuiKey_T;
    case 'U':
      return ImGuiKey_U;
    case 'V':
      return ImGuiKey_V;
    case 'W':
      return ImGuiKey_W;
    case 'X':
      return ImGuiKey_X;
    case 'Y':
      return ImGuiKey_Y;
    case 'Z':
      return ImGuiKey_Z;
    case '/':
      return ImGuiKey_Slash;
    case '-':
      return ImGuiKey_Minus;
    default:
      return ImGuiKey_COUNT;
  }
}
 
void AddTableColumn(Table& table, const std::string& label,
                    GuiElement element) {
  table.column_labels.push_back(label);
  table.column_contents.push_back(element);
}
 
void DrawTable(Table& params) {
  if (ImGui::BeginTable(params.id, params.num_columns, params.flags,
                        params.size)) {
    for (int i = 0; i < params.num_columns; ++i)
      ImGui::TableSetupColumn(params.column_labels[i].c_str());
 
    for (int i = 0; i < params.num_columns; ++i) {
      ImGui::TableNextColumn();
      switch (params.column_contents[i].index()) {
        case 0:
          std::get<0>(params.column_contents[i])();
          break;
        case 1:
          ImGui::Text("%s", std::get<1>(params.column_contents[i]).c_str());
          break;
      }
    }
    ImGui::EndTable();
  }
}
 
bool OpenUrl(const std::string& url) {
  ImGuiContext* context = ImGui::GetCurrentContext();
  if (context == nullptr || url.empty())
    return false;
 
#ifdef __EMSCRIPTEN__
  // ImGui's default shell opener uses native process APIs, not the browser.
  // Open synchronously from the click, and detach before navigating so the
  // destination cannot access this editor through window.opener.
  return EM_ASM_INT(
             {
               const opened = window.open('about:blank', '_blank');
               if (!opened)
                 return 0;
               opened.opener = null;
               opened.location.href = UTF8ToString($0);
               return 1;
             },
             url.c_str()) != 0;
#else
  ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
  if (platform_io.Platform_OpenInShellFn == nullptr)
    return false;
 
  return platform_io.Platform_OpenInShellFn(context, url.c_str());
#endif
}
 
void MemoryEditorPopup(const std::string& label, std::span<uint8_t> memory) {
  static bool open = false;
  static yaze::gui::MemoryEditorWidget editor;
  if (ImGui::Button(tr("View Data"))) {
    open = true;
  }
  if (open) {
    ImGui::Begin(label.c_str(), &open);
    editor.DrawContents(memory.data(), memory.size());
    ImGui::End();
  }
}
 
// Custom hex input functions that properly respect width
bool InputHexByteCustom(const char* label, uint8_t* data, float input_width) {
  ImGui::PushID(label);
 
  // Create a simple hex input that respects width
  char buf[8];
  snprintf(buf, sizeof(buf), "%02X", *data);
 
  ImGui::SetNextItemWidth(input_width);
  bool changed = ImGui::InputText(
      label, buf, sizeof(buf),
      ImGuiInputTextFlags_CharsHexadecimal | ImGuiInputTextFlags_AutoSelectAll);
 
  if (changed) {
    unsigned int temp;
    if (sscanf(buf, "%X", &temp) == 1) {
      *data = static_cast<uint8_t>(temp & 0xFF);
    }
  }
 
  ImGui::PopID();
  return changed;
}
 
bool InputHexWordCustom(const char* label, uint16_t* data, float input_width) {
  ImGui::PushID(label);
 
  // Create a simple hex input that respects width
  char buf[8];
  snprintf(buf, sizeof(buf), "%04X", *data);
 
  ImGui::SetNextItemWidth(input_width);
  bool changed = ImGui::InputText(
      label, buf, sizeof(buf),
      ImGuiInputTextFlags_CharsHexadecimal | ImGuiInputTextFlags_AutoSelectAll);
 
  if (changed) {
    unsigned int temp;
    if (sscanf(buf, "%X", &temp) == 1) {
      *data = static_cast<uint16_t>(temp & 0xFFFF);
    }
  }
 
  ImGui::PopID();
  return changed;
}
 
bool SliderFloatWheel(const char* label, float* v, float v_min, float v_max,
                      const char* format, float wheel_step,
                      ImGuiSliderFlags flags) {
  bool changed = ImGui::SliderFloat(label, v, v_min, v_max, format, flags);
 
  // Require active focus or the platform primary modifier so hovering while
  // scrolling a panel doesn't unexpectedly change the value.
  if (IsValueWheelAdjustmentAllowedForCurrentItem()) {
    float wheel = ImGui::GetIO().MouseWheel;
    if (wheel != 0.0f) {
      *v = std::clamp(*v + wheel * wheel_step, v_min, v_max);
      changed = true;
    }
  }
  return changed;
}
 
bool SliderIntWheel(const char* label, int* v, int v_min, int v_max,
                    const char* format, int wheel_step,
                    ImGuiSliderFlags flags) {
  bool changed = ImGui::SliderInt(label, v, v_min, v_max, format, flags);
 
  if (IsValueWheelAdjustmentAllowedForCurrentItem()) {
    float wheel = ImGui::GetIO().MouseWheel;
    if (wheel != 0.0f) {
      int delta = static_cast<int>(wheel) * wheel_step;
      *v = std::clamp(*v + delta, v_min, v_max);
      changed = true;
    }
  }
  return changed;
}
 
}  // namespace gui
}  // namespace yaze