rbcurse 1.4.1 → 1.5.0.pre1

data/lib/ver/keyboard2.rb

@@ -1,170 +0,0 @@
-# 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

@@ -1,218 +0,0 @@
-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/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/ver/panel.rb

@@ -1,162 +0,0 @@
-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