rbcurse 0.1.0

data/lib/ver/keyboard.rb

@@ -0,0 +1,150 @@
+module VER
+  module Keyboard # avoid initialize
+    ESC         = 27 # keycode
+    @polling = false
+
+    module_function
+
+    def focus=(receiver)
+      @stack = []
+      @focus = receiver
+      poll unless @polling
+    end
+
+    def poll
+      @polling = true
+
+      while char = @focus.window.getch
+        break if @focus.stopping? # XXX
+        #break if VER.stopping?
+        $log.debug("char: #{char} stakc: #{@stack.inspect}") if char != Ncurses::ERR
+        if char == Ncurses::ERR # timeout or signal
+          @focus.press('esc') if @stack == [ESC]
+          @stack.clear
+        elsif ready = resolve(char)
+$log.debug("char: #{char} ready: #{ready}")
+          @stack.clear
+          @focus.press(ready)
+        end
+      end
+
+    ensure
+      @polling = false
+    end
+
+    def resolve(char)
+      @stack << char
+
+      if @stack.first == ESC
+        MOD_KEYS[@stack] || SPECIAL_KEYS[@stack]
+      else
+        NCURSES_KEYS[char] || CONTROL_KEYS[char] || PRINTABLE_KEYS[char]
+      end
+    end
+
+    # TODO: make this section sane
+
+    ASCII     = (0..255).map{|c| c.chr }
+    CONTROL   = ASCII.grep(/[[:cntrl:]]/)
+    PRINTABLE = ASCII.grep(/[[:print:]]/)
+
+    SPECIAL_KEYS = {
+      [27, 79, 50, 81]              => 'F14',
+      [27, 79, 50, 82]              => 'F15',
+      [27, 79, 70]                  => 'end',
+      [27, 79, 70]                  => 'end',
+      [27, 79, 72]                  => 'home',
+      [27, 79, 80]                  => 'F1',
+      [27, 79, 81]                  => 'F2',
+      [27, 79, 82]                  => 'F3',
+      [27, 79, 83]                  => 'F4',
+      [27, 91, 49, 126]             => 'end',
+      [27, 91, 49, 126]             => 'home',
+      [27, 91, 49, 49, 126]         => 'F1',
+      [27, 91, 49, 50, 126]         => 'F2',
+      [27, 91, 49, 51, 126]         => 'F3',
+      [27, 91, 49, 52, 126]         => 'F4',
+      [27, 91, 49, 52, 126]         => 'F4',
+      [27, 91, 49, 53, 126]         => 'F5',
+      [27, 91, 49, 55, 126]         => 'F6',
+      [27, 91, 49, 56, 59, 50, 126] => 'F19',
+      [27, 91, 49, 56, 59, 51, 126] => 'F7',
+      [27, 91, 49, 59, 51, 65]      => 'ppage',
+      [27, 91, 49, 59, 51, 66]      => 'npage',
+      [27, 91, 49, 59, 53, 65]      => 'ppage',
+      [27, 91, 49, 59, 53, 66]      => 'npage',
+      [27, 91, 49, 59, 53, 70]      => 'M-<',
+      [27, 91, 49, 59, 53, 72]      => 'M->',
+      [27, 91, 50, 54, 126]         => 'F14',
+      [27, 91, 50, 56, 126]         => 'F15',
+      [27, 91, 51, 59, 51, 126]     => 'del',
+      [27, 91, 52, 126]             => 'end',
+      [27, 91, 55, 126]             => 'home',
+      [27, 91, 55, 126]             => 'home',
+      [27, 91, 56, 126]             => 'end',
+      [27, 91, 56, 126]             => 'end',
+      [27, 91, 65]                  => 'up',
+      [27, 91, 66]                  => 'down',
+      [27, 91, 67]                  => 'right',
+      [27, 91, 68]                  => 'left',
+      [27, 91, 70]                  => 'end',
+      [27, 91, 72]                  => 'end',
+      [27, 91, 72]                  => 'home',
+      [27, 91, 91, 65]              => 'F1',
+      [27, 91, 91, 66]              => 'F2',
+      [27, 91, 91, 67]              => 'F3',
+      [27, 91, 91, 68]              => 'F4',
+      [27, 91, 91, 69]              => 'F5',
+    }
+
+    CONTROL_KEYS = {
+      0   => 'C-space',
+      1   => 'C-a',
+      2   => 'C-b',
+      3   => 'C-c',
+      4   => 'C-d',
+      5   => 'C-e',
+      6   => 'C-f',
+      7   => 'C-g',
+      8   => 'C-h',
+      9   => 'tab',
+      10  => 'return', # C-j
+      11  => 'C-k',
+      12  => 'C-l',
+      13  => 'return', # C-m
+      14  => 'C-n',
+      15  => 'C-o',
+      16  => 'C-p',
+      17  => 'C-q',
+      18  => 'C-r',
+      19  => 'C-s',
+      20  => 'C-t',
+      21  => 'C-u',
+      22  => 'C-v',
+      23  => 'C-w',
+      24  => 'C-x',
+      25  => 'C-y',
+      26  => 'C-z', # FIXME: is usually suspend in shell job control
+      # 27  => 'esc',
+      32  => 'space',
+      127 => 'backspace',
+    }
+
+    PRINTABLE_KEYS = {}
+    MOD_KEYS = {}
+
+    PRINTABLE.each do |key|
+      code = key.unpack('c')[0] # using unpack to be compatible with 1.9
+      PRINTABLE_KEYS[code] = key
+      MOD_KEYS[[ESC, code]] = "M-#{key}" unless key == '[' # don't map esc
+    end
+
+    NCURSES_KEYS = {}
+    Ncurses.constants.grep(/^KEY_/).each do |const|
+      value = Ncurses.const_get(const)
+      key = const[/^KEY_(.*)/, 1]
+      key = key =~ /^F/ ? key : key.downcase # function keys
+      NCURSES_KEYS[value] = key
+    end
+  end
+end

