rbcurse-core 0.0.13 → 0.0.14

data/CHANGELOG

@@ -1,3 +1,13 @@
+**2013-04-01**
+## 0.0.14 rbcurse-core
+   * added module RubyCurses to various modules that were coming as top layer
+     Things could break !!!
+   * minor fix in rlist list()
+
+**2013-03-29**
+## 0.0.13 rbcurse-core
+   * textpad - support cases where dimension changes, or a row is updated
+
 **2013-03-25**
 ## 0.0.12 rbcurse-core
    * Minor tweaks and fixes to statusline (tested in ribhu gem)

data/VERSION

@@ -1 +1 @@
-0.0.13
+0.0.14

data/lib/rbcurse.rb

@@ -4,5 +4,5 @@ require 'rbcurse/core/system/window'
 require 'rbcurse/core/widgets/rwidget'
 require 'rbcurse/core/util/rdialogs'
 class Rbcurse
-  VERSION = '0.0.12'
+  VERSION = '0.0.14'
 end

data/lib/rbcurse/core/include/bordertitle.rb

@@ -1,6 +1,7 @@
 # I am moving the common title and border printing stuff into 
 # a separate module.
-module BorderTitle
+module RubyCurses
+  module BorderTitle
     dsl_accessor :suppress_borders            #to_print_borders
     dsl_accessor :border_attrib, :border_color
     dsl_accessor :title                       #set this on top
@@ -42,5 +43,6 @@ module BorderTitle
       @graphic.printstring( @row, @col+(@width-_title.length)/2, _title, @color_pair, @title_attrib) unless @title.nil?
     end
 
+  end
 end
 include BorderTitle

data/lib/rbcurse/core/include/chunk.rb

@@ -4,198 +4,200 @@
 #       Author: rkumar http://github.com/rkumar/rbcurse/
 #         Date: 07.11.11 - 12:31 
 #  Same as Ruby's License (http://www.ruby-lang.org/LICENSE.txt)
-#  Last update: 2013-03-21 19:01
+#  Last update: 2013-04-01 13:38
 # ------------------------------------------------------------ #
 #
 
-module Chunks
-  extend self
-  class Chunk
-
-    # color_pair of associated text
-    # text to print
-    # attribute of associated text
-    #attr_accessor :color, :text, :attrib
-    attr_reader :chunk
-
-    def initialize color, text, attrib
-      @chunk = [ color, text, attrib ]
-      #@color = color
-      #@text  = text
-      #@attrib = attrib
-    end
-    def color
-      @chunk[0]
-    end
-    def text
-      @chunk[1]
-    end
-    def attrib
-      @chunk[2]
+module RubyCurses
+  module Chunks
+    extend self
+    class Chunk
+
+      # color_pair of associated text
+      # text to print
+      # attribute of associated text
+      #attr_accessor :color, :text, :attrib
+      attr_reader :chunk
+
+      def initialize color, text, attrib
+        @chunk = [ color, text, attrib ]
+        #@color = color
+        #@text  = text
+        #@attrib = attrib
+      end
+      def color
+        @chunk[0]
+      end
+      def text
+        @chunk[1]
+      end
+      def attrib
+        @chunk[2]
+      end
     end
-  end
 
-  # consists of an array of chunks and corresponds to a line
-  # to be printed.
-  class ChunkLine
+    # consists of an array of chunks and corresponds to a line
+    # to be printed.
+    class ChunkLine
 
-    # an array of chunks
-    attr_reader :chunks
+      # an array of chunks
+      attr_reader :chunks
 
-    def initialize arr=nil
-      @chunks = arr.nil? ? Array.new : arr
-    end
-    def <<(chunk)
-      raise ArgumentError, "Chunk object expected. Received #{chunk.class} " unless chunk.is_a? Chunk
-      @chunks << chunk
-    end
-    alias :add :<<
-    def each &block
-      @chunks.each &block
-    end
+      def initialize arr=nil
+        @chunks = arr.nil? ? Array.new : arr
+      end
+      def <<(chunk)
+        raise ArgumentError, "Chunk object expected. Received #{chunk.class} " unless chunk.is_a? Chunk
+        @chunks << chunk
+      end
+      alias :add :<<
+      def each &block
+        @chunks.each &block
+      end
 
-    # returns length of text in chunks
-    def row_length
-      result = 0
-      @chunks.each { |e| result += e.text.length }
-      return result
-    end
-    # returns match for str in this chunk
-    # added 2013-03-07 - 23:59 
-    def index str
-      result = 0
-      @chunks.each { |e| txt = e.text; 
-        ix =  txt.index(str) 
-        return result + ix if ix
-        result += e.text.length 
-      }
-      return nil
-    end
-    alias :length :row_length
-    alias :size   :row_length
+      # returns length of text in chunks
+      def row_length
+        result = 0
+        @chunks.each { |e| result += e.text.length }
+        return result
+      end
+      # returns match for str in this chunk
+      # added 2013-03-07 - 23:59 
+      def index str
+        result = 0
+        @chunks.each { |e| txt = e.text; 
+          ix =  txt.index(str) 
+          return result + ix if ix
+          result += e.text.length 
+        }
+        return nil
+      end
+      alias :length :row_length
+      alias :size   :row_length
 
-    # return a Chunkline containing only the text for the range requested
-    def substring start, size
-      raise "substring not implemented yet"
-    end
-    def to_s
-      result = ""
-      @chunks.each { |e| result << e.text }
-      result
-    end
+      # return a Chunkline containing only the text for the range requested
+      def substring start, size
+        raise "substring not implemented yet"
+      end
+      def to_s
+        result = ""
+        @chunks.each { |e| result << e.text }
+        result
+      end
 
-    # added to take care of many string methods that are called.
-    # Callers really don't know this is a chunkline, they assume its a string
-    # 2013-03-21 - 19:01 
-    def method_missing(sym, *args, &block)
-      self.to_s.send sym, *args, &block
-    end
-  end
-  class ColorParser
-    def initialize cp
-      color_parser cp
-      @color_pair = $datacolor
-      @attrib     = FFI::NCurses::A_NORMAL
-      @color_array = [:white]
-      @bgcolor_array = [:black]
-      @attrib_array = [@attrib]
-      @color_pair_array = [@color_pair]
-      @color = :white
-      @bgcolor = :black
+      # added to take care of many string methods that are called.
+      # Callers really don't know this is a chunkline, they assume its a string
+      # 2013-03-21 - 19:01 
+      def method_missing(sym, *args, &block)
+        self.to_s.send sym, *args, &block
+      end
     end
