rbcurse 1.5.2 → 1.5.3

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

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

@@ -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