grmenu 4.1.0 → 5.0.0

data/grmenu/theme.rb

@@ -0,0 +1,378 @@
+# frozen_string_literal: true
+
+class GRmenu
+  # Almacena la configuracion del tema global cargado actualmente
+  @@global_theme = {}
+
+  # Devuelve el tema global activo
+  def self.current_theme
+    @@global_theme
+  end
+
+  # Parsea el contenido de un archivo de tema .gr o de un bloque heredoc <<-GR.
+  # La sintaxis admite secciones delimitadas por <<nombre ... >> y pares clave:: valor.
+  def self.parse_config_text(text)
+    data = { global: {}, sections: {} }
+    current_section = nil
+    current_section_data = {}
+
+    text.to_s.each_line do |line|
+      line = line.strip
+      next if line.empty? || line.start_with?("#")
+      next if line.start_with?("GRmenu::config") # Encabezado de version del formato .gr
+
+      # Apertura de bloque de seccion (ej. <<menu, <<tabs, <<input)
+      if line.start_with?("<<")
+        sec_name = line[2..-1].strip.downcase
+        current_section = sec_name
+        current_section_data = {}
+      # Cierre de bloque de seccion
+      elsif line == ">>"
+        if current_section
+          data[:sections][current_section] = current_section_data
+          current_section = nil
+        end
+      # Definicion de propiedad clave:: valor
+      elsif line.include?("::")
+        key, _, val = line.partition("::")
+        key = key.strip.sub(/^@/, '').downcase
+        val = val.strip.sub(/^["']/, '').sub(/["']$/, '')
+        if current_section
+          current_section_data[key] = val
+        else
+          data[:global][key] = val
+        end
+      end
+    end
+    data
+  end
+
+  # Localiza un archivo de tema .gr buscando en rutas relativas y en la carpeta data/themes/
+  def self.find_theme_file(path_or_name)
+    raw_name = path_or_name.to_s
+    names = [raw_name]
+    if raw_name.start_with?("cromatico_")
+      names << raw_name.sub(/\Acromatico_/, "chromatic_")
+    elsif raw_name.start_with?("chromatic_")
+      names << raw_name.sub(/\Achromatic_/, "cromatico_")
+    end
+
+    names.each do |name|
+      candidate_paths = [
+        name,
+        "#{name}.gr",
+        find_data_file("themes/#{name}.gr"),
+        find_data_file("themes/#{name}"),
+        File.expand_path("data/themes/#{name}.gr", __dir__),
+        File.expand_path("data/themes/#{name}", __dir__),
+        File.expand_path("../data/themes/#{name}.gr", __dir__),
+        File.expand_path("../data/themes/#{name}", __dir__)
+      ].compact
+      found = candidate_paths.find { |path| File.exist?(path) }
+      return found if found
+    end
+    nil
+  end
+
+  # Importa y aplica un tema .gr desde un archivo en disco
+  def self.import_config(path_or_name)
+    path = find_theme_file(path_or_name)
+    raise "No se encontro el tema: #{path_or_name}" unless path && File.exist?(path)
+    text = File.read(path)
+    parsed = parse_config_text(text)
+    apply_parsed_theme(parsed)
+    @@global_theme = parsed
+    path
+  end
+
+  # Alias amigable para importar un tema: GRmenu.theme(:cyberpunk) o GRmenu.theme("matrix")
+  def self.theme(name)
+    import_config(name)
+  end
+
+  # Descompone una cadena de especificacion de color "nombre:nivel" (ej. "cyan:2") en [nombre, nivel]
+  def self.extract_color_and_level(val, default_level = 1)
+    return ["white", default_level] if val.nil?
+    parts = val.to_s.split(":")
+    color_name = parts[0].to_s.strip
+    level = parts[1] ? parts[1].to_i : default_level
+    [color_name, level]
+  end
+
+  # Aplica los estilos parseados a SetStyle respetando estrictamente los valores
+  # fijados explicitamente por el programador (from_css: true).
+  def self.apply_parsed_theme(parsed)
+    sections = parsed[:sections] || {}
+    global_settings = parsed[:global] || {}
+    menu_settings = (sections["menu"] || {}).merge(global_settings)
+
+    if menu_settings && !menu_settings.empty?
+      if (menu_settings["border"] || menu_settings["border_color"]) && !SetStyle.explicitly_set?(:border)
+        c, l = extract_color_and_level(menu_settings["border"] || menu_settings["border_color"], 1)
+        SetStyle.border(c, l, from_css: true)
+      end
+      if (menu_settings["title"] || menu_settings["title_color"]) && !SetStyle.explicitly_set?(:title)
+        c, l = extract_color_and_level(menu_settings["title"] || menu_settings["title_color"], 2)
+        SetStyle.title(c, l, from_css: true)
+      end
+      if (menu_settings["focus"] || menu_settings["focus_color"]) && !SetStyle.explicitly_set?(:focus)
+        c, l = extract_color_and_level(menu_settings["focus"] || menu_settings["focus_color"], 2)
+        SetStyle.focus(c, l, from_css: true)
+      end
+      if (menu_settings["options"] || menu_settings["options_color"]) && !SetStyle.explicitly_set?(:options)
+        c, l = extract_color_and_level(menu_settings["options"] || menu_settings["options_color"], 1)
+        SetStyle.options(c, l, from_css: true)
+      end
+      if (menu_settings["banner"] || menu_settings["banner_color"]) && !SetStyle.explicitly_set?(:banner)
+        c, l = extract_color_and_level(menu_settings["banner"] || menu_settings["banner_color"], 2)
+        SetStyle.banner(c, l, from_css: true)
+      end
+      if (menu_settings["subtitle"] || menu_settings["subtitle_color"]) && !SetStyle.explicitly_set?(:subtitle)
+        c, l = extract_color_and_level(menu_settings["subtitle"] || menu_settings["subtitle_color"], 1)
+        SetStyle.subtitle(c, l, from_css: true)
+      end
+      if (menu_settings["divider"] || menu_settings["divider_color"]) && !SetStyle.explicitly_set?(:divider)
+        c, l = extract_color_and_level(menu_settings["divider"] || menu_settings["divider_color"], 1)
+        SetStyle.divider(c, l, from_css: true)
+      end
+      if (menu_settings["desc_prefix"] || menu_settings["description_prefix"] || menu_settings["prefix"]) && !SetStyle.explicitly_set?(:desc_prefix)
+        SetStyle.desc_prefix(menu_settings["desc_prefix"] || menu_settings["description_prefix"] || menu_settings["prefix"], from_css: true)
+      end
+      if menu_settings["font"] && !SetStyle.explicitly_set?(:font)
+        SetStyle.font(menu_settings["font"].to_i, from_css: true)
+      end
+    end
+
+    # Aplica estilos a secciones especificas (border, options, focus, etc.)
+    sections.each do |section_key, section_data|
+      next unless section_data.is_a?(Hash)
+      color_spec = section_data["color"] || section_data["border"] || section_data["options"] || section_data["focus"] || section_data["title"] || section_data["banner"] || section_data["subtitle"] || section_data["divider"]
+      c, l = extract_color_and_level(color_spec, (section_data["level"] || 1).to_i)
+      case section_key
+      when "border"
+        SetStyle.border(c, l, from_css: true) unless SetStyle.explicitly_set?(:border)
+      when "options"
+        SetStyle.options(c, l, from_css: true) unless SetStyle.explicitly_set?(:options)
+      when "focus"
+        SetStyle.focus(c, l, from_css: true) unless SetStyle.explicitly_set?(:focus)
+      when "title"
+        SetStyle.title(c, l, from_css: true) unless SetStyle.explicitly_set?(:title)
+      when "banner"
+        SetStyle.banner(c, l, from_css: true) unless SetStyle.explicitly_set?(:banner)
+      when "subtitle"
+        SetStyle.subtitle(c, l, from_css: true) unless SetStyle.explicitly_set?(:subtitle)
+      when "divider"
+        SetStyle.divider(c, l, from_css: true) unless SetStyle.explicitly_set?(:divider)
+      end
+    end
+    SetStyle.font(global_settings["font"].to_i, from_css: true) if global_settings["font"] && !SetStyle.explicitly_set?(:font)
+  end
+
+  # Inyecta estilos CSS directamente a traves de una cadena heredoc en la clase
+  def self.style(css_content)
+    parsed = parse_config_text(css_content)
+    apply_parsed_theme(parsed)
+    parsed
+  end
+
+  # Exporta la configuracion actual de SetStyle a un archivo .gr valido
+  def self.export_config(path = nil)
+    if path.nil?
+      caller_loc = caller_locations.find { |c| !c.path.include?(__FILE__) }
+      base = caller_loc ? caller_loc.path.sub(/\.rb$/, '') : "theme"
+      path = "#{base}.gr"
+    end
+    lines = ["GRmenu::config<-1->", ""]
+    lines << "@theme:: \"#{File.basename(path, '.gr').capitalize}\""
+    lines << "@author:: \"grcode\""
+    lines << "@version:: \"1.0\""
+    lines << ""
+    lines << "<<menu"
+    lines << "  style:: 3"
+    lines << "  banner_style:: 3"
+    lines << "  font:: #{SetStyle.font}"
+    lines << "  animate:: rgb"
+    lines << "  center:: true"
+    lines << "  border:: #{SetStyle.border[:color]}:#{SetStyle.border[:level]}"
+    lines << "  title:: #{SetStyle.title[:color]}:#{SetStyle.title[:level]}"
+    lines << "  focus:: #{SetStyle.focus[:color]}:#{SetStyle.focus[:level]}"
+    lines << "  options:: #{SetStyle.options[:color]}:#{SetStyle.options[:level]}"
+    lines << "  banner:: #{SetStyle.banner[:color]}:#{SetStyle.banner[:level]}"
+    lines << "  subtitle:: #{SetStyle.subtitle[:color]}:#{SetStyle.subtitle[:level]}"
+    lines << "  divider:: #{SetStyle.divider[:color]}:#{SetStyle.divider[:level]}"
+    lines << ">>"
+    lines << ""
+    lines << "<<table"
+    lines << "  style:: 3"
+    lines << "  header_color:: yellow:2"
+    lines << "  border_color:: rgb:2"
+    lines << "  selected_row:: green:2"
+    lines << "  row_color:: white:1"
+    lines << "  zebra_striping:: true"
+    lines << ">>"
+    lines << ""
+    lines << "<<card"
+    lines << "  style:: 7"
+    lines << "  border_color:: cyan:2"
+    lines << "  title_color:: yellow:2"
+    lines << "  content_color:: white:1"
+    lines << ">>"
+    lines << ""
+    lines << "<<slider"
+    lines << "  style:: 3"
+    lines << "  color:: rgb:2"
+    lines << "  fill_char:: █"
+    lines << "  empty_char:: ░"
+    lines << ">>"
+    lines << ""
+    lines << "<<checkbox"
+    lines << "  style:: 3"
+    lines << "  color:: rgb:2"
+    lines << "  checked_mark:: [X]"
+    lines << "  unchecked_mark:: [ ]"
+    lines << ">>"
+    lines << ""
+    lines << "<<input"
+    lines << "  style:: 3"
+    lines << "  border_color:: cyan:2"
+    lines << "  title_color:: yellow:2"
+    lines << "  label_color:: white:2"
+    lines << ">>"
+    lines << ""
+    lines << "<<modal"
+    lines << "  style:: 3"
+    lines << "  border_color:: cyan:2"
+    lines << "  title_color:: yellow:2"
+    lines << "  content_color:: white:1"
+    lines << "  shadow:: true"
+    lines << ">>"
+    lines << ""
+    lines << "<<form"
+    lines << "  style:: 3"
+    lines << "  border_color:: cyan:2"
+    lines << "  title_color:: yellow:2"
+    lines << "  focus_color:: green:2"
+    lines << "  shadow:: true"
+    lines << ">>"
+    lines << ""
+    File.write(path, lines.join("\n") + "\n")
+    path
+  end
+
+  # Inspecciona un script Ruby de usuario interceptando la llamada a `draw`
+  # para extraer sus configuraciones y guardarlas como tema .gr sin ejecutar la TUI.
+  def self.export_from_file(source_file, target_path = nil)
+    raise "No existe #{source_file}" unless File.exist?(source_file)
+    original_draw_method = instance_method(:draw) rescue nil
+    extracted = nil
+
+    # Sobrescribe draw temporalmente para interceptar los atributos antes de renderizar
+    define_method(:draw) do |*|
+      extracted = {
+        style: @style,
+        banner_style: @banner_style,
+        font: @style_config&.font,
+        animate: @animate,
+        border: @style_config&.border,
+        title: @style_config&.title,
+        focus: @style_config&.focus,
+        options: @style_config&.options,
+        banner: @style_config&.banner,
+        subtitle: @style_config&.subtitle,
+        divider: @style_config&.divider
+      }
+      # Lanza un salto no local para abortar la ejecucion del script tras capturar datos
+      throw :grmenu_export_completed
+    end
+
+    begin
+      catch(:grmenu_export_completed) do
+        load(File.expand_path(source_file))
+      end
+    ensure
+      # Restaura siempre el metodo draw original
+      define_method(:draw, original_draw_method) if original_draw_method
+    end
+
+    output_path = target_path || source_file.sub(/\.rb$/, '') + ".gr"
+    if extracted && extracted[:border]
+      lines = ["GRmenu::config<-1->", ""]
+      lines << "@theme:: \"#{File.basename(output_path, '.gr').capitalize}\""
+      lines << "@author:: \"grcode\""
+      lines << "@version:: \"1.0\""
+      lines << ""
+      lines << "<<menu"
+      lines << "  style:: #{extracted[:style] || 3}"
+      lines << "  banner_style:: #{extracted[:banner_style] || 3}"
+      lines << "  font:: #{extracted[:font] || 1}"
+      lines << "  animate:: #{extracted[:animate] || 'rgb'}"
+      lines << "  center:: true"
+      lines << "  border:: #{extracted[:border][:color]}:#{extracted[:border][:level]}"
+      lines << "  title:: #{extracted[:title][:color]}:#{extracted[:title][:level]}"
+      lines << "  focus:: #{extracted[:focus][:color]}:#{extracted[:focus][:level]}"
+      lines << "  options:: #{extracted[:options][:color]}:#{extracted[:options][:level]}"
+      lines << "  banner:: #{extracted[:banner][:color]}:#{extracted[:banner][:level]}"
+      lines << "  subtitle:: #{extracted[:subtitle][:color]}:#{extracted[:subtitle][:level]}"
+      lines << "  divider:: #{extracted[:divider][:color]}:#{extracted[:divider][:level]}"
+      lines << ">>"
+      lines << ""
+      lines << "<<table"
+      lines << "  style:: #{extracted[:style] || 3}"
+      lines << "  header_color:: yellow:2"
+      lines << "  border_color:: rgb:2"
+      lines << "  selected_row:: green:2"
+      lines << "  row_color:: white:1"
+      lines << "  zebra_striping:: true"
+      lines << ">>"
+      lines << ""
+      lines << "<<card"
+      lines << "  style:: 7"
+      lines << "  border_color:: cyan:2"
+      lines << "  title_color:: yellow:2"
+      lines << "  content_color:: white:1"
+      lines << ">>"
+      lines << ""
+      lines << "<<slider"
+      lines << "  style:: 3"
+      lines << "  color:: rgb:2"
+      lines << "  fill_char:: █"
+      lines << "  empty_char:: ░"
+      lines << ">>"
+      lines << ""
+      lines << "<<checkbox"
+      lines << "  style:: 3"
+      lines << "  color:: rgb:2"
+      lines << "  checked_mark:: [X]"
+      lines << "  unchecked_mark:: [ ]"
+      lines << ">>"
+      lines << ""
+      lines << "<<input"
+      lines << "  style:: #{extracted[:style] || 3}"
+      lines << "  border_color:: #{extracted[:border] ? "#{extracted[:border][:color]}:#{extracted[:border][:level]}" : 'cyan:2'}"
+      lines << "  title_color:: #{extracted[:title] ? "#{extracted[:title][:color]}:#{extracted[:title][:level]}" : 'yellow:2'}"
+      lines << "  label_color:: white:2"
+      lines << ">>"
+      lines << ""
+      lines << "<<modal"
+      lines << "  style:: #{extracted[:style] || 3}"
+      lines << "  border_color:: #{extracted[:border] ? "#{extracted[:border][:color]}:#{extracted[:border][:level]}" : 'cyan:2'}"
+      lines << "  title_color:: #{extracted[:title] ? "#{extracted[:title][:color]}:#{extracted[:title][:level]}" : 'yellow:2'}"
+      lines << "  content_color:: white:1"
+      lines << "  shadow:: true"
+      lines << ">>"
+      lines << ""
+      lines << "<<form"
+      lines << "  style:: #{extracted[:style] || 3}"
+      lines << "  border_color:: #{extracted[:border] ? "#{extracted[:border][:color]}:#{extracted[:border][:level]}" : 'cyan:2'}"
+      lines << "  title_color:: #{extracted[:title] ? "#{extracted[:title][:color]}:#{extracted[:title][:level]}" : 'yellow:2'}"
+      lines << "  focus_color:: #{extracted[:focus] ? "#{extracted[:focus][:color]}:#{extracted[:focus][:level]}" : 'green:2'}"
+      lines << "  shadow:: true"
+      lines << ">>"
+      lines << ""
+      File.write(output_path, lines.join("\n") + "\n")
+      output_path
+    else
+      export_config(output_path)
+    end
+  end
+end

data/grmenu/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class GRmenu
+  # Versión oficial de la suite GRmenu en Ruby
+  VERSION = "5.0.0"
+end

data/grmenu/widgets/checkbox.rb

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+class GRmenu
+  # Widget de selección múltiple (checkbox) para la terminal.
+  #
+  # Permite al usuario navegar con las flechas y alternar la selección de varios
+  # elementos con la barra espaciadora. También soporta atajos rápidos para marcar
+  # todos ('a'), desmarcar todos ('n') o invertir la selección ('i').
+  #
+  # @param items_arg [Array, nil] Lista de opciones si se pasa como primer argumento posicional.
+  # @param items [Array, nil] Lista de opciones si se pasa como argumento nominal.
+  # @param title [String] Título superior en el marco.
+  # @param subtitle [String] Instrucciones o atajos mostrados en la parte inferior.
+  # @param color [String, Symbol, nil] Color del marco y elementos activos.
+  # @param style [Integer, nil] Estilo de borde del marco (1 a 12).
+  # @param page_size [Integer, nil] Cantidad máxima de elementos visibles a la vez.
+  # @param min_width [Integer, nil] Ancho mínimo forzado para la caja.
+  # @param preselected [Array] Índices o nombres de los elementos que inician marcados.
+  # @return [Array] Lista de los elementos seleccionados (en su formato u objeto original).
+  def self.checkbox(items_arg = nil, items: nil, title: "Selección Múltiple", subtitle: "Espacio: Marcar/Desmarcar | a: Todos | n: Ninguno | i: Invertir | Enter: Confirmar", color: nil, style: nil, page_size: nil, min_width: nil, preselected: [])
+    checkbox_theme = (@@global_theme.is_a?(Hash) && @@global_theme.dig(:sections, "checkbox")) || {}
+    actual_items = items || items_arg || []
+    item_list = actual_items.is_a?(Array) ? actual_items : Array(actual_items)
+    return [] if item_list.empty?
+
+    checked_mark   = checkbox_theme["checked_mark"]   || "[X]"
+    unchecked_mark = checkbox_theme["unchecked_mark"] || "[ ]"
+
+    # Normalizamos los elementos de entrada a una estructura uniforme:
+    # { name: String, checked: Boolean, desc: String, original: Object }
+    parsed_items = item_list.map do |it|
+      case it
+      when Array
+        name = it[0].to_s
+        is_chk = it.length > 1 ? !!it[1] : false
+        desc = it.length > 2 ? it[2].to_s : ""
+        { name: name, checked: is_chk, desc: desc, original: it }
+      when Hash
+        name = (it[:name] || it["name"] || it[:title] || it["title"] || "Item").to_s
+        is_chk = !!(it[:checked] || it["checked"] || it[:selected] || it["selected"])
+        desc = (it[:desc] || it["desc"] || it[:description] || it["description"]).to_s
+        { name: name, checked: is_chk, desc: desc, original: it }
+      else
+        { name: it.to_s, checked: false, desc: "", original: it }
+      end
+    end
+
+    # Aplicar selecciones previas ya sea por índice entero o coincidencia exacta de nombre
+    preselected.each do |p|
+      if p.is_a?(Integer) && parsed_items[p]
+        parsed_items[p][:checked] = true
+      else
+        found = parsed_items.find { |item| item[:name] == p.to_s }
+        found[:checked] = true if found
+      end
+    end
+
+    current_cursor_idx = 0
+    rgb_tick = 0.0
+    drawn_lines = 0
+    box_color_name = (color || checkbox_theme["color"] || "cyan").to_s
+    border_style = (style || checkbox_theme["style"] || 3).to_i
+    is_rgb = (box_color_name.downcase == "rgb" || box_color_name.downcase == "rainbow" || box_color_name.downcase == "chroma")
+
+    border_chars = BORDERS[border_style] || BORDERS[3]
+    horizontal_top    = border_chars[:ht] || border_chars[:h]
+    horizontal_bottom = border_chars[:hb] || border_chars[:h]
+    vertical_left     = border_chars[:vl] || border_chars[:v]
+    vertical_right    = border_chars[:vr] || border_chars[:v]
+
+    render_frame = lambda do
+      term_w = terminal_width
+      term_h = terminal_height
+
+      # Calculamos anchos necesarios basados en el texto más largo
+      max_name_w = parsed_items.map { |it| display_width(it[:name]) }.max || 10
+      req_w = [max_name_w + 12, display_width(title) + 6, display_width(subtitle) + 4, min_width || 38].max
+      box_w = [req_w, term_w - 4].min
+      inner_w = box_w - 4
+
+      top_fill = (horizontal_top * ((box_w - 2).to_f / horizontal_top.length).ceil)[0...(box_w - 2)]
+      bot_fill = (horizontal_bottom * ((box_w - 2).to_f / horizontal_bottom.length).ceil)[0...(box_w - 2)]
+      mid_fill = (horizontal_top * ((box_w - 2).to_f / horizontal_top.length).ceil)[0...(box_w - 2)]
+
+      total_items = parsed_items.length
+      max_visible = page_size ? [page_size, total_items, term_h - 10].min : [total_items, term_h - 10].min
+      max_visible = [max_visible, 1].max
+
+      # Ventana deslizante para paginar la lista si no cabe en pantalla
+      start_idx = 0
+      end_idx = total_items - 1
+      if total_items > max_visible
+        half = max_visible / 2
+        start_idx = [[current_cursor_idx - half, 0].max, total_items - max_visible].min
+        end_idx = start_idx + max_visible - 1
+      end
+
+      lines = []
+      if is_rgb
+        vr_col = Color.rgb(vertical_right, rgb_tick + (req_w - 1) * 0.12)
+        lines << Color.rgb("#{border_chars[:tl]}#{top_fill}#{border_chars[:tr]}", rgb_tick)
+        unless title.to_s.empty?
+          t_clean = title.to_s
+          t_clean = t_clean[0...[inner_w - 3, 1].max] + "..." if display_width(t_clean) > inner_w
+          pad_t = [inner_w - display_width(t_clean), 0].max
+          t_line = (" " * (pad_t / 2)) + t_clean + (" " * (pad_t - (pad_t / 2)))
+          lines << "#{Color.rgb(vertical_left, rgb_tick)} #{Color.rgb(t_line, rgb_tick + 2 * 0.12)} #{vr_col}"
+          lines << Color.rgb("#{vertical_left}#{mid_fill}#{vertical_right}", rgb_tick)
+        end
+        if start_idx > 0
+          up_t = "▲ (+#{start_idx} arriba)"
+          pad_u = [inner_w - display_width(up_t), 0].max
+          lines << "#{Color.rgb(vertical_left, rgb_tick)} #{Color.gray(" " * (pad_u / 2) + up_t + " " * (pad_u - (pad_u / 2)))} #{vr_col}"
+        end
+        (start_idx..end_idx).each do |i|
+          it = parsed_items[i]
+          mark = it[:checked] ? checked_mark : unchecked_mark
+          is_active = (i == current_cursor_idx)
+          max_w = [inner_w - display_width(mark) - 4, 4].max
+          name_str = it[:name].to_s
+          name_str = name_str[0...[max_w - 3, 1].max] + "..." if display_width(name_str) > max_w
+          raw_line = "#{is_active ? '> ' : '  '}#{mark} #{name_str}"
+          line_padded = pad_to_width(raw_line, inner_w)
+          if is_active
+            lines << "#{Color.rgb(vertical_left, rgb_tick)} #{Color.rgb(line_padded, rgb_tick + 2 * 0.12)} #{vr_col}"
+          elsif it[:checked]
+            lines << "#{Color.rgb(vertical_left, rgb_tick)} #{Color.bright_green(line_padded)} #{vr_col}"
+          else
+            lines << "#{Color.rgb(vertical_left, rgb_tick)} #{Color.white(line_padded)} #{vr_col}"
+          end
+        end
+        if end_idx < (total_items - 1)
+          rem = total_items - 1 - end_idx
+          dn_t = "▼ (+#{rem} abajo)"
+          pad_d = [inner_w - display_width(dn_t), 0].max
+          lines << "#{Color.rgb(vertical_left, rgb_tick)} #{Color.gray(" " * (pad_d / 2) + dn_t + " " * (pad_d - (pad_d / 2)))} #{vr_col}"
+        end
+        unless subtitle.to_s.empty?
+          lines << Color.rgb("#{vertical_left}#{mid_fill}#{vertical_right}", rgb_tick)
+          s_clean = subtitle.to_s
+          s_clean = s_clean[0...[inner_w - 3, 1].max] + "..." if display_width(s_clean) > inner_w
+          pad_sub = [inner_w - display_width(s_clean), 0].max
+          sub_padded = (" " * (pad_sub / 2)) + s_clean + (" " * (pad_sub - (pad_sub / 2)))
+          lines << "#{Color.rgb(vertical_left, rgb_tick)} #{Color.gray(sub_padded)} #{vr_col}"
+        end
+        lines << Color.rgb("#{border_chars[:bl]}#{bot_fill}#{border_chars[:br]}", rgb_tick)
+      else
+        color_code = ansi_color(box_color_name, 2)
+        reset_code = ansi_reset
+        lines << "#{color_code}#{border_chars[:tl]}#{top_fill}#{border_chars[:tr]}#{reset_code}"
+        unless title.to_s.empty?
+          t_clean = title.to_s
+          t_clean = t_clean[0...[inner_w - 3, 1].max] + "..." if display_width(t_clean) > inner_w
+          pad_t = [inner_w - display_width(t_clean), 0].max
+          t_line = (" " * (pad_t / 2)) + t_clean + (" " * (pad_t - (pad_t / 2)))
+          lines << "#{color_code}#{vertical_left}#{reset_code} #{Color.bright_yellow(t_line)} #{color_code}#{vertical_right}#{reset_code}"
+          lines << "#{color_code}#{vertical_left}#{top_fill}#{vertical_right}#{reset_code}"
+        end
+        if start_idx > 0
+          up_t = "▲ (+#{start_idx} arriba)"
+          pad_u = [inner_w - display_width(up_t), 0].max
+          lines << "#{color_code}#{vertical_left}#{reset_code} #{Color.gray(" " * (pad_u / 2) + up_t + " " * (pad_u - (pad_u / 2)))} #{color_code}#{vertical_right}#{reset_code}"
+        end
+        (start_idx..end_idx).each do |i|
+          it = parsed_items[i]
+          mark = it[:checked] ? checked_mark : unchecked_mark
+          is_active = (i == current_cursor_idx)
+          max_w = [inner_w - display_width(mark) - 4, 4].max
+          name_str = it[:name].to_s
+          name_str = name_str[0...[max_w - 3, 1].max] + "..." if display_width(name_str) > max_w
+          raw_line = "#{is_active ? '> ' : '  '}#{mark} #{name_str}"
+          line_padded = pad_to_width(raw_line, inner_w)
+          if is_active
+            lines << "#{color_code}#{vertical_left}#{reset_code} #{Color.bright_yellow(line_padded)} #{color_code}#{vertical_right}#{reset_code}"
+          elsif it[:checked]
+            lines << "#{color_code}#{vertical_left}#{reset_code} #{Color.bright_green(line_padded)} #{color_code}#{vertical_right}#{reset_code}"
+          else
+            lines << "#{color_code}#{vertical_left}#{reset_code} #{Color.white(line_padded)} #{color_code}#{vertical_right}#{reset_code}"
+          end
+        end
+        if end_idx < (total_items - 1)
+          rem = total_items - 1 - end_idx
+          dn_t = "▼ (+#{rem} abajo)"
+          pad_d = [inner_w - display_width(dn_t), 0].max
+          lines << "#{color_code}#{vertical_left}#{reset_code} #{Color.gray(" " * (pad_d / 2) + dn_t + " " * (pad_d - (pad_d / 2)))} #{color_code}#{vertical_right}#{reset_code}"
+        end
+        unless subtitle.to_s.empty?
+          lines << "#{color_code}#{vertical_left}#{top_fill}#{vertical_right}#{reset_code}"
+          s_clean = subtitle.to_s
+          s_clean = s_clean[0...[inner_w - 3, 1].max] + "..." if display_width(s_clean) > inner_w
+          pad_sub = [inner_w - display_width(s_clean), 0].max
+          sub_padded = (" " * (pad_sub / 2)) + s_clean + (" " * (pad_sub - (pad_sub / 2)))
+          lines << "#{color_code}#{vertical_left}#{reset_code} #{Color.gray(sub_padded)} #{color_code}#{vertical_right}#{reset_code}"
+        end
+        lines << "#{color_code}#{border_chars[:bl]}#{bot_fill}#{border_chars[:br]}#{reset_code}"
+      end
+
+      frame = lines.join("\r\n") + "\r\n"
+      Kernel.print("\e[#{drawn_lines}A\e[J") if drawn_lines > 0
+      Kernel.print(frame)
+      $stdout.flush
+      drawn_lines = lines.length
+    end
+
+    is_tty = $stdin.respond_to?(:tty?) && $stdin.tty?
+    submitted = false
+
+    begin
+      Kernel.print(HIDE_CURSOR)
+      render_frame.call
+
+      reader = lambda do |stream|
+        while true
+          # Para efecto Chroma/RGB, usamos un polling select de 35ms para avanzar el arcoíris
+          if is_rgb
+            ready = false
+            if stream.respond_to?(:to_io) || stream.is_a?(IO)
+              begin
+                sr = IO.select([stream], nil, nil, 0.035)
+                ready = true if sr && sr[0] && !sr[0].empty?
+              rescue StandardError
+                ready = true
+              end
+            else
+              ready = true
+            end
+            unless ready
+              rgb_tick += 0.08
+              render_frame.call
+              next
+            end
+          end
+
+          key = GRmenu.read_key_raw(stream)
+          break if key.nil? || key == "\x03" || key == "\x04" || key == "q" || key == "Q" || key == "\e"
+
+          if key == "\e[A" || key == "\eOA" || key == "\xe0H" || key == "\x00H"
+            # Flecha Arriba
+            current_cursor_idx = (current_cursor_idx - 1) % parsed_items.length
+            render_frame.call
+          elsif key == "\e[B" || key == "\eOB" || key == "\xe0P" || key == "\x00P"
+            # Flecha Abajo
+            current_cursor_idx = (current_cursor_idx + 1) % parsed_items.length
+            render_frame.call
+          elsif key == " "
+            # Alternar estado del elemento actual
+            parsed_items[current_cursor_idx][:checked] = !parsed_items[current_cursor_idx][:checked]
+            render_frame.call
+          elsif key == "a" || key == "A"
+            # Marcar todos
+            parsed_items.each { |item| item[:checked] = true }
+            render_frame.call
+          elsif key == "n" || key == "N"
+            # Desmarcar todos
+            parsed_items.each { |item| item[:checked] = false }
+            render_frame.call
+          elsif key == "i" || key == "I"
+            # Invertir selecciones
+            parsed_items.each { |item| item[:checked] = !item[:checked] }
+            render_frame.call
+          elsif key == "\r" || key == "\n"
+            # Enter: confirmar la selección
+            submitted = true
+            break
+          end
+        end
+      end
+
+      if is_tty
+        $stdin.raw { |s| reader.call(s) }
+      else
+        reader.call($stdin)
+      end
+    ensure
+      Kernel.print(SHOW_CURSOR)
+    end
+
+    if submitted
+      # Retornar los objetos o estructuras originales que quedaron seleccionados
+      selected_items = parsed_items.select { |item| item[:checked] }
+      selected_items.map { |item| item[:original] }
+    else
+      []
+    end
+  end
+
+  class << self
+    alias_method :select_multi, :checkbox
+    alias_method :multiselect, :checkbox
+  end
+end