rbcurse 1.4.0 → 1.4.1.pre2

data/lib/rbcurse/common/bordertitle.rb

@@ -0,0 +1,41 @@
+# I am moving the common title and border printing stuff into 
+# a separate module.
+module BorderTitle
+    dsl_accessor :suppress_borders            #to_print_borders
+    dsl_accessor :border_attrib, :border_color
+    dsl_accessor :title                       #set this on top
+    dsl_accessor :title_attrib                #bold, reverse, normal
+    dsl_accessor :border_attrib, :border_color # 
+
+    def bordertitle_init
+      @row_offset = @col_offset = 0 if @suppress_borders 
+      @internal_width = 1 if @suppress_borders
+    end
+    # why the dash does it reduce height by one.
+    def print_borders
+      raise ArgumentError, "Graphic not set" unless @graphic
+      width = @width
+      height = @height-1
+      window = @graphic
+      startcol = @col 
+      startrow = @row 
+      @color_pair = get_color($datacolor)
+      bordercolor = @border_color || @color_pair
+      borderatt = @border_attrib || Ncurses::A_NORMAL
+      window.print_border startrow, startcol, height, width, bordercolor, borderatt
+      print_title
+    end
+    def print_title
+      return unless @title
+      raise "#{self} needs width" unless @width
+      @color_pair ||= get_color($datacolor) # should we not use this ??? XXX 
+      #$log.debug " print_title #{@row}, #{@col}, #{@width}  "
+      # check title.length and truncate if exceeds width
+      _title = @title
+      if @title.length > @width - 2
+        _title = @title[0..@width-2]
+      end
+      @graphic.printstring( @row, @col+(@width-_title.length)/2, _title, @color_pair, @title_attrib) unless @title.nil?
+    end
+
+end

data/lib/rbcurse/common/chunk.rb

@@ -0,0 +1,177 @@
+# ------------------------------------------------------------ #
+#         File: chunk.rb 
+#  Description: 
+#       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: use ,,L
+# ------------------------------------------------------------ #
+#
+
+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
+
+  # consists of an array of chunks and corresponds to a line
+  # to be printed.
+  class ChunkLine
+
+    # 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
+
+    # returns length of text in chunks
+    def row_length
+      result = 0
+      @chunks.each { |e| result += e.text.length }
+      return result
+    end
+    alias :length :row_length
+    alias :size   :row_length
+
+    # return a Chunkline containing only the text for the range requested
+    def substring start, size
+    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
+    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/common/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} "
+
+          #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/common/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/common/ansiparser'
+        @color_parser = AnsiParser.new
+      else
+        @color_parser = f
+      end
+    end
+  end # class
+end

data/lib/rbcurse/common/colorparser.rb

