grmenu 4.1.0 → 5.0.0

data/data/themes/monokai.gr

@@ -52,9 +52,25 @@ GRmenu::config<-1->
   unchecked_mark:: [ ]
 >>
 
+<<input
+  style:: 4
+  border_color:: yellow:2
+  title_color:: green:2
+  label_color:: orange:2
+>>
+
 <<modal
   style:: 4
   border_color:: yellow:2
-  prompt_color:: magenta:2
-  mask_char:: *
+  title_color:: green:2
+  content_color:: white:1
+  shadow:: true
+>>
+
+<<form
+  style:: 4
+  border_color:: yellow:2
+  title_color:: green:2
+  focus_color:: magenta:2
+  shadow:: true
 >>

data/data/themes/nord.gr

@@ -52,9 +52,25 @@ GRmenu::config<-1->
   unchecked_mark:: [ ]
 >>
 
+<<input
+  style:: 6
+  border_color:: blue:2
+  title_color:: cyan:2
+  label_color:: aqua:2
+>>
+
 <<modal
   style:: 6
   border_color:: blue:2
-  prompt_color:: cyan:2
-  mask_char:: *
+  title_color:: cyan:2
+  content_color:: white:1
+  shadow:: true
+>>
+
+<<form
+  style:: 6
+  border_color:: blue:2
+  title_color:: cyan:2
+  focus_color:: aqua:2
+  shadow:: true
 >>

data/data/themes/sunset.gr

@@ -52,9 +52,25 @@ GRmenu::config<-1->
   unchecked_mark:: [ ]
 >>
 
+<<input
+  style:: 19
+  border_color:: orange:2
+  title_color:: yellow:2
+  label_color:: pink:2
+>>
+
 <<modal
   style:: 19
   border_color:: orange:2
-  prompt_color:: yellow:2
-  mask_char:: *
+  title_color:: yellow:2
+  content_color:: white:1
+  shadow:: true
+>>
+
+<<form
+  style:: 19
+  border_color:: orange:2
+  title_color:: yellow:2
+  focus_color:: yellow:2
+  shadow:: true
 >>

