rcurses 4.9.4 → 4.9.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 26aa4084a7e60a2da827d96974c2eefa1f5f49c592858148e479857346b92f13
-  data.tar.gz: 56c0a760d5d082b5927eca4d4d7c3952525d82ed3689f4f0f6ffb253235d8e87
+  metadata.gz: 3640945686095502c9c1cd2d3c38223a6af7dfc5c30ac9a7e6c2bcd311c156f2
+  data.tar.gz: fee33bc2c07cec00788c402c66707a1cdc0ccd4a3a7d7099a8cb8857bba2091b
 SHA512:
-  metadata.gz: a3f1885d497548d271e8c1c85b73eb161edf1f5a73e627175a108180fd9a745dc4eba93af13ec0ad0ad84957ab02b3419fd1233bc5c2ad582a66ad6c2b411227
-  data.tar.gz: fd6e8f2c3efc3f0169cb41d5901fe002d3350b8c0fd083378555d08be4caa2472312bc2bf23adf5b4e157a6ce54858aaf4c9aae1265d60ef658c2a9002f5d165
+  metadata.gz: 330e0732e4996d66e2f1843dfe88fdbd9fc905375cec018ecccd31582f9915a21e2a461528ec1f7c9e7f54d3582a2ff2d29d7aaf20dc6a1f6d61754e688f229f
+  data.tar.gz: 6c77f6074af662c578d4df20fccc4a03d1512252a0d71fea3e2e0d2af6ee7327a03fc2fdec90858d49f4c89fd864948e45504310f75c921ce5f68c2c93d251fc

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,6 @@
+module Rcurses
+  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
+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
+