-    #
-    # Takes a formatted string and converts the parsed parts to chunks.
-    #
-    # @param [String] takes the entire line or string and breaks into an array of chunks
-    # @yield chunk if block
-    # @return [ChunkLine] # [Array] array of chunks
-    # @since 1.4.1   2011-11-3 experimental, can change
-    public
-    def convert_to_chunk s, colorp=$datacolor, att=FFI::NCurses::A_NORMAL
-      #require 'rbcurse/core/include/chunk'
-
-      @color_parser ||= get_default_color_parser()
-      ## defaults
-      color_pair = @color_pair
-      attrib = @attrib
-      #res = []
-      res = ChunkLine.new
-      color = @color
-      bgcolor = @bgcolor
-      # stack the values, so when user issues "/end" we can pop earlier ones
-
-      @color_parser.parse_format(s) do |p|
-        case p
-        when Array
-          ## got color / attrib info, this starts a new span
-
-          #color, bgcolor, attrib = *p
-          lc, lb, la = *p
-          if la
-            @attrib = get_attrib la
-          end
-          if lc || lb
-            @color = lc ? lc : @color_array.last
-            @bgcolor = lb ? lb : @bgcolor_array.last
-            @color_array << @color
-            @bgcolor_array << @bgcolor
-            @color_pair = get_color($datacolor, @color, @bgcolor)
-          end
-          @color_pair_array << @color_pair
-          @attrib_array << @attrib
-          #$log.debug "XXX: CHUNK start #{color_pair} , #{attrib} :: c:#{lc} b:#{lb} "
-          #$log.debug "XXX: CHUNK start arr #{@color_pair_array} :: #{@attrib_array} "
-
-        when :endcolor
-
-          # end the current (last) span
-          @color_pair_array.pop
-          @color_pair = @color_pair_array.last
-          @attrib_array.pop
-          @attrib = @attrib_array.last
-          #$log.debug "XXX: CHUNK end #{color_pair} , #{attrib} "
-          #$log.debug "XXX: CHUNK end arr #{@color_pair_array} :: #{@attrib_array} "
-        when :reset   # ansi has this
-          # end all previous colors
-          @color_pair = $datacolor # @color_pair_array.first
-          @color_pair_array = [@color_pair]
-          @attrib = FFI::NCurses::A_NORMAL #@attrib_array.first
-          @attrib_array = [@attrib]
-          @bgcolor_array = [@bgcolor_array.first]
-          @color_array = [@color_array.first]
-
-        when String
-
-          ## create the chunk
-          #$log.debug "XXX:  CHUNK     using on #{p}  : #{@color_pair} , #{@attrib} " # 2011-12-10 12:38:51
-
-          #chunk =  [color_pair, p, attrib] 
-          chunk = Chunk.new @color_pair, p, @attrib
-          if block_given?
-            yield chunk
-          else
-            res << chunk
+    class ColorParser
+      def initialize cp
+        color_parser cp
+        @color_pair = $datacolor
+        @attrib     = FFI::NCurses::A_NORMAL
+        @color_array = [:white]
+        @bgcolor_array = [:black]
+        @attrib_array = [@attrib]
+        @color_pair_array = [@color_pair]
+        @color = :white
+        @bgcolor = :black
+      end
+      #
+      # Takes a formatted string and converts the parsed parts to chunks.
+      #
+      # @param [String] takes the entire line or string and breaks into an array of chunks
+      # @yield chunk if block
+      # @return [ChunkLine] # [Array] array of chunks
+      # @since 1.4.1   2011-11-3 experimental, can change
+      public
+      def convert_to_chunk s, colorp=$datacolor, att=FFI::NCurses::A_NORMAL
+        #require 'rbcurse/core/include/chunk'
+
+        @color_parser ||= get_default_color_parser()
+        ## defaults
+        color_pair = @color_pair
+        attrib = @attrib
+        #res = []
+        res = ChunkLine.new
+        color = @color
+        bgcolor = @bgcolor
+        # stack the values, so when user issues "/end" we can pop earlier ones
+
+        @color_parser.parse_format(s) do |p|
+          case p
+          when Array
+            ## got color / attrib info, this starts a new span
+
+            #color, bgcolor, attrib = *p
+            lc, lb, la = *p
+            if la
+              @attrib = get_attrib la
+            end
+            if lc || lb
+              @color = lc ? lc : @color_array.last
+              @bgcolor = lb ? lb : @bgcolor_array.last
+              @color_array << @color
+              @bgcolor_array << @bgcolor
+              @color_pair = get_color($datacolor, @color, @bgcolor)
+            end
+            @color_pair_array << @color_pair
+            @attrib_array << @attrib
+            #$log.debug "XXX: CHUNK start #{color_pair} , #{attrib} :: c:#{lc} b:#{lb} "
+            #$log.debug "XXX: CHUNK start arr #{@color_pair_array} :: #{@attrib_array} "
+
+          when :endcolor
+
+            # end the current (last) span
+            @color_pair_array.pop
+            @color_pair = @color_pair_array.last
+            @attrib_array.pop
+            @attrib = @attrib_array.last
+            #$log.debug "XXX: CHUNK end #{color_pair} , #{attrib} "
+            #$log.debug "XXX: CHUNK end arr #{@color_pair_array} :: #{@attrib_array} "
+          when :reset   # ansi has this
+            # end all previous colors
+            @color_pair = $datacolor # @color_pair_array.first
+            @color_pair_array = [@color_pair]
+            @attrib = FFI::NCurses::A_NORMAL #@attrib_array.first
+            @attrib_array = [@attrib]
+            @bgcolor_array = [@bgcolor_array.first]
+            @color_array = [@color_array.first]
+
+          when String
+
+            ## create the chunk
+            #$log.debug "XXX:  CHUNK     using on #{p}  : #{@color_pair} , #{@attrib} " # 2011-12-10 12:38:51
+
+            #chunk =  [color_pair, p, attrib] 
+            chunk = Chunk.new @color_pair, p, @attrib
+            if block_given?
+              yield chunk
+            else
+              res << chunk
+            end
           end
