rcurses 4.9.4 → 5.0.0

data/examples/basic_panes.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+
+require 'rcurses'
+
+@max_h, @max_w = IO.console.winsize
+
+# Start by creating the panes; Format:
+# pane      = Rcurses::Pane.new(      startx, starty,        width,     height,  fg,  bg)
+pane_top    = Rcurses::Pane.new(           1,      1,       @max_w,          1, 255, 236)
+pane_bottom = Rcurses::Pane.new(           1, @max_h,       @max_w,          1, 236, 254)
+pane_left   = Rcurses::Pane.new(           2,      3, @max_w/2 - 2, @max_h - 4,  52, nil)
+pane_right  = Rcurses::Pane.new(@max_w/2 + 1,      2,     @max_w/2, @max_h - 2, 255,  52)
+
+pane_left.border     = true # Adding a border to the left pane
+
+# Add content to the panes
+pane_top.text        = Time.now.to_s[0..15].b + "   Welcome to the rcurses example program"
+pane_left.text       = `ls --color`
+pane_right.text      = "Output of free:\n\n" + `free`
+pane_bottom.prompt   = "Enter any text and press ENTER: ".b # The prompt text before the user starts writing content
+
+pane_top.refresh     # This is the order of drawing/refreshing the panes
+pane_left.refresh    # ...then the left pane
+pane_right.refresh   # ...and the right pane
+pane_bottom.editline # Do not use a refresh before editline
+
+# Then create a "pop-up" pane in the middle of the screen
+pane_mid             = Rcurses::Pane.new(@max_w/2 - 10, @max_h/2 - 5, 20, 10, 18,  254)
+pane_mid.border      = true
+pane_mid.text        = "You wrote:" + "\n" + pane_bottom.text.i
+pane_mid.align       = "c"
+pane_mid.refresh
+
+# Then ask the user to hit ENTER before exiting the program
+pane_bottom.prompt   = "Now hit ENTER again "
+pane_bottom.text     = ""
+pane_bottom.editline
+
+# Reset terminal
+$stdin.cooked!
+$stdin.echo = true
+Rcurses::clear_screen
+Rcurses::Cursor.show

data/examples/focus_panes.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+require 'rcurses'
+include Rcurses::Input
+include Rcurses::Cursor
+
+@max_h, @max_w = IO.console.winsize
+@pane    = []
+@focused = 3 # Start with pane 3 so that the first keypress focuses back to Pane 0
+Rcurses::Cursor.hide
+
+# Start by creating the panes; Format:
+# pane    = Rcurses::Pane.new( startx, starty,  width, height,  fg,  bg)
+pane_back = Rcurses::Pane.new(      1,      1, @max_w, @max_h, nil, 236)
+@pane[0]  = Rcurses::Pane.new(      4,      4,     20,     10, 236, 254)
+@pane[1]  = Rcurses::Pane.new(     30,     10,     16,     12, 232, 132)
+@pane[2]  = Rcurses::Pane.new(      8,     20,     30,     20, 136,  54)
+@pane[3]  = Rcurses::Pane.new(     50,     30,     24,     10, 206,  24)
+
+pane_back.text = "PRESS ANY KEY TO SHIFT FOCUS. PRESS 'ESC' TO QUIT."
+@pane.each_index { |i| @pane[i].text = "This is pane " + i.to_s }
+pane_back.full_refresh
+@pane.each_index { |i| @pane[i].refresh }
+
+input = ''
+while input != 'ESC'
+  input = getchr
+  pane_back.full_refresh
+  @focused += 1
+  @focused  = 0 if @focused == @pane.size
+  @pane.each_index {|i| @pane[i].border = false}
+  @pane.each_index {|i| @pane[i].full_refresh}
+  @pane[@focused].border = true
+  @pane[@focused].full_refresh
+end
+
+# Always end an application with these lines:
+$stdin.cooked!
+$stdin.echo = true
+Rcurses.clear_screen
+Rcurses::Cursor.show
+

data/lib/rcurses/cursor.rb