data/lib/ver/keyboard2.rb

@@ -0,0 +1,170 @@
+# Usage: 
+#     VER::Keyboard2.focus = self 
+#     or whatever class you have created.
+#  DEPENDENCIES:
+#  press(key)  - a method that takes an int key and processes it
+#  stopping?   returns true of false. if false, this prgram returns control
+#  window    - gives window of caller, responding to getch
+#  2008-11-24 12:41 
+#  this differs from original in that i try to return an int so it can just replace
+#  existing loops without any modification
+#  I thus return an int not a string
+module VER
+  module Keyboard2 # avoid initialize
+    ESC         = 27 # keycode
+    @polling = false
+
+    module_function
+
+    def focus=(receiver)
+      @stack = []
+      @focus = receiver
+      poll unless @polling
+    end
+
+    def poll
+      @polling = true
+
+      while char = @focus.window.getch
+        break if @focus.stopping? # XXX
+        #break if VER.stopping?
+        $log.debug("char: #{char} stakc: #{@stack.inspect}") if char != Ncurses::ERR
+        if char == Ncurses::ERR # timeout or signal
+          #@focus.press('esc') if @stack == [ESC]
+          @focus.press(ESC) if @stack == [ESC]
+          @stack.clear
+        elsif ready = resolve(char)
+$log.debug("char: #{char} ready: #{ready}")
+          @stack.clear
+          @focus.press(ready)
+        end
+      end
+
+    ensure
+      @polling = false
+    end
+
+    def resolve(char)
+      $log.debug("char: #{char} resolve") if char == ESC
+      @stack << char
+
+      if @stack.first == ESC
+        MOD_KEYS[@stack] || SPECIAL_KEYS[@stack]
+      elsif (char >= 0 and char < 27) or char == 32 or char == 127
+        char
+      else
+        #NCURSES_KEYS[char] || CONTROL_KEYS[char] || PRINTABLE_KEYS[char]
+        NCURSES_KEYS[char] || PRINTABLE_KEYS[char]
+      end
+    end
+
+    # TODO: make this section sane
+
+    ASCII     = (0..255).map{|c| c.chr }
+    CONTROL   = ASCII.grep(/[[:cntrl:]]/)
+    PRINTABLE = ASCII.grep(/[[:print:]]/)
+
+    SPECIAL_KEYS = {
+      [27, 79, 50, 81]              => 'F14',
+      [27, 79, 50, 82]              => 'F15',
+      [27, 79, 70]                  => 'end',
+      [27, 79, 70]                  => 'end',
+      [27, 79, 72]                  => 'home',
+#      [27, 79, 80]                  => 'F1',
+      [27, 79, 80]                  => Ncurses::KEY_F1,
+      [27, 79, 81]                  => 'F2',
+      [27, 79, 82]                  => 'F3',
+      [27, 79, 83]                  => 'F4',
+      [27, 91, 49, 126]             => 'end',
+      [27, 91, 49, 126]             => 'home',
+      [27, 91, 49, 49, 126]         => Ncurses::KEY_F1,
+      [27, 91, 49, 50, 126]         => 'F2',
+      [27, 91, 49, 51, 126]         => 'F3',
+      [27, 91, 49, 52, 126]         => 'F4',
+      [27, 91, 49, 52, 126]         => 'F4',
+      [27, 91, 49, 53, 126]         => 'F5',
+      [27, 91, 49, 55, 126]         => 'F6',
+      [27, 91, 49, 56, 59, 50, 126] => 'F19',
+      [27, 91, 49, 56, 59, 51, 126] => 'F7',
+      [27, 91, 49, 59, 51, 65]      => 'ppage',
+      [27, 91, 49, 59, 51, 66]      => 'npage',
+      [27, 91, 49, 59, 53, 65]      => 'ppage',
+      [27, 91, 49, 59, 53, 66]      => 'npage',
+      [27, 91, 49, 59, 53, 70]      => 'M-<',
+      [27, 91, 49, 59, 53, 72]      => 'M->',
+      [27, 91, 50, 54, 126]         => 'F14',
+      [27, 91, 50, 56, 126]         => 'F15',
+      [27, 91, 51, 59, 51, 126]     => 'del',
+      [27, 91, 52, 126]             => 'end',
+      [27, 91, 55, 126]             => 'home',
+      [27, 91, 55, 126]             => 'home',
+      [27, 91, 56, 126]             => 'end',
+      [27, 91, 56, 126]             => 'end',
+      [27, 91, 65]                  => 'up',
+      [27, 91, 66]                  => 'down',
+      [27, 91, 67]                  => 'right',
+      [27, 91, 68]                  => 'left',
+      [27, 91, 70]                  => 'end',
+      [27, 91, 72]                  => 'end',
+      [27, 91, 72]                  => 'home',
+      [27, 91, 91, 65]              => Ncurses::KEY_F1,
+      [27, 91, 91, 66]              => 'F2',
+      [27, 91, 91, 67]              => 'F3',
+      [27, 91, 91, 68]              => 'F4',
+      [27, 91, 91, 69]              => 'F5',
+    }
+
+    CONTROL_KEYS = {
+      0   => 'C-space',
+      1   => 'C-a',
+      2   => 'C-b',
+      3   => 'C-c',
+      4   => 'C-d',
+      5   => 'C-e',
+      6   => 'C-f',
+      7   => 'C-g',
+      8   => 'C-h',
+      9   => 'tab',
+      10  => 'return', # C-j
+      11  => 'C-k',
+      12  => 'C-l',
+      13  => 'return', # C-m
+      14  => 'C-n',
+      15  => 'C-o',
+      16  => 'C-p',
+      17  => 'C-q',
+      18  => 'C-r',
+      19  => 'C-s',
+      20  => 'C-t',
+      21  => 'C-u',
+      22  => 'C-v',
+      23  => 'C-w',
+      24  => 'C-x',
+      25  => 'C-y',
+      26  => 'C-z', # FIXME: is usually suspend in shell job control
+      # 27  => 'esc',
+      32  => 'space',
+      127 => 'backspace',
+    }
+
+    PRINTABLE_KEYS = {}
+    MOD_KEYS = {}
+
+    PRINTABLE.each do |key|
+      code = key.unpack('c')[0] # using unpack to be compatible with 1.9
+    #  PRINTABLE_KEYS[code] = key
+    #  MOD_KEYS[[ESC, code]] = "M-#{key}" unless key == '[' # don't map esc
+      PRINTABLE_KEYS[code] = code
+      MOD_KEYS[[ESC, code]] = 128 + code unless key == '[' # don't map esc
+    end
+
+    NCURSES_KEYS = {}
+    Ncurses.constants.grep(/^KEY_/).each do |const|
+      value = Ncurses.const_get(const)
+      key = const[/^KEY_(.*)/, 1]
+      key = key =~ /^F/ ? key : key.downcase # function keys
+      #NCURSES_KEYS[value] = key
+      NCURSES_KEYS[value] = value
+    end
+  end
+end

