ruby_rich 0.4.0 → 0.4.2

data/lib/ruby_rich/console.rb

@@ -1,4 +1,6 @@
 require 'io/console'
+require_relative 'event'
+require_relative 'terminal'
 
 module RubyRich
   class Console
@@ -18,7 +20,25 @@ module RubyRich
       # 其他
       '[5~' => :page_up, '[6~' => :page_down,
       '[H' => :home, '[F' => :end,
-      '[2~' => :insert, '[3~' => :delete
+      '[2~' => :insert, '[3~' => :delete,
+      '[Z' => :shift_tab,
+      '[13;2u' => :shift_enter,
+      '[13;3u' => :alt_enter,
+      '[13;2~' => :shift_enter,
+      '[13;3~' => :alt_enter
+    }.freeze
+
+    WINDOWS_SPECIAL_KEYS = {
+      72 => :up,
+      80 => :down,
+      75 => :left,
+      77 => :right,
+      71 => :home,
+      79 => :end,
+      73 => :page_up,
+      81 => :page_down,
+      82 => :insert,
+      83 => :delete
     }.freeze
 
     def initialize
@@ -86,45 +106,104 @@ module RubyRich
       system('clear')
     end
 
+    def get_event(input: $stdin)
+      if RubyRich::Terminal.windows_mouse_reporting?
+        event = RubyRich::Terminal.read_windows_input_event
+        return event if event
+      end
+
+      get_key(input: input)
+    end
+
     def get_key(input: $stdin)
       input.raw(intr: true) do |io|
+        RubyRich::Terminal.prepare_input
         char = io.getch
-        # 优先处理回车键（ASCII 13 = \r，ASCII 10 = \n）
+        bytes = char.b.bytes
+        byte = bytes.first
+
+        return Event.key(:ctrl_c) if byte == 3
+
+        # Handle Enter key first (ASCII 13 = \r, ASCII 10 = \n)
         if char == "\r" || char == "\n"
-          # 检查是否有后续输入（粘贴内容会有多个字符）
+          # Check for subsequent input (pasted content has multiple characters)
           has_more = IO.select([io], nil, nil, 0)
-          return has_more ? {:name => :string, :value => char} : {:name=>:enter}
+
+          return has_more ? Event.key(:paste, value: collect_pending_input(io, char)) : Event.key(:enter)
         end
-        # 单独处理 Tab 键（ASCII 9）
+        # Handle Tab key separately (ASCII 9)
         if char == "\t"
-          return {:name=>:tab}
-        elsif char.ord == 0x07F
-          return {:name=>:backspace}
-        elsif char == "\e" # 检测到转义序列
-          sequence = ''
-          begin
-            while (c = io.read_nonblock(1))
-              sequence << c
-            end
-          rescue IO::WaitReadable
-            retry if IO.select([io], nil, nil, 0.01)
-          rescue EOFError
+          return Event.key(:tab)
+        elsif byte == 8 || byte == 0x7F
+          return Event.key(:backspace)
+        # Windows special keys can be delivered as:
+        # - "\xE0" + a second getch byte
+        # - "\xE0H" in one read
+        elsif byte == 0 || byte == 224
+          code = bytes[1]
+          code ||= io.getch.b.bytes.first
+          return Event.key(WINDOWS_SPECIAL_KEYS[code] || :"windows_special_#{code}")
+        elsif char == "\e" # Detect escape sequence
+          sequence = char.b.bytes.drop(1).pack('C*')
+
+          sleep 0.01
+          while IO.select([io], nil, nil, 0)
+            next_char = io.getch
+            break unless next_char
+
+            sequence << next_char
+            return read_bracketed_paste(io) if sequence == "[200~"
+            break if complete_escape_sequence?(sequence)
           end
+
           if sequence.empty?
-            return {:name => :escape}
+            return Event.key(:escape)
+          elsif sequence == "\r" || sequence == "\n"
+            return Event.key(:alt_enter)
+          elsif (mouse_event = parse_sgr_mouse(sequence))
+            return mouse_event
           else
-            return {:name => ESCAPE_SEQUENCES[sequence]} || {:name => :escape}
+            return Event.key(ESCAPE_SEQUENCES[sequence] || :"ansi_#{sequence.inspect}")
           end
-        # 处理 Ctrl 组合键（排除 Tab 和回车）
-        elsif char.ord.between?(1, 8) || char.ord.between?(10, 26)
-          ctrl_char = (char.ord + 64).chr.downcase
-          return {:name =>"ctrl_#{ctrl_char}".to_sym}
+        # Handle Ctrl combinations (excluding Tab and Enter)
+        elsif byte.between?(1, 8) || byte.between?(10, 26)
+          ctrl_char = (byte + 64).chr.downcase
+          return Event.key("ctrl_#{ctrl_char}".to_sym)
         else