@@ -0,0 +1,48 @@
+module Rcurses
+  module Cursor
+    # Terminal cursor movement ANSI codes (inspired by https://github.com/piotrmurach/tty-cursor)
+    module_function
+    ESC = "\e".freeze
+    CSI = "\e[".freeze
+    def save;    print(Gem.win_platform? ? CSI + 's' : ESC + '7'); end # Save current position
+    def restore; print(Gem.win_platform? ? CSI + 'u' : ESC + '8'); end # Restore cursor position
+    def pos # Query cursor current position
+      res = ''
+      $stdin.raw do |stdin|
+        $stdout << CSI + '6n' # The actual ANSI get-position
+        $stdout.flush
+        while (c = stdin.getc) != 'R'
+          res << c if c
+        end
+      end
+      m = res.match(/(?<row>\d+);(?<col>\d+)/)
+      return m[:row].to_i, m[:col].to_i
+    end
+    def rowget
+      row, _col = pos
+      row
+    end
+    def colget
+      _row, col = pos
+      col
+    end
+    def set(r = 1, c = 1); print(CSI + "#{r}d"); print(CSI + "#{c}G");  end # Set cursor position to Row, Col (y,x)
+    def up(n = 1);         print(CSI + "#{(n)}A");                      end # Move cursor up by n
+    def down(n = 1);       print(CSI + "#{(n)}B");                      end # Move the cursor down by n
+    def left(n = 1);       print(CSI + "#{n}D");                        end # Move the cursor backward by n
+    def right(n = 1);      print(CSI + "#{n}C");                        end # Move the cursor forward by n
+    def col(c = 1);        print(CSI + "#{c}G");                        end # Cursor moves to nth position horizontally in the current line
+    def row(r = 1);        print(CSI + "#{r}d");                        end # Cursor moves to the nth position vertically in the current column
+    def next_line;         print(CSI + 'E' + CSI + "1G");               end # Move cursor down to beginning of next line
+    def prev_line;         print(CSI + 'A' + CSI + "1G");               end # Move cursor up to beginning of previous line
+    def clear_char(n = 1); print(CSI + "#{n}X");                        end # Erase n characters from the current cursor position
+    def clear_line;        print(CSI + '2K' + CSI + "1G");              end # Erase the entire current line and return to beginning of the line
+    def clear_line_before; print(CSI + '1K');                           end # Erase from the beginning of the line up to and including the current cursor position.
+    def clear_line_after;  print(CSI + '0K');                           end # Erase from the current position (inclusive) to the end of the line
+    def clear_screen_down; print(CSI + 'J');                            end # Clear screen down from current row
+    def scroll_up;         print(ESC + 'M');                            end # Scroll display up one line
+    def scroll_down;       print(ESC + 'D');                            end # Scroll display down one line
+    def hide;              print(CSI + '?25l');                         end # Scroll display down one line
+    def show;              print(CSI + '?25h');                         end # Scroll display down one line
+  end
+end

data/lib/rcurses/general.rb

@@ -0,0 +1,99 @@
+module Rcurses
+  @@terminal_state_saved = false
+  @@original_stty_state = nil
+  
+  def self.clear_screen
+    # ANSI code \e[2J clears the screen, and \e[H moves the cursor to the top left.
+    print "\e[2J\e[H"
+  end
+  
+  def self.save_terminal_state(install_handlers = false)
+    unless @@terminal_state_saved
+      @@original_stty_state = `stty -g 2>/dev/null`.chomp rescue nil
+      @@terminal_state_saved = true
+      setup_signal_handlers if install_handlers
+    end
+  end
+  
+  def self.restore_terminal_state
+    if @@terminal_state_saved && @@original_stty_state
+      begin
+        # Restore terminal settings
+        system("stty #{@@original_stty_state} 2>/dev/null")
+        # Reset terminal
+        print "\e[0m\e[?25h\e[?7h\e[r"
+        STDOUT.flush
+      rescue
+        # Fallback restoration
+        begin
+          STDIN.cooked! rescue nil
+          STDIN.echo = true rescue nil
+        rescue
+        end
+      end
+    end
+    @@terminal_state_saved = false
+  end
+  
+  def self.setup_signal_handlers
+    ['TERM', 'INT', 'QUIT', 'HUP'].each do |signal|
+      Signal.trap(signal) do
+        restore_terminal_state
+        exit(1)
+      end
+    end
+    
+    # Handle WINCH (window size change) gracefully
+    Signal.trap('WINCH') do
+      # Just ignore for now - applications should handle this themselves
+    end
+  end
+  
+  def self.with_terminal_protection(install_handlers = true)
+    save_terminal_state(install_handlers)
+    begin
+      yield
+    ensure
+      restore_terminal_state
+    end
+  end
+  
+  # Simple, fast display_width function (like original 4.8.3)
+  def self.display_width(str)
+    return 0 if str.nil? || str.empty?
+    
+    width = 0
+    str.each_char do |char|
+      cp = char.ord
+      if cp == 0
+        # NUL – no width
+      elsif cp < 32 || (cp >= 0x7F && cp < 0xA0)
+        # Control characters: no width
+        width += 0
+      # Approximate common wide ranges:
+      elsif (cp >= 0x1100 && cp <= 0x115F) ||
+            cp == 0x2329 || cp == 0x232A ||
+            (cp >= 0x2E80 && cp <= 0xA4CF) ||
+            (cp >= 0xAC00 && cp <= 0xD7A3) ||
+            (cp >= 0xF900 && cp <= 0xFAFF) ||
+            (cp >= 0xFE10 && cp <= 0xFE19) ||
+            (cp >= 0xFE30 && cp <= 0xFE6F) ||
+            (cp >= 0xFF00 && cp <= 0xFF60) ||
+            (cp >= 0xFFE0 && cp <= 0xFFE6)
+        width += 2
+      else
+        width += 1
+      end
+    end
+    width
+  end
+  
+  # Comprehensive Unicode display width (available but not used in performance-critical paths)
+  def self.display_width_unicode(str)
+    return 0 if str.nil? || str.empty?
+    
+    # ... full Unicode implementation available when needed ...
+    # For now, just delegate to the simple version
+    display_width(str)
+  end
+end