+        end # parse
+        return res unless block_given?
+      end
+      def get_default_color_parser
+        require 'rbcurse/core/util/colorparser'
+        @color_parser || DefaultColorParser.new
+      end
+      # supply with a color parser, if you supplied formatted text
+      public
+      def color_parser f
+        $log.debug "XXX:  color_parser setting in CP to #{f} "
+        if f == :tmux
+          @color_parser = get_default_color_parser()
+        elsif f == :ansi
+          require 'rbcurse/core/util/ansiparser'
+          @color_parser = AnsiParser.new
+        else
+          @color_parser = f
         end
-      end # parse
-      return res unless block_given?
-    end
-    def get_default_color_parser
-      require 'rbcurse/core/util/colorparser'
-      @color_parser || DefaultColorParser.new
-    end
-    # supply with a color parser, if you supplied formatted text
-    public
-    def color_parser f
-      $log.debug "XXX:  color_parser setting in CP to #{f} "
-      if f == :tmux
-        @color_parser = get_default_color_parser()
-      elsif f == :ansi
-        require 'rbcurse/core/util/ansiparser'
-        @color_parser = AnsiParser.new
-      else
-        @color_parser = f
       end
-    end
-  end # class
+    end # class
+  end
 end

data/lib/rbcurse/core/include/io.rb

@@ -10,47 +10,48 @@
 # Changes:
 # 2011-12-6 : removed many old, outdated methods.
 #*******************************************************#
-module Io
+module RubyCurses
+  module Io
 
-  # create a 2 line window at bottom to accept user input
-  # 
-  def __create_footer_window h = 2 , w = Ncurses.COLS, t = Ncurses.LINES-2, l = 0
-    ewin = VER::Window.new(h, w , t, l)
-  end
-  # 2011-11-27 I have replaced the getting of chars with a field
+    # create a 2 line window at bottom to accept user input
+    # 
+    def __create_footer_window h = 2 , w = Ncurses.COLS, t = Ncurses.LINES-2, l = 0
+      ewin = VER::Window.new(h, w , t, l)
+    end
+    # 2011-11-27 I have replaced the getting of chars with a field
 
-  # routine to get a string at bottom of window.
-  # The first 3 params are no longer required since we create a window
-  # of our own. 
-  # @param [String] prompt - label to show
-  # @param [Fixnum] maxlen - max length of input
-  # @param [Hash] config - :default, :display_length of Field, :help_text, :tab_completion
-  # help_text is displayed on F1
-  # tab_completion is a proc which helps to complete user input
-  # This method is now only for backward compatibility
-  # rbgetstr had various return codes based on whether user asked for help
-  # possibly mimicking alpine, or because i could do nothing about it.
-  # Now, rbgets handles that and only returns if the user cancels or enters
-  # a string, so rbgets does not need to return other codes.
-  def rbgetstr(nolongerused, r, c, prompt, maxlen, config={})
-    config[:maxlen] = maxlen
-    str = rb_gets(prompt, config)
-    if str
-      return 0, str
-    else
-      return -1, nil
+    # routine to get a string at bottom of window.
+    # The first 3 params are no longer required since we create a window
+    # of our own. 
+    # @param [String] prompt - label to show
+    # @param [Fixnum] maxlen - max length of input
+    # @param [Hash] config - :default, :display_length of Field, :help_text, :tab_completion
+    # help_text is displayed on F1
+    # tab_completion is a proc which helps to complete user input
+    # This method is now only for backward compatibility
+    # rbgetstr had various return codes based on whether user asked for help
+    # possibly mimicking alpine, or because i could do nothing about it.
+    # Now, rbgets handles that and only returns if the user cancels or enters
+    # a string, so rbgets does not need to return other codes.
+    def rbgetstr(nolongerused, r, c, prompt, maxlen, config={})
+      config[:maxlen] = maxlen
+      str = rb_gets(prompt, config)
+      if str
+        return 0, str
+      else
+        return -1, nil
+      end
     end
-  end
 