-          {:name => :string, :value => char}
+          if IO.select([io], nil, nil, 0)
+            Event.key(:paste, value: collect_pending_input(io, char))
+          else
+            Event.key(:string, value: char)
+          end
         end
       end
     end
 
+    def parse_sgr_mouse(sequence)
+      match = sequence.match(/\A\[<(\d+);(\d+);(\d+)([Mm])\z/)
+      return nil unless match
+
+      code = match[1].to_i
+      raw_x = match[2].to_i
+      raw_y = match[3].to_i
+      terminator = match[4]
+      button = mouse_button(code)
+      name = mouse_event_name(code, terminator)
+      direction = mouse_wheel_direction(code)
+
+      Event.mouse(
+        name,
+        button: button,
+        x: raw_x - 1,
+        y: raw_y - 1,
+        raw_x: raw_x,
+        raw_y: raw_y,
+        code: code,
+        modifiers: mouse_modifiers(code),
+        direction: direction
+      )
+    end
+
     def add_line(text)
       @lines << text
     end
@@ -151,6 +230,76 @@ module RubyRich
 
     private
 
+    def read_bracketed_paste(io)
+      terminator = "\e[201~"
+      buffer = +""
+      loop do
+        char = io.getch
+        break unless char
+
+        buffer << char
+        break if buffer.end_with?(terminator)
+      end
+      buffer = normalize_paste_text(buffer.delete_suffix(terminator))
+      Event.key(:paste, value: buffer)
+    end
+
+    def collect_pending_input(io, first_char)
+      buffer = +first_char
+      while IO.select([io], nil, nil, 0)
+        char = io.getch
+        break unless char
+
+        buffer << char
+      end
+      normalize_paste_text(buffer)
+    end
+
+    def normalize_paste_text(text)
+      text.to_s.gsub(/\r\n?/, "\n")
+    end
+
+    def complete_escape_sequence?(sequence)
+      if sequence.start_with?('[<')
+        sequence.end_with?('M') || sequence.end_with?('m') || sequence.length >= 32
+      else
+        ESCAPE_SEQUENCES.key?(sequence) || sequence.length >= 8
+      end
+    end
+
+    def mouse_event_name(code, terminator)
+      return :mouse_up if terminator == 'm'
+      return :mouse_wheel if (code & 64) == 64
+      return :mouse_drag if (code & 32) == 32
+
+      :mouse_down
+    end
+
+    def mouse_button(code)
+      return :wheel if (code & 64) == 64
+
+      case code & 3
+      when 0 then :left
+      when 1 then :middle
+      when 2 then :right
+      else :unknown
+      end
+    end
+
+    def mouse_wheel_direction(code)
+      return nil unless (code & 64) == 64
+
+      (code & 1) == 1 ? :down : :up
+    end
+
+    def mouse_modifiers(code)
+      modifiers = []
+      modifiers << :shift if (code & 4) == 4
+      modifiers << :alt if (code & 8) == 8
+      modifiers << :ctrl if (code & 16) == 16
+      modifiers
+    end
+
     def format_line(line)
       content = line.is_a?(RichText) ? line.render : line
       case @layout[:align]
@@ -163,4 +312,4 @@ module RubyRich
       end
     end
   end
-end
+end

data/lib/ruby_rich/dialog.rb

@@ -4,6 +4,7 @@ module RubyRich
     attr_accessor :width, :height
 
     def initialize(title: "", content: "", width: 48, height: 8, buttons: [:ok])
+      @title = title
       @width = width
       @height = height
       terminal_width = `tput cols`.to_i
@@ -63,4 +64,4 @@ module RubyRich
       end
     end
   end
-end
+end

data/lib/ruby_rich/event.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RubyRich
+  module Event
+    module_function
+
+    def key(name, value: nil)
+      event = { name: name, type: :key }
+      event[:value] = value unless value.nil?
+      event
+    end
+
+    def mouse(name, button:, x:, y:, raw_x:, raw_y:, code:, modifiers: [], direction: nil)
+      event = {
+        name: name,
+        type: :mouse,
+        button: button,
+        x: x,
+        y: y,
+        raw_x: raw_x,
+        raw_y: raw_y,
+        code: code,
+        modifiers: modifiers
+      }
+      event[:direction] = direction if direction
+      event
+    end
+  end
+end

data/lib/ruby_rich/focus_manager.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RubyRich
+  class FocusManager
+    attr_reader :focused_name
+
+    def initialize
+      @entries = []
+      @focused_name = nil
+    end
+
+    def register(name, layout, target)
+      @entries << { name: name, layout: layout, target: target }
+      focus(name) unless @focused_name
+      self
+    end
+
+    def attach(root_layout, priority: 500)
+      root_layout.key(:tab, priority) do |_event_data, _live|
+        current = @entries.find { |entry| entry[:name] == @focused_name }
+        if current && current[:target].respond_to?(:wants_tab?) && current[:target].wants_tab?
+          false
+        else
+          next_entry = focus_next
+          target = next_entry && next_entry[:target]
+          target.ignore_next_tab if target.respond_to?(:ignore_next_tab)
+
+          false
+        end
+      end
+
+      root_layout.key(:mouse_down, priority) do |event_data, _live|
+        entry = entry_at(event_data[:x], event_data[:y])
+        if entry
+          focus(entry[:name])
+          false
+        else
+          false
+        end
+      end
+
+      self
+    end
+
+    def focus(name)
+      entry = @entries.find { |item| item[:name] == name }
+      return nil unless entry
+
+      blur_current
+      @focused_name = entry[:name]
+      entry[:target].focus if entry[:target].respond_to?(:focus)
+      entry
+    end
+
+    def focus_next
+      return nil if @entries.empty?
+
+      index = @entries.index { |entry| entry[:name] == @focused_name } || -1
+      focus(@entries[(index + 1) % @entries.length][:name])
+    end
+
+    def focused?(name)
+      @focused_name == name
+    end
+
+    private
+
+    def blur_current
+      current = @entries.find { |entry| entry[:name] == @focused_name }
+      current[:target].blur if current && current[:target].respond_to?(:blur)
+    end
+
+    def entry_at(x, y)
+      @entries.reverse.find { |entry| entry[:layout].contains?(x, y) }
+    end
+  end
+end

data/lib/ruby_rich/layout.rb

@@ -19,6 +19,7 @@ module RubyRich
       @show = true
       @event_listeners = {}
       @event_intercepted = false
+      @mouse_capture = nil
     end
 
     def key(event_name, priority = 0, &block)
@@ -35,6 +36,8 @@ module RubyRich
     end
 
     def notify_listeners(event_data)
+      return route_mouse_event(event_data) if event_data[:type] == :mouse
+
       return if @event_intercepted
       if @dialog
         @dialog.notify_listeners(event_data)
@@ -62,6 +65,27 @@ module RubyRich
       @parent ? @parent.root : self
     end
 
+    def contains?(x, y)
+      return false unless @show
+      return false unless @width && @height
+
+      x >= @x_offset &&
+        x < @x_offset + @width &&
+        y >= @y_offset &&
+        y < @y_offset + @height
+    end
+
+    def hit_test(x, y)
+      return nil unless contains?(x, y)
+
+      @children.reverse_each do |child|
+        hit = child.hit_test(x, y)
+        return hit if hit
+      end
+
+      self
+    end
+
     def split_row(*layouts)
       @split_direction = :row
       layouts.each { |l| l.parent = self }
@@ -75,6 +99,7 @@ module RubyRich
     end
 
     def add_child(layout)
+      layout.parent = self
       @children << layout
     end
 
@@ -111,15 +136,15 @@ module RubyRich
     end
 
     def render
-      # 将缓冲区转换为字符串（每行用换行符连接）
+      # Convert buffer to string (join lines with newlines)
       buffer = render_to_buffer
       buffer.map { |line| line.compact.join("") }.join("\n")
     end
 
     def render_to_buffer
-      # 初始化缓冲区（二维数组，每个元素代表一个字符）
+      # Initialize buffer (2D array, each element represents a character)
       buffer = Array.new(@height) { Array.new(@width, " ") }
-      # 递归填充内容到缓冲区
+      # Recursively fill content into buffer
       render_into(buffer)
       render_dialog_into(buffer) if @dialog
       return buffer
@@ -150,7 +175,7 @@ module RubyRich
       content_lines = if content.is_a?(String)
                         content.split("\n")[0...height]
                       else
-                        content.render[0...height]
+                        normalize_rendered_lines(content.render)[0...height]
                       end
     
       content_lines.each_with_index do |line, line_index|
@@ -159,9 +184,9 @@ module RubyRich
     
         in_escape = false
         escape_char = ""
-        char_width = 0 # 初始宽度调整为0，方便位置计算
+        char_width = 0 # Initialize width to 0 for position calculation
         line.each_char do |char|
-          # 处理ANSI转义码
+          # Handle ANSI escape codes
           if in_escape
             escape_char += char
             in_escape = false if char == 'm'
@@ -169,49 +194,47 @@ module RubyRich
               escape_char = ""
             end
             next
-          elsif char.ord == 27 # 检测到转义开始符\e
+          elsif char.ord == 27 # Detect escape sequence start \e
             in_escape = true
             escape_char += char
             next
           end
-    
-          # 计算字符宽度
+
+          # Calculate character width
           char_w = case char.ord
-                   when 0x0000..0x007F then 1 # 英文字符
-                   when 0x4E00..0x9FFF then 2 # 中文字符
+                   when 0x0000..0x007F then 1 # English characters
+                   when 0x4E00..0x9FFF then 2 # Chinese characters
                    else Unicode::DisplayWidth.of(char)
                    end
-          # 计算字符的起始位置
+          # Calculate character start position
           x_start = x_offset + char_width
-    
-          # 超出右边界则跳过
+
+          # Skip if beyond right boundary
           next if x_start >= buffer[y_pos].size
-    
-          # 处理字符渲染（中文字符可能占用多个位置）
+
+          # Handle character rendering (Chinese characters may occupy multiple positions)
           char_w.times do |i|
             x_pos = x_start + i
-            break if x_pos >= buffer[y_pos].size # 超出右边界停止
+            break if x_pos >= buffer[y_pos].size # Stop at right boundary
             unless escape_char.empty?
-              char = escape_char + char + "\e[0m" # 每次都记录字符的实际颜色
+              char = escape_char + char + "\e[0m" # Record character's actual color each time
             end
-            buffer[y_pos][x_pos] = char unless i > 0 # 中文字符仅在第一个位置写入，避免覆盖
+            buffer[y_pos][x_pos] = char unless i > 0 # Write Chinese character only at first position to avoid overwriting
             buffer[y_pos][x_pos+1] = nil if char_w == 2
           end
-          char_width += char_w # 更新累计宽度
+          char_width += char_w # Update cumulative width
         end
       end
     end
 
     def calculate_node_dimensions(available_width, available_height)
-      # 只在未设置宽度时计算宽度
-      @width ||= if @size
-                  [@size, available_width].min
-                else
-                  available_width
-                end
+      @width = if @size && @parent&.split_direction == :row
+                 [@size, available_width].min
+               else
+                 available_width
+               end
 
-      # 只在未设置高度时计算高度
-      @height ||= if @size
+      @height = if @size && @parent&.split_direction == :column
                   [@size, available_height].min
                 else
                   available_height
@@ -220,10 +243,20 @@ module RubyRich
       if @content.class == RubyRich::Panel
         @content.width = @width
         @content.height = @height
+      else
+        @content.width = @width if @content.respond_to?(:width=)
+        @content.height = @height if @content.respond_to?(:height=)
       end
 
       return if @children.empty?
 
+      @children.each do |child|
+        next unless child.content.respond_to?(:desired_height)
+        next unless @split_direction == :column
+
+        child.size = [[child.content.desired_height, 1].max, available_height - 2].min
+      end
+
       case @split_direction
       when :row
         remaining_width = @width
@@ -290,5 +323,60 @@ module RubyRich
         end
       end
     end
+
+    private
+
+    def route_mouse_event(event_data)
+      if @dialog
+        @dialog.notify_listeners(event_data)
+        return
+      end
+
+      capture = root.instance_variable_get(:@mouse_capture)
+      target = capture && [:mouse_drag, :mouse_up].include?(event_data[:name]) ? capture : (hit_test(event_data[:x], event_data[:y]) || self)
+      handled = target.bubble_mouse_event(event_data)
+
+      root.instance_variable_set(:@mouse_capture, target) if event_data[:name] == :mouse_down && handled
+      root.instance_variable_set(:@mouse_capture, nil) if event_data[:name] == :mouse_up
+      handled
+    end
+
+    protected
+
+    def bubble_mouse_event(event_data)
+      current = self
+      while current
+        return true if current.dispatch_event_listeners(event_data)
+
+        current = current.parent
+      end
+
+      false
+    end
+
+    def dispatch_event_listeners(event_data)
+      listeners = @event_listeners[event_data[:name]]
+      return false unless listeners
+
+      listeners.each do |listener|
+        result = listener[:block].call(event_data, root.live)
+        return true if result == true
+      end
+
+      false
+    end
+
+    private
+
+    def normalize_rendered_lines(rendered)
+      case rendered
+      when String
+        rendered.split("\n")
+      when Array
+        rendered
+      else
+        rendered.to_s.split("\n")
+      end
+    end
   end
-end
+end