rbcurse-core 0.0.0

data/lib/rbcurse/core/system/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/rbcurse/core/system/keydefs.rb

@@ -0,0 +1,30 @@
+# ----------------------------------------------------------------------------- #
+#         File: keydefs.rb
+#  Description: Some common keys used in app. Earlier part of rwidget.rb
+#       Author: rkumar http://github.com/rkumar/rbcurse/
+#         Date: 08.11.11 - 14:57
+#      License: Same as Ruby's License (http://www.ruby-lang.org/LICENSE.txt)
+#  Last update: 08.11.11 - 14:57
+# ----------------------------------------------------------------------------- #
+#
+
+# some common definition that we use throughout app. Do not add more, only what is common.
+# I should not have added Sh-F9 and C-left since they are rare, but only to show they exist.
+#
+KEY_TAB    = 9
+KEY_F1  = FFI::NCurses::KEY_F1
+KEY_F10  = FFI::NCurses::KEY_F10
+KEY_ENTER  = 13 # FFI::NCurses::KEY_ENTER gives 343
+KEY_RETURN = 10  # FFI gives 10 too
+KEY_BTAB  = 353 # nc gives same
+KEY_DELETE = 330
+KEY_BACKSPACE = KEY_BSPACE = 127 # Nc gives 263 for BACKSPACE
+KEY_CC     = 3   # C-c
+KEY_LEFT  = FFI::NCurses::KEY_LEFT
+KEY_RIGHT  = FFI::NCurses::KEY_RIGHT
+KEY_UP  = FFI::NCurses::KEY_UP
+KEY_DOWN  = FFI::NCurses::KEY_DOWN
+C_LEFT = 18168
+C_RIGHT = 18167
+S_F9 = 17949126
+META_KEY = 128

data/lib/rbcurse/core/system/ncurses.rb

@@ -0,0 +1,218 @@
+require 'ffi-ncurses'
+#include FFI::NCurses # this pollutes many objects and invalidates method_missing
+module VER
+  module_function
+
+  # Setup ncurses, nicely documented by the curses manpages
+  def start_ncurses
+    return if $ncurses_started
+    $ncurses_started = true
+    # 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  ## FFI
+
+#    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.pointer, bf = true) # FFIWINDOW
+    #Ncurses.keypad(stdscr, bf = true)
+      #Ncurses.stdscr.keypad(true)     # turn on keypad mode FFI
+    #Ncurses.keypad(stdscr, bf = 1)
+
+    # 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
+
+  # this should happen only in outermost program that started ncurses
+  # if a called program does this, the calling program can have a display freeze
+  def stop_ncurses
+    Ncurses.echo
+    Ncurses.nocbreak
+    Ncurses.nl
+    Ncurses.endwin
+    $ncurses_started = false
+    #puts "curses over"
+  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
+require 'rbcurse/core/system/colormap'
+include ColorMap
+end
+module Ncurses
+  extend self
+  FALSE = 0
+  TRUE = 1
+  module NCX
+    def COLS
+      FFI::NCurses.getmaxx(FFI::NCurses.stdscr)
+    end
+    def LINES
+#      #FFI::NCurses.getmaxy(FFI::NCurses.stdscr)
+      FFI::NCurses.LINES
+    end
+#    # supposed to be picked up at runtime
+    def COLORS
+      FFI::NCurses.COLORS
+    end
+
+    # jsut trying this so i can do Ncurses.stdscr.getmax
+    def _stdscr
+      FFI::NCurses.stdscr
+    end
+    # this allows me to refer to them as Ncurses::A_REVERSE as is the case everywhere
+    A_REVERSE = FFI::NCurses::A_REVERSE
+    A_STANDOUT = FFI::NCurses::A_STANDOUT
+    A_BOLD = FFI::NCurses::A_BOLD
+    A_UNDERLINE = FFI::NCurses::A_UNDERLINE
+    A_BLINK = FFI::NCurses::A_BLINK
+    A_NORMAL = FFI::NCurses::A_NORMAL
+    KEY_F1 = FFI::NCurses::KEY_F1
+  end
+  include NCX
+  extend NCX
+  # i think we can knock this off
+  def method_missing meth, *args
+    if (FFI::NCurses.respond_to?(meth))
+      FFI::NCurses.send meth, *args
+    end
+  end
+  # FFINC.constants.each { |e| Ncurses.const_set(e, FFINC.const_get(e) )  }
+  def const_missing name
+    val = FFI::NCurses.const_get(name)
+    const_set(name, val)
+    return val
+  end
+
+  # This is a window pointer wrapper, to be used for stdscr and others.
+  # Ideally ffi-ncurses should do this, if it returns a pointer, I'll do this.
+  class FFIWINDOW
+    attr_accessor :pointer
+    def initialize(*args, &block)
+      if block_given?
+        @pointer = args.first
+      else
+        @pointer = FFI::NCurses.newwin(*args)
+      end
+    end
+    def method_missing(name, *args)
+      name = name.to_s
+      if (name[0,2] == "mv")
+        test_name = name.dup
+        test_name[2,0] = "w" # insert "w" after"mv"
+        if (FFI::NCurses.respond_to?(test_name))
+          return FFI::NCurses.send(test_name, @pointer, *args)
+        end
+      end
+      test_name = "w" + name
+      if (FFI::NCurses.respond_to?(test_name))
+        return FFI::NCurses.send(test_name, @pointer, *args)
+      end
+      FFI::NCurses.send(name, @pointer, *args)
+    end
+    def respond_to?(name)
+      name = name.to_s
+      if (name[0,2] == "mv" && FFI::NCurses.respond_to?("mvw" + name[2..-1]))
+        return true
+      end
+      FFI::NCurses.respond_to?("w" + name) || FFI::NCurses.respond_to?(name)
+    end
+    def del
+      FFI::NCurses.delwin(@pointer)
+    end
+    alias delete del
+  end
+  # if ffi-ncurses returns a pointer wrap it.
+  # or we can check for whether it responds_to? refresh and getch
+  def self.initscr
+    #@stdscr = Ncurses::FFIWINDOW.new(FFI::NCurses.initscr) { }
+    stdscr = FFI::NCurses.initscr
+    if stdscr.is_a? FFI::Pointer
+      @stdscr = Ncurses::FFIWINDOW.new(stdscr) { }
+    else
+      @stdscr = stdscr
+    end
+  end
+  def self.stdscr
+    @stdscr
+  end
+  #  commented off on 2011-09-15 FFIWINDOW results in errors
+#  class << self
+#    def method_missing(method, *args, &block)
+#      FFI::NCurses.send(method, *args, &block)
+#    end
+#  end
+#  ---
+end