-  # get a string at the bottom of the screen
-  #
-  # @param [String] prompt - label to show
-  # @param [Hash] config - :default, :display_length of Field, :help_text, :tab_completion
-  # help_text is displayed on F1
-  # tab_completion is a proc which helps to complete user input
-  # @yield [Field] for overriding or customization
-  # @return [String, nil] String if entered, nil if canceled
-  def rb_gets(prompt, config={}) # yield field
+    # get a string at the bottom of the screen
+    #
+    # @param [String] prompt - label to show
+    # @param [Hash] config - :default, :display_length of Field, :help_text, :tab_completion
+    # help_text is displayed on F1
+    # tab_completion is a proc which helps to complete user input
+    # @yield [Field] for overriding or customization
+    # @return [String, nil] String if entered, nil if canceled
+    def rb_gets(prompt, config={}) # yield field
       if config.is_a? Array
         options = config
         completion_proc = Proc.new{|str| 
@@ -59,493 +60,494 @@ module Io
         config = {}
         config[:tab_completion] = completion_proc
       end
-    begin
-      win = __create_footer_window
-      form = Form.new win
-      r = 0; c = 1;
-      default = config[:default] || ""
-      prompt = "#{prompt} [#{default}]:" if default.size > 0
-      _max = FFI::NCurses.COLS-1-prompt.size-4
-      displen = config[:display_length] || [config[:maxlen] || 999, _max].min
-      maxlen = config[:maxlen] || _max
-      field = Field.new form, :row => r, :col => c, :maxlen => maxlen, :default => default, :label => prompt,
-        :display_length => displen
-      bg = Ncurses.COLORS >= 236 ? 233 : :blue
-      field.bgcolor = bg
-      field.cursor_end if default.size > 0
-      def field.default=(x); default(x);end
+      begin
+        win = __create_footer_window
+        form = Form.new win
+        r = 0; c = 1;
+        default = config[:default] || ""
+        prompt = "#{prompt} [#{default}]:" if default.size > 0
+        _max = FFI::NCurses.COLS-1-prompt.size-4
+        displen = config[:display_length] || [config[:maxlen] || 999, _max].min
+        maxlen = config[:maxlen] || _max
+        field = Field.new form, :row => r, :col => c, :maxlen => maxlen, :default => default, :label => prompt,
+          :display_length => displen
+        bg = Ncurses.COLORS >= 236 ? 233 : :blue
+        field.bgcolor = bg
+        field.cursor_end if default.size > 0
+        def field.default=(x); default(x);end
 
-      # if user wishes to use the yield and say "field.history = [x,y,z] then
-      # we should alredy have extended this, so lets make it permanent
-      #if config[:history]
+        # if user wishes to use the yield and say "field.history = [x,y,z] then
+        # we should alredy have extended this, so lets make it permanent
+        #if config[:history]
         #raise ArgumentError, "Field history must be an array" unless config[:history].is_a? Array
         require 'rbcurse/core/include/rhistory'
         field.extend(FieldHistory)
         #field.history_config :row => 
         field.history = config[:history]
-      #end
-
-      yield field if block_given?
-      form.repaint
-      win.wrefresh
-      prevchar = 0
-      entries = nil
-      oldstr = nil # for tab completion, origal word entered by user
-      while ((ch = win.getchar()) != 999)
-        break if ch == 10 || ch == 13 || ch == KEY_ENTER
-        #return -1, nil if ch == ?\C-c.getbyte(0) || ch == ?\C-g.getbyte(0)
-        return nil if ch == ?\C-c.getbyte(0) || ch == ?\C-g.getbyte(0)
-        #if ch == ?\M-h.getbyte(0) #                            HELP KEY
-        #help_text = config[:help_text] || "No help provided"
-        #color = $datacolor
-        #print_help(win, r, c, color, help_text)
-        ## this will come over our text
         #end
-        # TODO tab completion and help_text print on F1
-        # that field objects can extend, same for tab completion and gmail completion
-        if ch == KEY_TAB
-          if config
-            str = field.text
-            if prevchar == KEY_TAB
-              if !entries.nil? && !entries.empty?
-                str = entries.delete_at(0)
+
+        yield field if block_given?
+        form.repaint
+        win.wrefresh
+        prevchar = 0
+        entries = nil
+        oldstr = nil # for tab completion, origal word entered by user
+        while ((ch = win.getchar()) != 999)
+          break if ch == 10 || ch == 13 || ch == KEY_ENTER
+          #return -1, nil if ch == ?\C-c.getbyte(0) || ch == ?\C-g.getbyte(0)
+          return nil if ch == ?\C-c.getbyte(0) || ch == ?\C-g.getbyte(0)
+          #if ch == ?\M-h.getbyte(0) #                            HELP KEY
+          #help_text = config[:help_text] || "No help provided"
+          #color = $datacolor
+          #print_help(win, r, c, color, help_text)
+          ## this will come over our text
+          #end
+          # TODO tab completion and help_text print on F1
+          # that field objects can extend, same for tab completion and gmail completion
+          if ch == KEY_TAB
+            if config
+              str = field.text
+              if prevchar == KEY_TAB
+                if !entries.nil? && !entries.empty?
+                  str = entries.delete_at(0)
+                else
+                  str = oldstr if oldstr
+                  prevchar = ch = nil # so it can start again completing
+                end
               else
-                str = oldstr if oldstr
-                prevchar = ch = nil # so it can start again completing
+                tabc = config[:tab_completion] unless tabc
+                next unless tabc
+                oldstr = str.dup
+                entries = tabc.call(str).dup
+                $log.debug " tab got #{entries} for str=#{str}"
+                str = entries.delete_at(0) unless entries.nil? || entries.empty?
+                str = str.to_s.dup
               end
-            else
-              tabc = config[:tab_completion] unless tabc
-              next unless tabc
-              oldstr = str.dup
-              entries = tabc.call(str).dup
-              $log.debug " tab got #{entries} for str=#{str}"
-              str = entries.delete_at(0) unless entries.nil? || entries.empty?
-              str = str.to_s.dup
-            end
-            if str
-              field.text = str
-              field.cursor_end
-              field.set_form_col # shit why are we doign this, text sets curpos to 0
+              if str
+                field.text = str
+                field.cursor_end
+                field.set_form_col # shit why are we doign this, text sets curpos to 0
+              end
+              form.repaint
+              win.wrefresh
             end
-            form.repaint
-            win.wrefresh
-          end
 
-          # tab_completion
-          # if previous char was not tab, execute tab_completion_proc and push first entry
-          # else push the next entry
-        elsif ch == KEY_F1
-          help_text = config[:help_text] || "No help provided. C-c/C-g aborts. <TAB> completion. Alt-h history. C-a/e"
-          print_status_message help_text, :wait => 7
-        else
-          form.handle_key ch
+            # tab_completion
+            # if previous char was not tab, execute tab_completion_proc and push first entry
+            # else push the next entry
+          elsif ch == KEY_F1
+            help_text = config[:help_text] || "No help provided. C-c/C-g aborts. <TAB> completion. Alt-h history. C-a/e"
+            print_status_message help_text, :wait => 7
+          else
+            form.handle_key ch
+          end
+          prevchar = ch
+          win.wrefresh
         end
-        prevchar = ch
-        win.wrefresh
+      rescue => err
+        Ncurses.beep
+        textdialog [err.to_s, *err.backtrace], :title => "Exception"
+        $log.error "EXC in rbgetsr #{err} "
+        $log.error(err.backtrace.join("\n")) 
+      ensure
+        win.destroy if win
       end
-    rescue => err
-      Ncurses.beep
-      textdialog [err.to_s, *err.backtrace], :title => "Exception"
-      $log.error "EXC in rbgetsr #{err} "
-      $log.error(err.backtrace.join("\n")) 
-    ensure
-      win.destroy if win
+      config[:history] << field.text if config[:history] && field.text
+      return field.text
     end
-    config[:history] << field.text if config[:history] && field.text
-    return field.text
-  end
 
-  # get a character.
-  # unlike rb_gets allows user to enter control or alt or function character too.
-  # @param [String] prompt or label to show.
-  # @param [Hash] configuration such as default or regexp for validation
-  # @return [Fixnum] nil if canceled, or ret value of getchar which is numeric
-  # If default provided, then ENTER returns the default
-  def rb_getchar(prompt, config={}) # yield field
-    begin
-      win = __create_footer_window
-      #form = Form.new win
-      r = 0; c = 1;
-      default = config[:default] 
-      prompt = "#{prompt} [#{default}] " if default
-      win.mvprintw(r, c, "%s: " % prompt);
-      bg = Ncurses.COLORS >= 236 ? 236 : :blue
-      color_pair = get_color($reversecolor, :white, bg)
-      win.printstring r, c + prompt.size + 2, " ", color_pair
+    # get a character.
+    # unlike rb_gets allows user to enter control or alt or function character too.
+    # @param [String] prompt or label to show.
+    # @param [Hash] configuration such as default or regexp for validation
+    # @return [Fixnum] nil if canceled, or ret value of getchar which is numeric
+    # If default provided, then ENTER returns the default
+    def rb_getchar(prompt, config={}) # yield field
+      begin
+        win = __create_footer_window
+        #form = Form.new win
+        r = 0; c = 1;
+        default = config[:default] 
+        prompt = "#{prompt} [#{default}] " if default
+        win.mvprintw(r, c, "%s: " % prompt);
+        bg = Ncurses.COLORS >= 236 ? 236 : :blue
+        color_pair = get_color($reversecolor, :white, bg)
+        win.printstring r, c + prompt.size + 2, " ", color_pair
 
-      win.wrefresh
-      prevchar = 0
-      entries = nil
-      while ((ch = win.getchar()) != 999)
-        return default.ord if default && (ch == 13 || ch == KEY_ENTER)
-        return nil if ch == ?\C-c.getbyte(0) || ch == ?\C-g.getbyte(0)
-        if ch == KEY_F1
-          help_text = config[:help_text] || "No help provided. C-c/C-g aborts."
-          print_status_message help_text, :wait => 7
-          win.wrefresh # nevr had to do this with ncurses, but have to with ffi-ncurses ??
-          next
-        end
-        if config[:regexp]
-          reg = config[:regexp]
-          if ch > 0 && ch < 256
-            chs = ch.chr
-            return ch if chs =~ reg
-            alert "Wrong character. #{reg} "
+        win.wrefresh
+        prevchar = 0
+        entries = nil
+        while ((ch = win.getchar()) != 999)
+          return default.ord if default && (ch == 13 || ch == KEY_ENTER)
+          return nil if ch == ?\C-c.getbyte(0) || ch == ?\C-g.getbyte(0)
+          if ch == KEY_F1
+            help_text = config[:help_text] || "No help provided. C-c/C-g aborts."
+            print_status_message help_text, :wait => 7
+            win.wrefresh # nevr had to do this with ncurses, but have to with ffi-ncurses ??
+            next
+          end
+          if config[:regexp]
+            reg = config[:regexp]
+            if ch > 0 && ch < 256
+              chs = ch.chr
+              return ch if chs =~ reg
+              alert "Wrong character. #{reg} "
+            else
+              alert "Wrong character. #{reg} "
+            end
           else
-            alert "Wrong character. #{reg} "
+            return ch
           end
-        else
-          return ch
+          #form.handle_key ch
+          win.wrefresh
         end
-        #form.handle_key ch
-        win.wrefresh
+      rescue => err
+        Ncurses.beep
+        $log.error "EXC in rbgetsr #{err} "
+        $log.error(err.backtrace.join("\n")) 
+      ensure
+        win.destroy if win
       end
-    rescue => err
-      Ncurses.beep
-      $log.error "EXC in rbgetsr #{err} "
-      $log.error(err.backtrace.join("\n")) 
-    ensure
-      win.destroy if win
+      return nil
     end
-    return nil
-  end
 
-  # This is just experimental, trying out tab_completion
-  # Prompt user for a file name, allowing him to tab to complete filenames
-  # @param [String] label to print before field
-  # @param [Fixnum] max length of field
-  # @return [String] filename or blank if user cancelled
-  def get_file prompt, config={}  #:nodoc:
-    maxlen = 70
-    tabc = Proc.new {|str| Dir.glob(str +"*") }
-    config[:tab_completion] ||= tabc
-    #config[:default] = "test"
-    ret, str = rbgetstr(nil,0,0, prompt, maxlen, config)
-    #$log.debug " get_file returned #{ret} , #{str} "
-    return "" if ret != 0
-    return str
-  end
-  def clear_this win, r, c, color, len
-    print_this(win, "%-*s" % [len," "], color, r, c)
-  end
+    # This is just experimental, trying out tab_completion
+    # Prompt user for a file name, allowing him to tab to complete filenames
+    # @param [String] label to print before field
+    # @param [Fixnum] max length of field
+    # @return [String] filename or blank if user cancelled
+    def get_file prompt, config={}  #:nodoc:
+      maxlen = 70
+      tabc = Proc.new {|str| Dir.glob(str +"*") }
+      config[:tab_completion] ||= tabc
+      #config[:default] = "test"
+      ret, str = rbgetstr(nil,0,0, prompt, maxlen, config)
+      #$log.debug " get_file returned #{ret} , #{str} "
+      return "" if ret != 0
+      return str
+    end
+    def clear_this win, r, c, color, len
+      print_this(win, "%-*s" % [len," "], color, r, c)
+    end
 
 
 
-  ##
-  # prints given text to window, in color at x and y coordinates
-  # @param [Window] window to write to
-  # @param [String] text to print
-  # @param [int] color pair such as $datacolor or $promptcolor
-  # @param [int] x  row
-  # @param [int] y  col
-  # @see Window#printstring
-  def print_this(win, text, color, x, y)
-    raise "win nil in print_this" unless win
-    color=Ncurses.COLOR_PAIR(color);
-    win.attron(color);
-    #win.mvprintw(x, y, "%-40s" % text);
-    win.mvprintw(x, y, "%s" % text);
-    win.attroff(color);
-    win.refresh
-  end
+    ##
+    # prints given text to window, in color at x and y coordinates
+    # @param [Window] window to write to
+    # @param [String] text to print
+    # @param [int] color pair such as $datacolor or $promptcolor
+    # @param [int] x  row
+    # @param [int] y  col
+    # @see Window#printstring
+    def print_this(win, text, color, x, y)
+      raise "win nil in print_this" unless win
+      color=Ncurses.COLOR_PAIR(color);
+      win.attron(color);
+      #win.mvprintw(x, y, "%-40s" % text);
+      win.mvprintw(x, y, "%s" % text);
+      win.attroff(color);
+      win.refresh
+    end
 
 
-  #
-  # warn user: currently flashes and places error in log file
-  # experimental, may change interface later
-  # it does not say anything on screen
-  # @param [String] text of error/warning to put in log
-  # @since 1.1.5
-  def warn string
-    $log.warn string
-    Ncurses.beep
-  end
+    #
+    # warn user: currently flashes and places error in log file
+    # experimental, may change interface later
+    # it does not say anything on screen
+    # @param [String] text of error/warning to put in log
+    # @since 1.1.5
+    def warn string
+      $log.warn string
+      Ncurses.beep
+    end
 
-  #def add_item hotkey, label, desc,action
-  #
-  ## A *simple* way of creating menus that will appear in a single row.
-  # This copies the menu at the bottom of "most" upon pressing ":".
-  # hotkey is the key to invoke an item (a single digit letter)
-  #
-  # label is an action name
-  #
-  # desc is a description displayed after an item is chosen. Usually, its like:
-  #+ "Folding has been enabled" or "Searches will now be case sensitive"
-  #
-  # action may be a Proc or a symbol which will be called if item selected
-  #+ action may be another menu, so recursive menus can be built, but each
-  #+ should fit in a line, its a simple system.
+    #def add_item hotkey, label, desc,action
+    #
+    ## A *simple* way of creating menus that will appear in a single row.
+    # This copies the menu at the bottom of "most" upon pressing ":".
+    # hotkey is the key to invoke an item (a single digit letter)
+    #
+    # label is an action name
+    #
+    # desc is a description displayed after an item is chosen. Usually, its like:
+    #+ "Folding has been enabled" or "Searches will now be case sensitive"
+    #
+    # action may be a Proc or a symbol which will be called if item selected
+    #+ action may be another menu, so recursive menus can be built, but each
+    #+ should fit in a line, its a simple system.
 
-  CMenuItem = Struct.new( :hotkey, :label, :desc, :action )
+    CMenuItem = Struct.new( :hotkey, :label, :desc, :action )
 
 
-  ## An encapsulated form of yesterday's Most Menu
-  # It keeps the internals away from the user.
-  # Its not really OOP in the sense that the PromptMenu is not a MenuItem. That's how it is in
-  # our Menu system, and that led to a lot of painful coding (at least for me). This is quite
-  # simple. A submenu contains a PromptMenu in its action object and is evaluated in a switch.
-  # A recursive loop handles submenus.
-  #
-  # Prompting of menu options with suboptions etc.
-  # A block of code or symbol or proc is executed for any leaf node
-  # This allows us to define different menus for different objects on the screen, and not have to map 
-  # all kinds of control keys for operations, and have the user remember them. Only one key invokes the menu
-  # and the rest are ordinary characters.
-  # 
-  #  == Example
-  #    menu = PromptMenu.new self do
-  #      item :s, :goto_start
-  #      item :b, :goto_bottom
-  #      item :r, :scroll_backward
-  #      item :l, :scroll_forward
-  #      submenu :m, "submenu" do
-  #        item :p, :goto_last_position
-  #        item :r, :scroll_backward
-  #        item :l, :scroll_forward
-  #      end
-  #    end
-  #    menu.display @form.window, $error_message_row, $error_message_col, $datacolor #, menu
+    ## An encapsulated form of yesterday's Most Menu
+    # It keeps the internals away from the user.
+    # Its not really OOP in the sense that the PromptMenu is not a MenuItem. That's how it is in
+    # our Menu system, and that led to a lot of painful coding (at least for me). This is quite
+    # simple. A submenu contains a PromptMenu in its action object and is evaluated in a switch.
+    # A recursive loop handles submenus.
+    #
+    # Prompting of menu options with suboptions etc.
+    # A block of code or symbol or proc is executed for any leaf node
+    # This allows us to define different menus for different objects on the screen, and not have to map 
+    # all kinds of control keys for operations, and have the user remember them. Only one key invokes the menu
+    # and the rest are ordinary characters.
+    # 
+    #  == Example
+    #    menu = PromptMenu.new self do
+    #      item :s, :goto_start
+    #      item :b, :goto_bottom
+    #      item :r, :scroll_backward
+    #      item :l, :scroll_forward
+    #      submenu :m, "submenu" do
+    #        item :p, :goto_last_position
+    #        item :r, :scroll_backward
+    #        item :l, :scroll_forward
+    #      end
+    #    end
+    #    menu.display @form.window, $error_message_row, $error_message_col, $datacolor #, menu
 
-  class PromptMenu
-    include Io
-    attr_reader :text
-    attr_reader :options
-    def initialize caller,  text="Choose:", &block
-      @caller = caller
-      @text = text
-      @options = []
-      yield_or_eval &block if block_given?
-    end
-    def add *menuitem
-      item = nil
-      case menuitem.first
-      when CMenuItem
-        item = menuitem.first
-        @options << item
-      else
-        case menuitem.size
-        when 4
-          item = CMenuItem.new(*menuitem.flatten)
-        when 2
-          # if user only sends key and symbol
-          menuitem[3] = menuitem[1]
-          item = CMenuItem.new(*menuitem.flatten)
-        when 1
-          if menuitem.first.is_a? Action
-            item = menuitem.first
+    class PromptMenu
+      include Io
+      attr_reader :text
+      attr_reader :options
+      def initialize caller,  text="Choose:", &block
+        @caller = caller
+        @text = text
+        @options = []
+        yield_or_eval &block if block_given?
+      end
+      def add *menuitem
+        item = nil
+        case menuitem.first
+        when CMenuItem
+          item = menuitem.first
+          @options << item
+        else
+          case menuitem.size
+          when 4
+            item = CMenuItem.new(*menuitem.flatten)
+          when 2
+            # if user only sends key and symbol
+            menuitem[3] = menuitem[1]
+            item = CMenuItem.new(*menuitem.flatten)
+          when 1
+            if menuitem.first.is_a? Action
+              item = menuitem.first
+            else
+              raise ArgumentError, "Don't know how to handle #{menuitem.size} : #{menuitem} "
+            end
           else
             raise ArgumentError, "Don't know how to handle #{menuitem.size} : #{menuitem} "
           end
-        else
-          raise ArgumentError, "Don't know how to handle #{menuitem.size} : #{menuitem} "
+          @options << item
         end
+        return item
+      end
+      alias :item :add
+      def create_mitem *args
+        item = CMenuItem.new(*args.flatten)
+      end
+      # Added this, since actually it could have been like this 2011-12-22  
+      def self.create_menuitem *args
+        item = CMenuItem.new(*args.flatten)
+      end
+      # create the whole thing using a MenuTree which has minimal information.
+      # It uses a hotkey and a code only. We are supposed to resolve the display text
+      # and actual proc from the caller using this code.
+      def menu_tree mt, pm = self
+        mt.each_pair { |ch, code| 
+          if code.is_a? RubyCurses::MenuTree
+            item = pm.add(ch, code.value, "") 
+            current = PromptMenu.new @caller, code.value
+            item.action = current
+            menu_tree code, current
+          else
+            item = pm.add(ch, code.to_s, "", code) 
+          end
+        }
+      end
+      # 
+      # To allow a more rubyesque way of defining menus and submenus
+      def submenu key, label, &block
+        item = CMenuItem.new(key, label)
         @options << item
+        item.action = PromptMenu.new @caller, label, &block
       end
-      return item
-    end
-    alias :item :add
-    def create_mitem *args
-      item = CMenuItem.new(*args.flatten)
-    end
-    # Added this, since actually it could have been like this 2011-12-22  
-    def self.create_menuitem *args
-      item = CMenuItem.new(*args.flatten)
-    end
-    # create the whole thing using a MenuTree which has minimal information.
-    # It uses a hotkey and a code only. We are supposed to resolve the display text
-    # and actual proc from the caller using this code.
-    def menu_tree mt, pm = self
-      mt.each_pair { |ch, code| 
-        if code.is_a? RubyCurses::MenuTree
-          item = pm.add(ch, code.value, "") 
-          current = PromptMenu.new @caller, code.value
-          item.action = current
-          menu_tree code, current
-        else
-          item = pm.add(ch, code.to_s, "", code) 
+      #
+      # Display prompt_menu in columns using commandwindow
+      # This is an improved way of showing the "most" like menu. The earlier
+      # format would only print in one row.
+      #
+      def display_columns config={}
+        prompt = config[:prompt] || "Choose: "
+        require 'rbcurse/core/util/rcommandwindow'
+        layout = { :height => 5, :width => Ncurses.COLS-0, :top => Ncurses.LINES-6, :left => 0 }
+        rc = CommandWindow.new nil, :layout => layout, :box => true, :title => config[:title] || "Menu"
+        w = rc.window
+        r = 4
+        c = 1
+        color = $datacolor
+        begin
+          menu = @options
+          $log.debug " DISP MENU "
+          ret = 0
+          len = 80
+          while true
+            h = {}
+            valid = []
+            labels = []
+            menu.each{ |item|
+              if item.respond_to? :hotkey
+                hk = item.hotkey.to_s
+              else
+                raise ArgumentError, "Promptmenu needs hotkey or mnemonic"
+              end
+              # 187compat 2013-03-20 - 19:00 throws up
+              labels << "%c. %s " % [ hk.getbyte(0), item.label ]
+              h[hk] = item
+              valid << hk
+            }
+            #$log.debug " valid are #{valid} "
+            color = $datacolor
+            #print_this(win, str, color, r, c)
+            rc.display_menu labels, :indexing => :custom
+            ch=w.getchar()
+            rc.clear
+            #$log.debug " got ch #{ch} "
+            next if ch < 0 or ch > 255
+            if ch == 3 || ch == ?\C-g.getbyte(0)
+              clear_this w, r, c, color, len
+              print_this(w, "Aborted.", color, r,c)
+              break
+            end
+            ch = ch.chr
+            index = valid.index ch
+            if index.nil?
+              clear_this w, r, c, color, len
+              print_this(w, "Not valid. Valid are #{valid}. C-c/C-g to abort.", color, r,c)
+              sleep 1
+              next
+            end
+            #$log.debug " index is #{index} "
+            item = h[ch]
+            # I don;t think this even shows now, its useless
+            if item.respond_to? :desc
+              desc = item.desc
+              #desc ||= "Could not find desc for #{ch} "
+              desc ||= ""
+              clear_this w, r, c, color, len
+              print_this(w, desc, color, r,c)
+            end
+            action = item.action
+            case action
+              #when Array
+            when PromptMenu
+              # submenu
+              menu = action.options
+              title = rc.title
+              rc.title title +" => " + action.text # set title of window to submenu
+            when Proc
+              ret = action.call
+              break
+            when Symbol
+              if @caller.respond_to?(action, true)
+                $log.debug "XXX:  IO caller responds to action #{action} "
+                ret = @caller.send(action)
+              elsif @caller.respond_to?(:execute_this, true)
+                ret = @caller.send(:execute_this, action)
+              else
+                alert "PromptMenu: unidentified action #{action} for #{@caller.class} "
+                raise "PromptMenu: unidentified action #{action} for #{@caller.class} "
+              end
+
+              break
+            else 
+              $log.debug " Unidentified flying class #{action.class} "
+              break
+            end
+          end # while
+        ensure
+          rc.destroy
+          rc = nil
         end
-      }
-    end
-    # 
-    # To allow a more rubyesque way of defining menus and submenus
-    def submenu key, label, &block
-      item = CMenuItem.new(key, label)
-      @options << item
-      item.action = PromptMenu.new @caller, label, &block
-    end
-    #
-    # Display prompt_menu in columns using commandwindow
-    # This is an improved way of showing the "most" like menu. The earlier
-    # format would only print in one row.
-    #
-    def display_columns config={}
-      prompt = config[:prompt] || "Choose: "
-      require 'rbcurse/core/util/rcommandwindow'
-      layout = { :height => 5, :width => Ncurses.COLS-0, :top => Ncurses.LINES-6, :left => 0 }
-      rc = CommandWindow.new nil, :layout => layout, :box => true, :title => config[:title] || "Menu"
-      w = rc.window
-      r = 4
-      c = 1
-      color = $datacolor
-      begin
+      end
+      alias :display_new :display_columns
+
+      # Display the top level menu and accept user input
+      # Calls actions or symbols upon selection, or traverses submenus
+      # @return retvalue of last call or send, or 0
+      # @param win window
+      # @param r, c row and col to display on
+      # @param color text color (use $datacolor if in doubt)
+      # @see display_new - it presents in a much better manner
+      # and is not restricted to one row. Avoid this.
+      def display win, r, c, color
+        raise "Please use display_new, i've replace this with that"
+        # FIXME use a oneline window, user should not have to give all this crap.
+        # What about panning if we can;t fit, should we use horiz list to show ?
         menu = @options
         $log.debug " DISP MENU "
         ret = 0
-        len = 80
         while true
+          str = @text.dup
           h = {}
           valid = []
-          labels = []
           menu.each{ |item|
-            if item.respond_to? :hotkey
-              hk = item.hotkey.to_s
-            else
-              raise ArgumentError, "Promptmenu needs hotkey or mnemonic"
-            end
-            # 187compat 2013-03-20 - 19:00 throws up
-            labels << "%c. %s " % [ hk.getbyte(0), item.label ]
+            hk = item.hotkey.to_s
+            str << "(%c) %s " % [ hk, item.label ]
             h[hk] = item
             valid << hk
           }
           #$log.debug " valid are #{valid} "
           color = $datacolor
-          #print_this(win, str, color, r, c)
-          rc.display_menu labels, :indexing => :custom
-          ch=w.getchar()
-          rc.clear
+          print_this(win, str, color, r, c)
+          ch=win.getchar()
           #$log.debug " got ch #{ch} "
           next if ch < 0 or ch > 255
           if ch == 3 || ch == ?\C-g.getbyte(0)
-            clear_this w, r, c, color, len
-            print_this(w, "Aborted.", color, r,c)
+            clear_this win, r, c, color, str.length
+            print_this(win, "Aborted.", color, r,c)
             break
           end
           ch = ch.chr
           index = valid.index ch
           if index.nil?
-            clear_this w, r, c, color, len
-            print_this(w, "Not valid. Valid are #{valid}. C-c/C-g to abort.", color, r,c)
+            clear_this win, r, c, color, str.length
+            print_this(win, "Not valid. Valid are #{valid}", color, r,c)
             sleep 1
             next
           end
           #$log.debug " index is #{index} "
           item = h[ch]
-          # I don;t think this even shows now, its useless
-          if item.respond_to? :desc
-            desc = item.desc
-            #desc ||= "Could not find desc for #{ch} "
-            desc ||= ""
-            clear_this w, r, c, color, len
-            print_this(w, desc, color, r,c)
-          end
+          desc = item.desc
+          #desc ||= "Could not find desc for #{ch} "
+          desc ||= ""
+          clear_this win, r, c, color, str.length
+          print_this(win, desc, color, r,c)
           action = item.action
           case action
             #when Array
           when PromptMenu
             # submenu
             menu = action.options
-            title = rc.title
-            rc.title title +" => " + action.text # set title of window to submenu
+            str = "%s: " % action.text 
           when Proc
             ret = action.call
             break
           when Symbol
-            if @caller.respond_to?(action, true)
-              $log.debug "XXX:  IO caller responds to action #{action} "
-              ret = @caller.send(action)
-            elsif @caller.respond_to?(:execute_this, true)
-              ret = @caller.send(:execute_this, action)
-            else
-              alert "PromptMenu: unidentified action #{action} for #{@caller.class} "
-              raise "PromptMenu: unidentified action #{action} for #{@caller.class} "
-            end
-
+            ret = @caller.send(action)
             break
           else 
             $log.debug " Unidentified flying class #{action.class} "
             break
           end
         end # while
-      ensure
-        rc.destroy
-        rc = nil
+        return ret # ret val of last send or call
       end
-    end
-    alias :display_new :display_columns
-
-    # Display the top level menu and accept user input
-    # Calls actions or symbols upon selection, or traverses submenus
-    # @return retvalue of last call or send, or 0
-    # @param win window
-    # @param r, c row and col to display on
-    # @param color text color (use $datacolor if in doubt)
-    # @see display_new - it presents in a much better manner
-    # and is not restricted to one row. Avoid this.
-    def display win, r, c, color
-      raise "Please use display_new, i've replace this with that"
-      # FIXME use a oneline window, user should not have to give all this crap.
-      # What about panning if we can;t fit, should we use horiz list to show ?
-      menu = @options
-      $log.debug " DISP MENU "
-      ret = 0
-      while true
-        str = @text.dup
-        h = {}
-        valid = []
-        menu.each{ |item|
-          hk = item.hotkey.to_s
-          str << "(%c) %s " % [ hk, item.label ]
-          h[hk] = item
-          valid << hk
-        }
-        #$log.debug " valid are #{valid} "
-        color = $datacolor
-        print_this(win, str, color, r, c)
-        ch=win.getchar()
-        #$log.debug " got ch #{ch} "
-        next if ch < 0 or ch > 255
-        if ch == 3 || ch == ?\C-g.getbyte(0)
-          clear_this win, r, c, color, str.length
-          print_this(win, "Aborted.", color, r,c)
-          break
-        end
-        ch = ch.chr
-        index = valid.index ch
-        if index.nil?
-          clear_this win, r, c, color, str.length
-          print_this(win, "Not valid. Valid are #{valid}", color, r,c)
-          sleep 1
-          next
-        end
-        #$log.debug " index is #{index} "
-        item = h[ch]
-        desc = item.desc
-        #desc ||= "Could not find desc for #{ch} "
-        desc ||= ""
-        clear_this win, r, c, color, str.length
-        print_this(win, desc, color, r,c)
-        action = item.action
-        case action
-          #when Array
-        when PromptMenu
-          # submenu
-          menu = action.options
-          str = "%s: " % action.text 
-        when Proc
-          ret = action.call
-          break
-        when Symbol
-          ret = @caller.send(action)
-          break
-        else 
-          $log.debug " Unidentified flying class #{action.class} "
-          break
-        end
-      end # while
-      return ret # ret val of last send or call
-    end
-  end # class PromptMenu
+    end # class PromptMenu
 
-  ### ADD HERE ###  
+    ### ADD HERE ###  
 
+  end # module
 end # module