rbcurse 1.5.0 → 1.5.2

data/lib/rbcurse/deprecated/widgets/stdscrwindow.rb

@@ -0,0 +1,309 @@
+require 'rbcurse/core/system/ncurses'
+module RubyCurses
+  #
+  # an attempt to make a window based on stdscr for bottom line printing so the entire 
+  # application can have one pointer, regardless of whether through App
+  # or otherwise. This still provides the full getchar operation, copied from
+  # Window class which is the main purpose of this. So as to provide ask, agree and say.
+  #
+  # We should be able to pass this window to bottomline and have one global bottomline
+  # created once (by window class ?)
+  #
+  # FFI: 2011-09-9 The change to FFI has affected this a lot since I do not get window
+  # methods in rbcurse for stdscr whereas suprisingly if i run the samples, i get them
+  # all.
+  #
+  #   NOTE:
+  #   WARNING: Pls do not use this class. This was just experimentation. Using stdscr
+  #   mucks up the display and overwrites objects on the screen. I will remove this class
+  #   at some time.
+  #
+  class StdscrWindow 
+    attr_reader :width, :height, :top, :left
+
+    def initialize
+
+      #@window_pointer = FFI::NCurses.initscr
+      @window_pointer = Ncurses.initscr # FFIWINDOW
+      $log.debug "STDSCR window pointer is #{@window_pointer.class}"
+      #$log.debug "STDSCR window pointer mehtods #{@window_pointer.public_methods}"
+      $error_message_row ||= Ncurses.LINES-1
+      $error_message_col ||= 1
+      init_vars
+
+
+    end
+    def init_vars
+      #Ncurses::keypad(@window_pointer, true)
+      Ncurses.keypad(@window_pointer.pointer, true)
+      @stack = []
+    end
+    ##
+
+    # Ncurses
+
+
+    # taken from Window
+    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 (@window_pointer.respond_to?(test_name)) # FFIPOINTER
+          return @window_pointer.send(test_name,*args)
+        end
+
+        if (FFI::NCurses.respond_to?(test_name))
+          return FFI::NCurses.send(test_name, @window_pointer, *args)
+        end
+      end
+      test_name = "w" + name
+      # FFI responds but the pointer does not !!! bottomline 1045
+      if (@window_pointer.respond_to?(test_name)) # FFIPOINTER
+        return @window_pointer.send(test_name,*args)
+      end
+      if (FFI::NCurses.respond_to?(test_name))
+        return FFI::NCurses.send(test_name, @window_pointer, *args)
+      end
+      # what if it does not respond, can go into loop and give stack overflow
+      FFI::NCurses.send(name, @window_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
+      #@window.send(meth, *args)
+
+    # FFI WARNING XXX I think these methods one window_pointer will fail
+    # since somehow stdscr is not getting these methods here.
+    def print(string, width = width)
+      return unless visible?
+      @window_pointer.waddnstr(string.to_s, width)
+    end
+
+    def print_yx(string, y = 0, x = 0)
+      @window_pointer.mvwaddnstr(y, x, string, width)
+    end
+
+    def print_empty_line
+      return unless visible?
+      @window_pointer.printw(' ' * width)
+    end
+
+    def print_line(string)
+      print(string.ljust(width))
+    end
+
+    def puts(*strings)
+      print(strings.join("\n") << "\n")
+    end
+
+    # FFI 2011-09-9 commented off so it goes to method missing
+    def XXXrefresh
+      @window_pointer.refresh
+    end
+
+
+    def color=(color)
+      @color = color
+      @window_pointer.color_set(color, nil)
+    end
+
+    def highlight_line(color, y, x, max)
+      @window_pointer.mvchgat(y, x, max, FFI::NCurses::A_NORMAL, color, nil)
+    end
+
+    def ungetch(ch)
+      FFI::NCurses.ungetch(ch)
+    end
+
+    # this used to work fine in ncursesruby
+    # but somehow in ffi, stdscr does not have most methods, i am unable to figure
+    # this out. C-c will crash this.
+    def getch
+      c = @window_pointer.getch # FFI NW stdscr must get key not some window
+      #raise "Ncurses.stdscr does not have getch" if !Ncurses.stdscr.respond_to? :getch
+      #$log.debug " XXXX before calling getch"
+      #c = Ncurses.stdscr.getch # FFIW if you use the FFIWINDOW
+      #c = FFI::NCurses.getch # FFI 2011-09-9  # without FFIWINDOW
+      #$log.debug " XXXX after calling getch #{c}"
+      #if c == FFI::NCurses::KEY_RESIZE
+      return c
+    rescue Interrupt => ex
+      3 # is C-c
+    end
+
+    # returns control, alt, alt+ctrl, alt+control+shift, F1 .. etc
+    # ALT combinations also send a 27 before the actual key
+    # Please test with above combinations before using on your terminal
+    # added by rkumar 2008-12-12 23:07 
+    def getchar 
+      FFI::NCurses.raw # FFI required so that getch does not crash on C-c
+      while 1 
+        ch = getch 
+        #$log.debug "window getchar() GOT: #{ch}" if ch != -1
+        if ch == -1
+          # the returns escape 27 if no key followed it, so its SLOW if you want only esc
+          if @stack.first == 27
+            #$log.debug " -1 stack sizze #{@stack.size}: #{@stack.inspect}, ch #{ch}"
+            case @stack.size
+            when 1
+              @stack.clear
+              return 27
+            when 2 # basically a ALT-O, this will be really slow since it waits for -1
+              ch = 128 + @stack.last
+              @stack.clear
+              return ch
+            when 3
+              $log.debug " SHOULD NOT COME HERE getchar()"
+            end
+          end
+          @stack.clear
+          next
+        end
+        # this is the ALT combination
+        if @stack.first == 27
+          # experimental. 2 escapes in quick succession to make exit faster
+          if ch == 27
+            @stack.clear
+            return ch
+          end
+          # possible F1..F3 on xterm-color
+          if ch == 79 or ch == 91
+            #$log.debug " got 27, #{ch}, waiting for one more"
+            @stack << ch
+            next
+          end
+          #$log.debug "stack SIZE  #{@stack.size}, #{@stack.inspect}, ch: #{ch}"
+          if @stack == [27,79]
+            # xterm-color
+            case ch
+            when 80
+              ch = KEY_F1
+            when 81
+              ch = KEY_F2
+            when 82
+              ch = KEY_F3
+            when 83
+              ch = KEY_F4
+            end
+            @stack.clear
+            return ch
+          elsif @stack == [27, 91]
+            if ch == 90
+              @stack.clear
+              return KEY_BTAB # backtab
+            end
+          end
+          # the usual Meta combos. (alt)
+          ch = 128 + ch
+          @stack.clear
+          return ch
+        end
+        # append a 27 to stack, actually one can use a flag too
+        if ch == 27
+          @stack << 27
+          next
+        end
+        return ch
+      end
+    end
+
+    def clear
+      # return unless visible?
+      move 0, 0
+      puts *Array.new(height){ ' ' * (width - 1) }
+    end
+
+
+    def visible?
+      @visible
+    end
+    ## 
+    # added by rk 2008-11-29 19:01 
+    # I usually use this, not the others ones here
+    # @param  r - row
+    # @param  c - col
+    # @param string - text to print
+    # @param color - color pair
+    # @ param att - ncurses attribute: normal, bold, reverse, blink,
+    # underline
+    def printstring(r,c,string, color, att = FFI::NCurses::A_NORMAL)
+        prv_printstring(r,c,string, color, att )
+    end
+
+    ## name changed from printstring to prv_prinstring
+    def prv_printstring(r,c,string, color, att = FFI::NCurses::A_NORMAL)
+
+      #$log.debug " #{@name} inside window printstring r #{r} c #{c} #{string} "
+      att = FFI::NCurses::A_NORMAL if att.nil? 
+      case att.to_s.downcase
+      when 'normal'
+        att = FFI::NCurses::A_NORMAL
+      when 'underline'
+        att = FFI::NCurses::A_UNDERLINE
+      when 'bold'
+        att = FFI::NCurses::A_BOLD
+      when 'blink'
+        att = FFI::NCurses::A_BLINK    # unlikely to work
+      when 'reverse'
+        att = FFI::NCurses::A_REVERSE    
+      end
+
+      attron(Ncurses.COLOR_PAIR(color) | att)
+      # we should not print beyond window coordinates
+      # trying out on 2009-01-03 19:29 
+      width = Ncurses.COLS
+      # the next line won't ensure we don't write outside some bounds like table
+      #string = string[0..(width-c)] if c + string.length > width
+      #$log.debug "PRINT len:#{string.length}, #{Ncurses.COLS}, #{r}, #{c} w: #{@window} "
+      mvprintw(r, c, "%s", string);
+      attroff(Ncurses.COLOR_PAIR(color) | att)
+    end
+    # added by rk 2008-11-29 19:01 
+    # Since these methods write directly to window they are not advised
+    # since clearing previous message we don't know how much to clear.
+    # Best to map error_message to a label.
+    #  2010-09-13 00:22 WE should not use these any longer.
+    #  Application should create a label and map a Variable named
+    #  $errormessage to it. We should only update the Variable
+    # CLEANUP DEPRECATED
+    def print_error_message text=$error_message
+      raise "DEPRECATED CLEANUP use global method of same name"
+      r = $error_message_row || Ncurses.LINES-1
+      c = $error_message_col || (Ncurses.COLS-text.length)/2 
+
+      $log.debug "got ERROR MESSAGE #{text} row #{r} "
+      clear_error r, $datacolor
+      printstring r, c, text, color = $promptcolor
+      $error_message_clear_pending = true
+    end
+    # added by rk 2008-11-29 19:01 
+    # CLEANUP DEPRECATED
+    def print_status_message text=$status_message
+      raise "DEPRECATED CLEANUP use global method of same name"
+      r = $status_message_row || Ncurses.LINES-1
+      clear_error r, $datacolor
+      # print it in centre
+      printstring r, (Ncurses.COLS-text.length)/2, text, color = $promptcolor
+    end
+    # Clear error message printed
+    # I am not only clearing if something was printed. This is since
+    # certain small forms like TabbedForm top form throw an error on printstring.
+    # 
+      #raise "DEPRECATED CLEANUP use global method of same name"
+    def clear_error r = $error_message_row, color = $datacolor
+      return unless $error_message_clear_pending
+      c = $error_message_col || (Ncurses.COLS-text.length)/2 
+      sz = $error_message_size || Ncurses.COLS
+      printstring(r, c, "%-*s" % [sz, " "], color)
+      $error_message_clear_pending = false
+    end
+    ##
+    def get_window; @window_pointer; end
+    def to_s; @name || self; 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