data/lib/rcurses/input.rb

@@ -0,0 +1,127 @@
+module Rcurses
+  module Input
+    def getchr(t = nil, flush: true)
+      begin
+        # 1) Read a byte (with optional timeout)
+        begin
+          c = t ? Timeout.timeout(t) { $stdin.getch } : $stdin.getch
+        rescue Timeout::Error
+          return nil
+        end
+
+        # 2) If it's ESC, grab any quick trailing bytes
+        seq = c
+        if c == "\e"
+          if IO.select([$stdin], nil, nil, 0.05)
+            begin
+              seq << $stdin.read_nonblock(16)
+            rescue IO::WaitReadable, EOFError
+            end
+          end
+        end
+
+        # 3) Single ESC alone
+        return "ESC" if seq == "\e"
+
+        # 4) Shift‑TAB
+        return "S-TAB" if seq == "\e[Z"
+
+        # 5) Legacy single‑char shift‑arrows (your old working ones)
+        case seq
+        when "\e[a" then return "S-UP"
+        when "\e[b" then return "S-DOWN"
+        when "\e[c" then return "S-RIGHT"
+        when "\e[d" then return "S-LEFT"
+        end
+
+        # 6) CSI style shift‑arrows (e.g. ESC [1;2A )
+        if m = seq.match(/\A\e\[\d+;2([ABCD])\z/)
+          return { 'A' => "S-UP", 'B' => "S-DOWN", 'C' => "S-RIGHT", 'D' => "S-LEFT" }[m[1]]
+        end
+
+        # 7) Plain arrows
+        if m = seq.match(/\A\e\[([ABCD])\z/)
+          return { 'A' => "UP", 'B' => "DOWN", 'C' => "RIGHT", 'D' => "LEFT" }[m[1]]
+        end
+
+        # 8) CSI + '~' sequences (Ins, Del, Home, End, PgUp, PgDn, F5-F12)
+        if seq.start_with?("\e[") && seq.end_with?("~")
+          num = seq[/\d+(?=~)/].to_i
+          return case num
+                when 1, 7   then "HOME"
+                when 2       then "INS"
+                when 3       then "DEL"
+                when 4, 8    then "END"
+                when 5       then "PgUP"
+                when 6       then "PgDOWN"
+                when 15      then "F5"
+                when 17      then "F6"
+                when 18      then "F7"
+                when 19      then "F8"
+                when 20      then "F9"
+                when 21      then "F10"
+                when 23      then "F11"
+                when 24      then "F12"
+                else ""
+                end
+        end
+
+        # 9) SS3 function keys F1-F4
+        if seq.start_with?("\eO") && seq.length == 3
+          return case seq[2]
+                when 'P' then "F1"
+                when 'Q' then "F2"
+                when 'R' then "F3"
+                when 'S' then "F4"
+                else ""
+                end
+        end
+
+        # 10) Single / Ctrl-char mappings
+        return case seq
+              when "\r", "\n"     then "ENTER"
+              when "\t"           then "TAB"
+              when "\u007F", "\b" then "BACK"
+              when "\u0000"       then "C-SPACE"
+              when "\u0001"       then "C-A"
+              when "\u0002"       then "C-B"
+              when "\u0003"       then "C-C"
+              when "\u0004"       then "C-D"
+              when "\u0005"       then "C-E"
+              when "\u0006"       then "C-F"
+              when "\u0007"       then "C-G"
+              when "\u0008"       then "C-H"
+              when "\u000B"       then "C-K"
+              when "\u000C"       then "C-L"
+              when "\u000D"       then "C-M"
+              when "\u000E"       then "C-N"
+              when "\u000F"       then "C-O"
+              when "\u0010"       then "C-P"
+              when "\u0011"       then "C-Q"
+              when "\u0012"       then "C-R"
+              when "\u0013"       then "C-S"
+              when "\u0014"       then "C-T"
+              when "\u0015"       then "C-U"
+              when "\u0016"       then "C-V"
+              when "\u0018"       then "C-X"
+              when "\u0019"       then "C-Y"
+              when "\u001A"       then "C-Z"
+              when "\u0017"       then "WBACK"
+              when /\A[[:print:]]\z/ then seq
+              else ""
+              end
+      ensure
+        if flush
+          while IO.select([$stdin], nil, nil, 0)
+            begin
+              $stdin.read_nonblock(4096)
+            rescue IO::WaitReadable, EOFError
+              break
+            end
+          end
+        end
+      end
+    end
+  end
+end
+