data/grmenu/animation.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+class GRmenu
+  # Divide una cadena con secuencias ANSI en un arreglo de caracteres individuales,
+  # asociando a cada caracter el código de estilo ANSI que tenía activo.
+  # Esto permite manipular o animar la matriz de texto celda por celda sin romper escapes.
+  def self.split_ansi_chars(str)
+    segments = []
+    current_style = String.new("")
+    in_escape = false
+    escape_buffer = String.new("")
+
+    str.to_s.each_char do |ch|
+      if ch == "\e"
+        in_escape = true
+        escape_buffer << ch
+        next
+      end
+      if in_escape
+        escape_buffer << ch
+        # Las secuencias de formato de estilo terminan en una letra
+        if ch =~ /[a-zA-Z]/
+          in_escape = false
+          current_style = escape_buffer.dup
+          escape_buffer.clear
+        end
+        next
+      end
+      segments << { char: ch, style: current_style.dup }
+    end
+    segments
+  end
+
+  # Ejecuta una animación de transición al presentar el menú en pantalla.
+  # Tipos soportados:
+  # - :diagonal -> Ola diagonal progresiva que revela el menú desde la esquina superior izquierda.
+  # - :linear   -> Aparición línea por línea de arriba hacia abajo.
+  # - :fade     -> Efecto de aparición gradual aumentando el brillo de los caracteres.
+  # - :rainbow  -> Barrido espectral multicolor continuo de arcoíris.
+  # - :chroma   -> Alias de rainbow.
+  def self.animate_render(lines, type = :diagonal, delay = 0.012)
+    type_str = type.to_s.downcase
+    return if lines.nil? || lines.empty?
+    reset_seq = ansi_reset
+
+    case type_str
+    when "diagonal"
+      # Tokeniza cada fila conservando sus estilos ANSI
+      parsed_rows = lines.map { |l| split_ansi_chars(l) }
+      max_len = parsed_rows.map(&:length).max || 0
+      total_steps = max_len + (parsed_rows.length * 2)
+      step = 0
+
+      while step <= total_steps
+        buffer = String.new(CURSOR_HOME)
+        parsed_rows.each_with_index do |row_segments, y|
+          rendered_row = String.new("")
+          row_segments.each_with_index do |segment, x|
+            # Ecuación de frente de onda diagonal: los puntos donde (x + 2y) <= step ya se revelaron
+            if (x + y * 2) <= step
+              rendered_row << segment[:style] << segment[:char] << reset_seq
+            else
+              rendered_row << " "
+            end
+          end
+          buffer << rendered_row << CLEAR_TO_EOL << "\r\n"
+        end
+        buffer << CLEAR_TO_EOS
+        Kernel.print(buffer)
+        $stdout.flush
+        sleep(delay)
+        step += 4 # Incremento de paso para mantener fluidez a 30-60 FPS
+      end
+    when "linear"
+      buffer = String.new(CURSOR_HOME)
+      lines.each do |line|
+        Kernel.print("#{line}#{CLEAR_TO_EOL}\r\n")
+        $stdout.flush
+        sleep(delay * 3)
+      end
+    when "fade"
+      [1, 2].each do |lvl|
+        buffer = String.new(CURSOR_HOME)
+        lines.each do |line|
+          clean_line = line.gsub(/\e\[[0-9;]*m/, '')
+          buffer << ansi_color("white", lvl) << clean_line << reset_seq << CLEAR_TO_EOL << "\r\n"
+        end
+        buffer << CLEAR_TO_EOS
+        Kernel.print(buffer)
+        $stdout.flush
+        sleep(delay * 8)
+      end
+    when "rainbow", "chroma", "rgb"
+      # Barrido de espectro cromático que revela la matriz con una ola multicolor viva
+      parsed_rows = lines.map { |l| split_ansi_chars(l) }
+      max_len = parsed_rows.map(&:length).max || 0
+      total_steps = max_len + (parsed_rows.length * 2)
+      step = 0
+
+      while step <= total_steps
+        buffer = String.new(CURSOR_HOME)
+        parsed_rows.each_with_index do |row_segments, y|
+          rendered_row = String.new("")
+          row_segments.each_with_index do |segment, x|
+            if (x + y * 2) <= step
+              # Al revelarse, genera la secuencia espectral de color arcoíris
+              wave_color = rgb_color(step * 0.12, (x + y * 2) * 0.08)
+              rendered_row << wave_color << segment[:char] << reset_seq
+            else
+              rendered_row << " "
+            end
+          end
+          buffer << rendered_row << CLEAR_TO_EOL << "\r\n"
+        end
+        buffer << CLEAR_TO_EOS
+        Kernel.print(buffer)
+        $stdout.flush
+        sleep(delay)
+        step += 4
+      end
+    when "chromatic", "cromatico"
+      # Transición de aparición con brillo cromático gradual
+      [0.3, 0.6, 1.0].each do |factor|
+        buffer = String.new(CURSOR_HOME)
+        lines.each do |line|
+          clean_line = line.gsub(/\e\[[0-9;]*m/, '')
+          r = (60 * factor).to_i
+          g = (255 * factor).to_i
+          b = (255 * factor).to_i
+          buffer << "\e[38;2;#{r};#{g};#{b}m#{clean_line}#{reset_seq}" << CLEAR_TO_EOL << "\r\n"
+        end
+        buffer << CLEAR_TO_EOS
+        Kernel.print(buffer)
+        $stdout.flush
+        sleep(delay * 6)
+      end
+    end
+  end
+end

data/grmenu/banner.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+class GRmenu
+  # Construye las filas de arte ASCII 3D para un texto dado utilizando una de las 10 fuentes.
+  # Intenta ajustar el espaciado entre letras (2, 1 o 0 espacios) para que el banner quepa
+  # comodamente dentro del ancho de la terminal sin desbordar.
+  def self.build_ascii_lines(text, max_cols = terminal_width, font_id = 1)
+    target_font = FONTS[font_id.to_i] || FONTS[1]
+    clean_chars = text.to_s.upcase.chars.select { |char| target_font.key?(char) }
+    return [] if clean_chars.empty?
+
+    font_height = target_font.values.first.length
+
+    # Prueba sucesivamente con espaciado amplio (2), medio (1) y compacto (0)
+    [2, 1, 0].each do |spacing|
+      lines = Array.new(font_height, "")
+      clean_chars.each_with_index do |char, idx|
+        glyph_rows = target_font[char]
+        padding = (idx == clean_chars.length - 1) ? "" : (" " * spacing)
+        font_height.times { |row_i| lines[row_i] += glyph_rows[row_i] + padding }
+      end
+
+      max_line_len = lines.map { |line| display_width(line) }.max
+      # Si cabe con holgura en las columnas de la terminal, lo retornamos
+      return lines if (max_line_len + 6) <= max_cols
+    end
+
+    # Si el texto es demasiado largo para cualquier espaciado ASCII, retornamos nil para fallback a texto plano
+    nil
+  end
+
+  # Renderiza un banner ASCII 3D enmarcado directamente en la terminal.
+  # Soporta colores ANSI calibrados o degradado continuo RGB Chroma Wave.
+  def self.banner(text, delay = 0, color: "magenta", level: 2, style: 3, font: 1)
+    cols = terminal_width
+    is_rgb = (color.to_s.downcase == "rgb" || color.to_s.downcase == "rainbow" || color.to_s.downcase == "chroma")
+    color_code = is_rgb ? "" : ansi_color(color, level)
+    reset_code = ansi_reset
+
+    ascii_rows = build_ascii_lines(text, cols, font)
+    border_cfg = BORDERS[style] || BORDERS[3]
+    h_top = border_cfg[:ht] || border_cfg[:h]
+    h_bot = border_cfg[:hb] || border_cfg[:h]
+    v_l   = border_cfg[:vl] || border_cfg[:v]
+    v_r   = border_cfg[:vr] || border_cfg[:v]
+
+    # Caso A: El texto cupo como arte ASCII 3D
+    if ascii_rows
+      max_len = ascii_rows.map { |r| display_width(r) }.max
+      # Calcula la linea de relleno superior e inferior repitiendo el caracter de borde
+      top_fill = (h_top * ((max_len + 4).to_f / h_top.length).ceil)[0...(max_len + 4)]
+      bot_fill = (h_bot * ((max_len + 4).to_f / h_bot.length).ceil)[0...(max_len + 4)]
+
+      if is_rgb
+        Kernel.print("#{Color.rgb("#{border_cfg[:tl]}#{top_fill}#{border_cfg[:tr]}")}\r\n")
+        ascii_rows.each_with_index do |line, idx|
+          pad = " " * (max_len - display_width(line))
+          row_content = "  #{line}#{pad}  "
+          Kernel.print("#{Color.rgb(v_l)}#{Color.rgb(row_content, idx * 0.2)}#{Color.rgb(v_r)}\r\n")
+          sleep(delay) if delay > 0
+        end
+        Kernel.print("#{Color.rgb("#{border_cfg[:bl]}#{bot_fill}#{border_cfg[:br]}")}\r\n")
+      else
+        Kernel.print("#{color_code}#{border_cfg[:tl]}#{top_fill}#{border_cfg[:tr]}#{reset_code}\r\n")
+        ascii_rows.each do |line|
+          pad = " " * (max_len - display_width(line))
+          Kernel.print("#{color_code}#{v_l}  #{line}#{pad}  #{v_r}#{reset_code}\r\n")
+          sleep(delay) if delay > 0
+        end
+        Kernel.print("#{color_code}#{border_cfg[:bl]}#{bot_fill}#{border_cfg[:br]}#{reset_code}\r\n")
+      end
+    # Caso B: Fallback a texto normal centrado dentro de una caja
+    else
+      clean_t = text.to_s.strip
+      box_w = [display_width(clean_t) + 6, cols - 2].min
+      top_fill = (h_top * ((box_w - 2).to_f / h_top.length).ceil)[0...(box_w - 2)]
+      bot_fill = (h_bot * ((box_w - 2).to_f / h_bot.length).ceil)[0...(box_w - 2)]
+
+      pad_t = [box_w - 4 - display_width(clean_t), 0].max
+      l_p = " " * (pad_t / 2)
+      r_p = " " * (pad_t - (pad_t / 2))
+
+      if is_rgb
+        Kernel.print("#{Color.rgb("#{border_cfg[:tl]}#{top_fill}#{border_cfg[:tr]}")}\r\n")
+        Kernel.print("#{Color.rgb(v_l)} #{Color.rgb(l_p + clean_t + r_p)} #{Color.rgb(v_r)}\r\n")
+        Kernel.print("#{Color.rgb("#{border_cfg[:bl]}#{bot_fill}#{border_cfg[:br]}")}\r\n")
+      else
+        Kernel.print("#{color_code}#{border_cfg[:tl]}#{top_fill}#{border_cfg[:tr]}#{reset_code}\r\n")
+        Kernel.print("#{color_code}#{v_l} #{l_p}#{clean_t}#{r_p} #{v_r}#{reset_code}\r\n")
+        Kernel.print("#{color_code}#{border_cfg[:bl]}#{bot_fill}#{border_cfg[:br]}#{reset_code}\r\n")
+      end
+    end
+  end
+
+  class << self
+    alias_method :message, :banner
+    alias_method :logo, :banner
+  end
+end

data/grmenu/color.rb

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+
+class GRmenu
+  # Genera un color TrueColor (24 bits) basado en una onda senoidal cromática.
+  # Los tres canales (R, G, B) están desfasados en 120 grados (2*pi/3 = 2.0943951 rad)
+  # para producir una transición de arcoíris fluida a lo largo del tiempo.
+  def self.rgb_color(tick, offset = 0.0)
+    time = tick.to_f + offset.to_f
+    red   = (Math.sin(time) * 127 + 128).clamp(0, 255).to_i
+    green = (Math.sin(time + 2.0943951) * 127 + 128).clamp(0, 255).to_i
+    blue  = (Math.sin(time + 4.1887902) * 127 + 128).clamp(0, 255).to_i
+    "\e[38;2;#{red};#{green};#{blue}m"
+  end
+
+  # Resuelve cualquier especificación de color a su secuencia de escape ANSI correspondiente.
+  # Admite:
+  # - Nombres integrados con nivel ("cyan:2", "red:1", etc.)
+  # - Palabras clave dinámicas ("rgb", "chroma", "rainbow")
+  # - Prefijos cromáticos ("chromatic_cyan", "cromatico_red")
+  # - Hexadecimal de 6 dígitos ("#FF0055" o "FF0055")
+  # - Hexadecimal shorthand de 3 dígitos ("#F05" o "F05")
+  def self.ansi_color(color_name, level = 1)
+    clean_name = color_name.to_s.downcase.strip
+    if clean_name.include?(":")
+      parts = clean_name.split(":")
+      clean_name = parts[0].strip
+      level = parts[1].to_i if parts[1] && !parts[1].empty?
+    end
+
+    return rgb_color(0.0) if clean_name == "rgb" || clean_name == "rainbow" || clean_name == "chroma"
+
+    # Hexadecimal de 6 dígitos (#RRGGBB)
+    if clean_name =~ /\A#?([0-9a-f]{6})\z/i
+      hex_code = $1
+      r = hex_code[0..1].to_i(16)
+      g = hex_code[2..3].to_i(16)
+      b = hex_code[4..5].to_i(16)
+      return "\e[38;2;#{r};#{g};#{b}m"
+    # Hexadecimal shorthand de 3 dígitos (#RGB) duplicado a (#RRGGBB)
+    elsif clean_name =~ /\A#?([0-9a-f]{3})\z/i
+      hex_code = $1
+      r = (hex_code[0] * 2).to_i(16)
+      g = (hex_code[1] * 2).to_i(16)
+      b = (hex_code[2] * 2).to_i(16)
+      return "\e[38;2;#{r};#{g};#{b}m"
+    end
+
+    # Mapeo transparente para nombres cromáticos contra colors.json
+    lookup_name = clean_name
+    unless COLORS.key?(lookup_name)
+      if lookup_name.start_with?("cromatico_")
+        lookup_name = lookup_name.sub(/\Acromatico_/, "chromatic_")
+      elsif lookup_name.start_with?("chromatic_")
+        lookup_name = lookup_name.sub(/\Achromatic_/, "cromatico_")
+      end
+    end
+
+    level_str = level.to_s
+    code_raw = COLORS.dig(lookup_name, level_str) || COLORS.dig(lookup_name, level.to_i) || COLORS[lookup_name]
+    return "\e[#{code_raw}" if code_raw
+    "\e[37m"
+  end
+
+  # Secuencia de reseteo ANSI a colores predeterminados de la terminal.
+  def self.ansi_reset
+    "\e[0m"
+  end
+
+  # Módulo utilitario para colorear texto directamente en consola o scripts de Ruby.
+  module Color
+    RESET = "\e[0m"
+    BOLD  = "\e[1m"
+    module_function
+
+    # Pinta un texto con el color indicado y asegura el reseteo al final.
+    def paint(text, color_name, level = 1)
+      color_str = color_name.to_s.downcase
+      if color_str == "rgb" || color_str == "rainbow" || color_str == "chroma"
+        return rgb(text)
+      end
+      code = GRmenu.ansi_color(color_name, level) || "\e[37m"
+      "#{code}#{text}#{RESET}"
+    end
+
+    # Aplica un degradado RGB dinámico caracter por caracter respetando secuencias previas.
+    def rgb(text, offset = 0.0)
+      output_str = String.new("")
+      char_index = 0
+      in_escape  = false
+      escape_buffer = String.new("")
+
+      text.to_s.each_char do |ch|
+        # Si encontramos el inicio de una secuencia ANSI existente, no la rompemos
+        if ch == "\e"
+          in_escape = true
+          escape_buffer << ch
+          next
+        end
+        if in_escape
+          escape_buffer << ch
+          # Las secuencias ANSI terminan en una letra (ej. m, H, J, etc.)
+          if ch =~ /[a-zA-Z]/
+            in_escape = false
+            output_str << escape_buffer
+            escape_buffer.clear
+          end
+          next
+        end
+
+        # Espacios y saltos de línea avanzan la posición de columna visual para mantener la fase continua
+        w = (GRmenu.char_width(ch) rescue 1)
+        if ch == " " || ch == "\n" || ch == "\r" || ch == "\t"
+          output_str << ch
+          char_index += w
+        else
+          # Calcula el desfase de color individual para dar efecto de ola (chroma wave)
+          t = char_index * 0.12 + offset
+          r = (Math.sin(t) * 127 + 128).clamp(0, 255).to_i
+          g = (Math.sin(t + 2.0943951) * 127 + 128).clamp(0, 255).to_i
+          b = (Math.sin(t + 4.1887902) * 127 + 128).clamp(0, 255).to_i
+          output_str << "\e[38;2;#{r};#{g};#{b}m#{ch}"
+          char_index += w
+        end
+      end
+      output_str << RESET
+      output_str
+    end
+
+    # Métodos directos para el espectro cromático continuo (RGB / Rainbow / Chroma)
+    def rainbow(text, offset = 0.0)
+      rgb(text, offset)
+    end
+
+    def chroma(text, offset = 0.0)
+      rgb(text, offset)
+    end
+
+    def chromatic(text, offset = 0.0)
+      rgb(text, offset)
+    end
+
+    def cromatico(text, offset = 0.0)
+      rgb(text, offset)
+    end
+
+    # Métodos directos para colores clásicos
+    def red(s);            paint(s, :red, 1);     end
+    def bright_red(s);     paint(s, :red, 2);     end
+    def dark_red(s);       paint(s, :red, 1);     end
+
+    def green(s);          paint(s, :green, 1);   end
+    def bright_green(s);   paint(s, :green, 2);   end
+    def dark_green(s);     paint(s, :green, 1);   end
+
+    def yellow(s);         paint(s, :yellow, 1);  end
+    def bright_yellow(s);  paint(s, :yellow, 2);  end
+
+    def blue(s);           paint(s, :blue, 1);    end
+    def bright_blue(s);    paint(s, :blue, 2);    end
+
+    def magenta(s);        paint(s, :magenta, 1); end
+    def bright_magenta(s); paint(s, :magenta, 2); end
+
+    def purple(s);         paint(s, :purple, 1);  end
+    def bright_purple(s);  paint(s, :purple, 2);  end
+
+    def pink(s);           paint(s, :pink, 1);    end
+    def bright_pink(s);    paint(s, :pink, 2);    end
+
+    def cyan(s);           paint(s, :cyan, 1);    end
+    def bright_cyan(s);    paint(s, :cyan, 2);    end
+
+    def aqua(s);           paint(s, :aqua, 1);    end
+    def bright_aqua(s);    paint(s, :aqua, 2);    end
+
+    def orange(s);         paint(s, :orange, 1);  end
+    def bright_orange(s);  paint(s, :orange, 2);  end
+
+    def white(s);          paint(s, :white, 1);   end
+    def bright_white(s);   paint(s, :white, 2);   end
+
+    def black(s);          paint(s, :black, 1);   end
+    def gray(s);           paint(s, :gray, 1);    end
+    def bright_gray(s);    paint(s, :gray, 2);    end
+    def grey(s);           gray(s);               end
+
+    # Métodos cromáticos vivos (anteriormente llamados neón)
+    def chromatic_red(s);       paint(s, :chromatic_red, 2);     end
+    def chromatic_green(s);     paint(s, :chromatic_green, 2);   end
+    def chromatic_cyan(s);      paint(s, :chromatic_cyan, 2);    end
+    def chromatic_blue(s);      paint(s, :chromatic_blue, 2);    end
+    def chromatic_pink(s);      paint(s, :chromatic_pink, 2);    end
+    def chromatic_yellow(s);    paint(s, :chromatic_yellow, 2);  end
+    def chromatic_orange(s);    paint(s, :chromatic_orange, 2);  end
+    def chromatic_purple(s);    paint(s, :chromatic_purple, 2);  end
+    def chromatic_magenta(s);   paint(s, :chromatic_magenta, 2); end
+    def chromatic_aqua(s);      paint(s, :chromatic_aqua, 2);    end
+    def chromatic_lime(s);      paint(s, :chromatic_lime, 2);    end
+    def chromatic_white(s);     paint(s, :chromatic_white, 2);   end
+
+    # Variantes en español
+    def cromatico_red(s);       paint(s, :cromatico_red, 2);     end
+    def cromatico_green(s);     paint(s, :cromatico_green, 2);   end
+    def cromatico_cyan(s);      paint(s, :cromatico_cyan, 2);    end
+    def cromatico_blue(s);      paint(s, :cromatico_blue, 2);    end
+    def cromatico_pink(s);      paint(s, :cromatico_pink, 2);    end
+    def cromatico_yellow(s);    paint(s, :cromatico_yellow, 2);  end
+    def cromatico_orange(s);    paint(s, :cromatico_orange, 2);  end
+    def cromatico_purple(s);    paint(s, :cromatico_purple, 2);  end
+    def cromatico_magenta(s);   paint(s, :cromatico_magenta, 2); end
+    def cromatico_aqua(s);      paint(s, :cromatico_aqua, 2);    end
+    def cromatico_lime(s);      paint(s, :cromatico_lime, 2);    end
+    def cromatico_white(s);     paint(s, :cromatico_white, 2);   end
+
+    # Abreviaturas comunes para prototipado veloz
+    def r(s);  bright_red(s);     end
+    def dr(s); dark_red(s);       end
+    def g(s);  bright_green(s);   end
+    def y(s);  bright_yellow(s);  end
+    def w(s);  bright_white(s);   end
+    def gr(s); gray(s);           end
+    def cy(s); bright_cyan(s);    end
+    def mg(s); bright_magenta(s); end
+    def bl(s); bright_blue(s);    end
+
+    # Pinta texto en negrita (bold)
+    def bold(s)
+      "#{BOLD}#{s}#{RESET}"
+    end
+
+    # Pinta texto con color hexadecimal directo
+    def hex(code, text)
+      c = GRmenu.ansi_color(code.to_s)
+      "#{c}#{text}#{RESET}"
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      m = method_name.to_s
+      GRmenu::COLORS.key?(m) || GRmenu::COLORS.key?(m.sub(/\Acromatico_/, 'chromatic_')) || super
+    end
+
+    # Permite invocar dinámicamente cualquier color cargado en colors.json o alias cromáticos
+    def method_missing(method_name, *args, &block)
+      m_str = method_name.to_s
+      lookup = m_str
+      unless GRmenu::COLORS.key?(lookup)
+        if lookup.start_with?("cromatico_")
+          lookup = lookup.sub(/\Acromatico_/, 'chromatic_')
+        elsif lookup.start_with?("chromatic_")
+          lookup = lookup.sub(/\Achromatic_/, 'cromatico_')
+        end
+      end
+      if GRmenu::COLORS.key?(lookup)
+        text = args[0].to_s
+        lvl = args[1] || 2
+        paint(text, m_str, lvl)
+      else
+        super
+      end
+    end
+  end
+
+  # Alias rápido para el módulo Color
+  C = Color
+end