data/lib/rbcurse/core/system/panel.rb

@@ -0,0 +1,162 @@
+require "ffi-ncurses"
+  module Ncurses # changed on 2011-09-8 
+    # making minimal changes as per ffi-ncurses 0.4.0 which implements panels
+    #module VER # too many places call Ncurses::Panel
+    class Panel #< Struct.new(:pointer)
+#      extend FFI::Library
+#
+#      # use RUBY_FFI_NCURSES_LIB to specify exactly which lib you want, e.g.
+#      # ncursesw, XCurses (from PDCurses)
+#      if ENV["RUBY_FFI_PANEL_LIB"].to_s != ""
+#        LIB_HANDLE = ffi_lib( ENV["RUBY_FFI_PANEL_LIB"] ).first
+#      else
+#        # next works but not when ENV, maybe since 'panel' not in code above 
+#        LIB_HANDLE = ffi_lib( 'panel', '/opt/local/lib/libpanelw.5.dylib' ).first
+#        #LIB_HANDLE = ffi_lib( 'panel', 'libpanel' ).first # this also works
+#      end
+#
+#      functions = [
+#        [:new_panel,         [:pointer],             :pointer],
+#        [:bottom_panel,      [:pointer],             :int],
+#        [:top_panel,         [:pointer],             :int],
+#        [:show_panel,        [:pointer],             :int],
+#        [:update_panels,     [],                     :void],
+#        [:hide_panel,        [:pointer],             :int],
+#        [:panel_window,      [:pointer],             :pointer],
+#        [:replace_panel,     [:pointer, :pointer],   :int],
+#        [:move_panel,        [:pointer, :int, :int], :int],
+#        [:panel_hidden,      [:pointer],             :int],
+#        [:panel_above,       [:pointer],             :pointer],
+#        [:panel_below,       [:pointer],             :pointer],
+#        [:set_panel_userptr, [:pointer, :pointer],   :int],
+#        [:panel_userptr,     [:pointer],             :pointer],
+#        [:del_panel,         [:pointer],             :int],
+#      ]
+#
+#      functions.each do |function|
+#        attach_function(*function)
+#      end
+
+      def initialize(window)
+        if window.respond_to?(:pointer)
+          @pointer = FFI::NCurses.new_panel(window.pointer)
+        else
+          @pointer = FFI::NCurses.new_panel(window)
+        end
+      end
+      def pointer
+        @pointer
+      end
+
+      # Puts panel below all other panels.
+      def bottom_panel
+        FFI::NCurses.bottom_panel(@pointer)
+      end
+      alias bottom bottom_panel
+
+      # Put the visible panel on top of all other panels in the stack.
+      #
+      # To ensure compatibility across platforms, use this method instead of
+      # {show_panel} when the panel is shown.
+      def top_panel
+        FFI::NCurses.top_panel(@pointer)
+      end
+      alias top top_panel
+
+      # Makes hidden panel visible by placing it on the top of the stack.
+      #
+      # To ensure compatibility across platforms, use this method instead of
+      # {top_panel} when the panel is hidden.
+      def show_panel
+        FFI::NCurses.show_panel(@pointer)
+      end
+      alias show show_panel
+
+      # Removes the given panel from the panel stack and thus hides it from
+      # view.
+      # The PANEL structure is not lost, merely removed from the stack.
+      def hide_panel
+        FFI::NCurses.hide_panel(@pointer)
+      end
+      alias hide hide_panel
+
+      # Returns a pointer to the window of the given panel.
+      def panel_window
+        FFI::NCurses.panel_window(@pointer)
+      end
+      alias window panel_window
+
+      # Replace the window of the panel with the given window.
+      # Useful, for example, if you want to resize a panel.
+      # You can call {replace_panel} on the output of {wresize}.
+      # It does not change the position of the panel in the stack.
+      def replace_panel(window)
+        FFI::NCurses.replace_panel(@pointer, window)
+      end
+      alias replace replace_panel
+
+      # Move the panel window so that its upper-left corner is at
+      # (+starty+,+startx+).
+      # It does not change the position of the panel in the stack.
+      # Be sure to use this method instead of {mvwin}, to move a panel window.
+      def move_panel(starty = 0, startx = 0)
+        FFI::NCurses.move_panel(@pointer, starty, startx)
+      end
+      alias move move_panel
+
+      # Returns true if the panel is in the panel stack, false if not.
+      # Returns ERR if the panel pointer is a null pointer.
+      def panel_hidden
+        FFI::NCurses.panel_hidden(@pointer) == 0
+      end
+      alias hidden? panel_hidden
+
+      # Returns pointer to the panel above.
+      def panel_above
+        FFI::NCurses.panel_above(@pointer)
+      end
+      alias above panel_above
+
+      # Return a pointer to the panel just below panel.
+      # If the panel argument is a pointer to 0, it returns a pointer to the
+      # top panel in the stack.
+      def panel_below
+        FFI::NCurses.panel_below(@pointer)
+      end
+      alias below panel_below
+
+      # Returns the user pointer for a given panel.
+      def panel_userptr
+        FFI::NCurses.panel_userptr(@pointer)
+      end
+      alias userptr panel_userptr
+
+      # sets the panel's user pointer.
+      def set_panel_userptr(user_pointer)
+        FFI::NCurses.set_panel_userptr(@pointer, user_pointer)
+      end
+      alias userptr= set_panel_userptr
+
+      # Remove the panel from the stack and deallocate the PANEL structure.
+      # Doesn't remove the associated window.
+      def del_panel
+        FFI::NCurses.del_panel(@pointer)
+      end
+      alias del del_panel
+      alias delete del_panel
+
+      class << self
+        # these will be used when you say Ncurses::Panel.del_panel(@panel.pointer)
+        # You could directly say FFI:NCurses or even @panel.del_panel.
+      def update_panels
+        FFI::NCurses.update_panels
+      end
+      def method_missing(name, *args)
+        if (FFI::NCurses.respond_to?(name))
+          return FFI::NCurses.send(name, *args)
+        end
+        raise "Panel did not respond_to #{name} "
+      end
+      end
+    end
+  end