data/lib/ver/ncurses.rb

@@ -0,0 +1,102 @@
+require 'rbcurse/colormap'
+module VER
+include ColorMap
+  module_function
+
+  # Setup ncurses, nicely documented by the curses manpages
+  def start_ncurses
+    # The initscr code determines the terminal type and initializes all curses
+    # data structures.
+    # initscr also causes the first call to refresh to clear the screen.
+    # If errors occur, initscr writes an appropriate error message to standard
+    # error and exits; otherwise, a pointer is returned to stdscr.
+    stdscr = Ncurses.initscr
+
+#    Color.start if Ncurses.has_colors?
+      Ncurses.start_color();
+      ColorMap.setup # added by RK 2008-11-30 00:48 
+    # The keypad option enables the keypad of the user's terminal.
+    # If enabled (bf is TRUE), the user can press a function key (such as an
+    # arrow key) and wgetch returns a single value representing the function
+    # key, as in KEY_LEFT.
+    # If disabled (bf is FALSE), curses does not treat function keys specially
+    # and the program has to interpret the escape sequences itself.
+    # If the keypad in the terminal can be turned on (made to transmit) and off
+    # (made to work locally), turning on this option causes the terminal keypad
+    # to be turned on when wgetch is called.
+    # The default value for keypad is false.
+    Ncurses.keypad(stdscr, bf = true)
+
+    # The nl and nonl routines control whether the underlying display device
+    # translates the return key into newline on input, and whether it
+    # translates newline into return and line-feed on output (in either case,
+    # the call addch('\n') does the equivalent of return and line feed on the
+    # virtual screen).
+    # Initially, these translations do occur.
+    # If you disable them using nonl, curses will be able to make better use of
+    # the line-feed capability, resulting in faster cursor motion.
+    # Also, curses will then be able to detect the return key.
+    Ncurses.nonl
+
+    # The raw and noraw routines place the terminal into or out of raw mode.
+    # Raw mode is similar to cbreak mode, in that characters typed are
+    # immediately passed through to the user program.
+    # The differences are that in raw mode, the interrupt, quit, suspend, and
+    # flow control characters are all passed through uninterpreted, instead of
+    # generating a signal.
+    # The behavior of the BREAK key depends on other bits in the tty driver
+    # that are not set by curses.
+    Ncurses.raw
+
+    # Normally, the tty driver buffers typed characters until a newline or
+    # carriage return is typed.
+    # The cbreak routine disables line buffering and
+    # erase/kill character-processing (interrupt and flow control characters
+    # are unaffected), making characters typed by the user immediately
+    # available to the program.
+    Ncurses.cbreak
+
+    # The echo and noecho routines control whether characters typed by the user
+    # are echoed by getch as they are typed.
+    # Echoing by the tty driver is always disabled, but initially getch is in
+    # echo mode, so characters typed are echoed.
+    Ncurses.noecho
+
+    # The curs_set routine sets the cursor state is set to invisible, normal,
+    # or very visible for visibility equal to 0, 1, or 2 respectively.
+    # If the terminal supports the visibility requested, the previous cursor
+    # state is returned; otherwise, ERR is returned.
+    Ncurses.curs_set(1)
+
+    # The halfdelay routine is used for half-delay mode, which is similar to
+    # cbreak mode in that characters typed by the user are immediately
+    # available to the  program.
+    # However, after blocking for tenths tenths of seconds, ERR is returned if
+    # nothing has been typed.
+    # The value of tenths must be a number between 1 and 255.
+    # Use nocbreak to leave half-delay mode.
+    Ncurses::halfdelay(tenths = 10)
+
+    # The nodelay option causes getch to be a non-blocking call. If no input is
+    # ready, getch returns ERR. If disabled (bf is FALSE), getch waits until a
+    # key is pressed.
+    # Ncurses::nodelay(Ncurses::stdscr, bf = true)
+  end
+
+  def stop_ncurses
+    Ncurses.echo
+    Ncurses.nocbreak
+    Ncurses.nl
+    Ncurses.endwin
+  ensure
+    return unless error = @last_error
+    log = Config[:logfile].value
+
+    Kernel.warn "There may have been fatal errors logged to: #{log}."
+    Kernel.warn "The most recent was:"
+
+    $stderr.puts ''
+    $stderr.puts @last_error_message if @last_error_message
+    $stderr.puts @last_error, *@last_error.backtrace
+  end
+end