@@ -0,0 +1,71 @@
+# ----------------------------------------------------------------------------- #
+#         File: colorparser.rb
+#  Description: Default parse for our tmux format
+#               The aim is to be able to specify parsers so different kinds
+#               of formatting or documents can be used, such as ANSI formatted
+#               manpages.
+#       Author: rkumar http://github.com/rkumar/rbcurse/
+#         Date: 07.11.11 - 13:17
+#      License: Same as Ruby's License (http://www.ruby-lang.org/LICENSE.txt)
+#  Last update: use ,,L
+# ----------------------------------------------------------------------------- #
+# == TODO
+#    - perhaps we can compile the regexp once and reuse
+# 
+
+class DefaultColorParser
+
+  # NOTE: Experimental and minimal
+  # parses the formatted string and yields either an array of color, bgcolor and attrib
+  # or the text. This will be called by convert_to_chunk.
+  #
+  # Currently, assumes colors and attributes are correct. No error checking or fancy stuff.
+  #  s="#[fg=green]hello there#[fg=yellow, bg=black, dim]"
+  # @since 1.4.1  2011-11-3 experimental, can change
+  # @return [nil] knows nothign about output format. 
+
+  def parse_format s  # yields attribs or text
+    ## set default colors
+    color   = :white
+    bgcolor = :black
+    attrib  = FFI::NCurses::A_NORMAL
+    text    = ""
+
+    ## split #[...]
+    a       = s.split /(#\[[^\]]*\])/
+    a.each { |e| 
+      ## process color or attrib portion
+      if e[0,2] == "#[" && e[-1] == "]"
+        # now resetting 1:20 PM November 3, 2011 , earlier we were  carrying over
+        color, bgcolor, attrib = nil, nil, nil
+        catch(:done) do
+          e = e[2..-2]
+          ## first split on commas to separate fg, bg and attr
+          atts = e.split /\s*,\s*/
+          atts.each { |att|  
+            ## next split on =
+            part = att.split /\s*=\s*/
+            case part[0]
+            when "fg"
+              color = part[1]
+            when "bg"
+              bgcolor = part[1]
+            when "/end", "end"
+              yield :endcolor if block_given?
+              #next
+              throw :done
+            else
+              # attrib
+              attrib = part[0]
+            end
+          }
+          yield [color,bgcolor,attrib] if block_given?
+        end # catch
+      else
+        text = e
+        yield text if block_given?
+      end
+    }
+  end
+
+end

data/lib/rbcurse/common/keydefs.rb

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

data/lib/rbcurse/common/widgetshortcuts.rb

@@ -0,0 +1,302 @@
+# ------------------------------------------------------------ #
+#         File: widgetshortcuts.rb 
+#  Description: A common module for shortcuts to create widgets
+#               Also, stacks and flows objects
+#       Author: rkumar http://github.com/rkumar/rbcurse/
+#         Date: 05.11.11 - 15:13 
+#  Last update: 06.11.11 - 10:57
+#  == TODO
+#     add multirow comps like textview and textarea, list
+#     add blocks that make sense like in app
+#     - what if user does not want form attached - app uses useform ot
+#       to check for this, if current_object don't add form
+#
+#     - usage of _position inside means these shortcuts cannot be reused
+#     with other positioning systems, we'll be cut-pasting forever
+#
+#  == CHANGES
+# ------------------------------------------------------------ #
+#
+
+# what is the real purpose of the shortcuts, is it to avoid putting nil
+# for form there if not required.
+# Or is it positioning, such as in a stack. or just a method ?
+module RubyCurses
+  module WidgetShortcuts
+    class Ws
+      attr_reader :config
+      def initialize config={}
+        @config = config
+      end
+      def [](sym)
+        @config[sym]
+      end
+      def []=(sym, val)
+        @config[sym] = val
+      end
+    end
+    class WsStack < Ws; end
+    class WsFlow < Ws; end
+    def widget_shortcuts_init
+      @_ws_app_row = @_ws_app_col = 0
+      @_ws_active = []
+      @_ws_components = []
+      @variables = {}
+    end
+    def field config={}, &block 
+      w = Field.new nil, config #, &block
+      _position w
+      if block
+        w.bind(:CHANGED, &block)
+      end
+      return w
+    end
+    def label config={}, &block 
+      w = Label.new nil, config, &block
+      _position w
+    end
+    def blank
+      label :text => ""
+    end
+    def line config={}
+      #horizontal line TODO
+      #row = config[:row] || @app_row
+      #width = config[:width] || 20
+      #_position config
+      #col = config[:col] || 1
+      #@color_pair = config[:color_pair] || $datacolor
+      #@attrib = config[:attrib] || Ncurses::A_NORMAL
+      #@window.attron(Ncurses.COLOR_PAIR(@color_pair) | @attrib)
+      #@window.mvwhline( row, col, FFI::NCurses::ACS_HLINE, width)
+      #@window.attron(Ncurses.COLOR_PAIR(@color_pair) | @attrib)
+    end
+    def check config={}, &block
+      w = CheckBox.new nil, config #, &block
+      _position w
+      if block
+        w.bind(:PRESS, &block)
+      end
+      return w
+    end
+    def button config={}, &block
+      w = Button.new nil, config #, &block
+      _position w
+      if block
+        w.bind(:PRESS, &block)
+      end
+      return w
+    end
+    def radio config={}, &block
+      a = config[:group]
+      # should we not check for a nil
+      if @variables.has_key? a
+        v = @variables[a]
+      else
+        v = Variable.new
+        @variables[a] = v
+      end
+      config[:variable] = v
+      config.delete(:group)
+      w = RadioButton.new nil, config #, &block
+      _position w
+      if block
+        w.bind(:PRESS, &block)
+      end
+      return w
+    end
+    # editable text area
+    def textarea config={}, &block
+      require 'rbcurse/rtextarea'
+      # TODO confirm events many more
+      events = [ :CHANGE,  :LEAVE, :ENTER ]
+      block_event = events[0]
+      #_process_args args, config, block_event, events
+      #config[:width] = config[:display_length] unless config.has_key? :width
+      # if no width given, expand to flows width
+      #config[:width] ||= @stack.last.width if @stack.last
+      useform = nil
+      #useform = @form if @current_object.empty?
+      w = TextArea.new useform, config
+      w.width = :expand unless w.width
+      w.height ||= 8 # TODO
+      _position(w)
+      # need to expand to stack's width or flows itemwidth if given
+      if block
+        w.bind(block_event, &block)
+      end
+      return w
+    end
+    def textview config={}, &block
+      require 'rbcurse/rtextview'
+      events = [ :LEAVE, :ENTER ]
+      block_event = events[0]
+      #_process_args args, config, block_event, events
+      #config[:width] = config[:display_length] unless config.has_key? :width
+      # if no width given, expand to flows width
+      #config[:width] ||= @stack.last.width if @stack.last
+      useform = nil
+      #useform = @form if @current_object.empty?
+      w = TextView.new useform, config
+      w.width = :expand unless w.width
+      w.height ||= 8 # TODO
+      _position(w)
+      # need to expand to stack's width or flows itemwidth if given
+      if block
+        w.bind(block_event, &block)
+      end
+      return w
+    end
+    def _position w
+      cur = @_ws_active.last
+      # this is outside any stack or flow, so we do the minimal
+      # user should specify row and col
+      unless cur
+        w.row ||= 0
+        w.col ||= 0
+        $log.debug "XXX:  LABEL #{w.row} , #{w.col} "
+        w.set_form @form if @form # temporary,, only set if not inside an object FIXME
+        if w.width == :expand
+          w.width = FFI::NCurses.COLS-0 # or take windows width since this could be in a message box
+        end
+        if w.height == :expand
+          # take from current row, and not zero  FIXME
+          w.height = FFI::NCurses.LINES-0 # or take windows width since this could be in a message box
+        end
+        return
+      end
+      r = cur[:row] || 0
+      c = cur[:col] || 0
+      w.row = r
+      w.col = c
+      if cur.is_a? WsStack
+        r += w.height || 1
+        cur[:row] = r
+      else
+        wid = cur[:item_width] || w.width || 10
+        c += wid + 1
+        cur[:col] = c
+      end
+      if w.width == :expand
+        w.width = cur[:width] or raise "Width not known for stack"
+      end
+      if w.height == :expand
+        w.height = cur[:height] or raise "height not known for flow"
+      end
+      w.color   ||= cur[:color]
+      w.bgcolor ||= cur[:bgcolor]
+      w.set_form @form if @form # temporary
+      @_ws_components << w
+      cur[:components] << w
+    end
+    # make it as simple as possible, don't try to be intelligent or
+    # clever, put as much on the user 
+    def stack config={}, &block
+      s = WsStack.new config
+      _configure s
+      @_ws_active << s
+      yield_or_eval &block if block_given?
+      @_ws_active.pop 
+      
+      # ---- stack is finished now
+      last = @_ws_active.last
+      if last 
+        case last
+        when WsStack
+        when WsFlow
+          last[:col] += last[:item_width] || 0 
+          # this tries to set height of outer flow based on highest row
+          # printed, however that does not account for height of object,
+          # so user should give a height to the flow.
+          last[:height] = s[:row] if s[:row] > (last[:height]||0)
+          $log.debug "XXX: STACK setting col to #{s[:col]} "
+        end
+      end
+
+    end
+    #
+    # item_width - width to use per item 
+    #   but the item width may apply to stacks inside not to items
+    def flow config={}, &block
+      s = WsFlow.new config
+      _configure s
+      @_ws_active << s
+      yield_or_eval &block if block_given?
+      @_ws_active.pop 
+      last = @_ws_active.last
+      if last 
+        case last
+        when WsStack
+          if s[:height]
+            last[:row] += s[:height] 
+          else
+            #last[:row] += last[:highest_row]  
+            last[:row] += 1
+          end
+        when WsFlow
+          last[:col] += last[:item_width] || 0 
+        end
+      end
+    end
+    # flow and stack could have a border option
+    def box config={}, &block
+      require 'rbcurse/extras/box'
+      # take current stacks row and col
+      # advance row by one and col by one
+      # at end note row and advance by one
+      # draw a box around using these coordinates. width should be
+      # provided unless we have item width or something.
+      last = @_ws_active.last
+      if last
+        r = last[:row]
+        c = last[:col]
+        config[:row] = r
+        config[:col] = c
+        last[:row] += config[:margin_top] || 1
+        last[:col] += config[:margin_left] || 1
+        _box = Box.new @form, config # needs to be created first or will overwrite area after others painted
+        yield_or_eval &block if block_given?
+        h = config[:height] || last[:height] || (last[:row] - r)
+        h = 2 if h < 2
+        w = config[:width] || last[:width] || 15 # tmp
+        case last
+        when WsFlow
+          w = last[:col]
+        when WsStack
+          #h += 1
+        end
+        config[:row] = r
+        config[:col] = c
+        config[:height] = h
+        config[:width] = w
+        _box.row r
+        _box.col c
+        _box.height h
+        _box.width w
+        last[:row] += 1
+        last[:col] += 1 # ??? XXX if flow we need to increment properly or not ?
+      end
+    end
+    def _configure s
+      s[:row] ||= 0
+      s[:col] ||= 0
+      s[:row] += (s[:margin_top] || 0)
+      s[:col] += (s[:margin_left] || 0)
+      s[:width] = FFI::NCurses.COLS if s[:width] == :expand
+      last = @_ws_active.last
+      if last
+        if last.is_a? WsStack
+          s[:row] += (last[:row] || 0)
+          s[:col] += (last[:col] || 0)  
+        else
+          s[:row] += (last[:row] || 0)
+          s[:col] += (last[:col] || 0)  # we are updating with item_width as each st finishes
+          s[:width] ||= last[:item_width] # 
+        end
+      end
+      s[:components] = []
+    end
+
+
+
+  end
+end