rbcurse 1.4.0 → 1.4.1.pre2

data/lib/rbcurse/applicationheader.rb

@@ -1,5 +1,21 @@
+# ----------------------------------------------------------------------------- #
+#         File: applicationheader.rb
+#  Description: Prints a header on first row, with right, left and centered text
+#               NOTE: on some terminal such as xterm-256color spaces do not print
+#               so you will see black or empty spaces between text.
+#               This does not happen on screen and xterm-color.
+#       Author: rkumar http://github.com/rkumar/rbcurse/
+#         Date: 
+#      License: Same as Ruby's License (http://www.ruby-lang.org/LICENSE.txt)
+#  Last update: 2011-11-16 - 00:07
+#
+#  CHANGES:
+#              For some terminals, like xterm-256color which were not printing spaces
+#              I've changed to code so only text is printed where it has to with no
+#              padding. These terminals remove the padding color.
+# ----------------------------------------------------------------------------- #
+#
 require 'rbcurse/rwidget'
-#include Ncurses # FFI 2011-09-8 
 include RubyCurses
 module RubyCurses
   class ApplicationHeader < Widget
@@ -39,20 +55,44 @@ module RubyCurses
       return unless @repaint_required
  
       #print_header(htext, posy = 0, posx = 0)
-      print_header(@text1 + " %15s " % @text2 + " %20s" % @text_center , posy=0, posx=0)
+      att = get_attrib @attr
+      len = @window.width
+      len = Ncurses.COLS-0 if len == 0
+      # print a bar across the screen 
+      @window.attron(Ncurses.COLOR_PAIR(@color_pair) | att)
+      @window.mvhline(@row, @col, 1, len)
+      @window.attroff(Ncurses.COLOR_PAIR(@color_pair) | att)
+      #print_header(@text1 + " %15s " % @text2 + " %20s" % @text_center , posy=0, posx=0)
+
+      # Now print the text in the correct positions with no padding, else some terminal
+      # will blacken the text out.
+      print_header("#{@text1}  #{@text2}") # + " %20s" % @text_center , posy=0, posx=0)
+      print_center("#{@text_center}") # + " %20s" % @text_center , posy=0, posx=0)
       print_top_right(@text_right)
       @repaint_required = false
     end
     def print_header(htext, r = 0, c = 0)
-    $log.debug " def print_header(#{htext}, posy = 0, posx = 0)"
+      #win = @window
+      #len = @window.width
+      #len = Ncurses.COLS-0 if len == 0
+      #
+      #@form.window.printstring r, c, "%-*s" % [len, htext], @color_pair, @attr
+      @form.window.printstring r, c, htext, @color_pair, @attr
+    end
+    def print_center(htext, r = 0, c = 0)
       win = @window
-      len = Ncurses.COLS-0
-      @form.window.printstring r, c, "%-*s" % [len, htext], @color_pair, @attr
+      len = win.width
+      len = Ncurses.COLS-0 if len == 0
+      #
+      #@form.window.printstring r, c, "%-*s" % [len, htext], @color_pair, @attr
+      win.printstring r, ((len-htext.length)/2).floor, htext, @color_pair, @attr
     end
     def print_top_right(htext)
     $log.debug " def print_top_right(#{htext})"
       hlen = htext.length
-      len = Ncurses.COLS-1
+      len = Ncurses.COLS-0
+      len = @window.width
+      len = Ncurses.COLS-0 if len == 0
       @form.window.printstring 0, len-hlen, htext, @color_pair, @attr
     end
     ##

data/lib/rbcurse/celleditor.rb

@@ -1,8 +1,3 @@
-require 'rubygems'
-#require 'ncurses'
-require 'logger'
-#require 'lib/rbcurse/rwidget'
-
 
 ##
 # This file gives us a mean of using a component as an editor in a list or later table.
@@ -23,7 +18,6 @@ module RubyCurses
       s = @component.class.to_s.downcase()
       s.slice!("rubycurses::")
       @_class = s.to_sym
-      #$log.debug " CELL EIDOTR got #{@_class}"
       config_setup config # @config.each_pair { |k,v| variable_set(k,v) }
       instance_eval &block if block_given?
     end
@@ -75,7 +69,6 @@ module RubyCurses
       f = @component
       f.on_leave
       if f.respond_to? :editable and f.modified?
-        $log.debug " Table about to fire CHANGED for #{f} "
         f.fire_handler(:CHANGED, f) 
       end
     end
@@ -97,13 +90,12 @@ module RubyCurses
       widget.visible = true
       widget.form = parent.form
       #$log.debug " prepare editor value #{widget.display_length} displlen #{widget.maxlen}"
-      $log.debug " prepare editor form: #{widget.form} "
+      #$log.debug " prepare editor form: #{widget.form} " # 2011-11-15 12:54:41
       #widget.display_length = widget.display_length -1
       widget.bgcolor = 'yellow'
       widget.color = 'black'
       widget.on_enter
       #widget.attr = Ncurses::A_REVERSE | Ncurses::A_BOLD
-      #$log.debug " prepare editor value #{value} : fr:#{row}, fc:#{col}"
     end
     #This may not really be necessary since we paint the cell editor only if editing is on
     def cancel_editor

data/lib/rbcurse/comboboxcellrenderer.rb

@@ -1,7 +1,3 @@
-require 'rubygems'
-#require 'ncurses'
-require 'logger'
-#require 'lib/rbcurse/rwidget'
 module RubyCurses
 
   ## 

data/lib/rbcurse/common/ansiparser.rb

@@ -0,0 +1,117 @@
+# ----------------------------------------------------------------------------- #
+#         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 AnsiParser
+
+  # 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       = s.split /(\x1b\[\d*(?:;\d+)*?[a-zA-Z])/
+    a.each { |e| 
+      ## process color or attrib portion
+      #[ "", "\e[1m", "", "\e[34m", "", "\e[47m", "Showing all items...", "\e[0m", "", "\e[0m", "\n"]
+      if e[0] == "\x1b" && e[-1] == "m"
+
+        #e.each { |f|  x=/^.\[(.*).$/.match(f) 
+          $log.debug "XXX: ANSI e #{e} "
+          x=/^.\[(.*).$/.match(e) 
+          color, bgcolor, attrib = nil, nil, nil
+          $log.debug "XXX: ANSI #{x} ..... #{x[1]}  "
+          args = x[1].split ';'
+          ## first split on commas to separate fg, bg and attr
+          # http://ascii-table.com/ansi-escape-sequences.php
+          args.each { |att|  
+            $log.debug "XXX: ANSI att: #{att}   "
+            case att.to_i
+            when 0
+              color, bgcolor, attrib = nil, nil, nil
+              yield :reset # actually this resets all so we need an endall or clearall reset
+
+            when 1
+              attrib = 'bold'
+            when 2
+              attrib = 'dim'
+            when 4
+              attrib = 'underline'
+            when 5
+              attrib = 'blink'
+            when 7
+              attrib = 'reverse'
+            when 8
+              attrib = 'hidden' # XXX
+            when 30 
+              color = 'black'
+            when 31  
+              color = 'red'
+            when 32  
+              color = 'green'
+            when 33  
+              color = 'yellow'
+            when 34  
+              color = 'blue'
+            when 35  
+              color = 'magenta'
+            when 36  
+              color = 'cyan'
+            when 37  
+              color = 'white'
+
+              #Background colors
+            when 40  
+              bgcolor = 'black'
+            when 41  
+              bgcolor = 'red'
+            when 42  
+              bgcolor = 'green'
+            when 43  
+              bgcolor = 'yellow'
+            when 44  
+              bgcolor = 'blue'
+            when 45  
+              bgcolor = 'magenta'
+            when 46  
+              bgcolor = 'cyan'
+            when 47  
+              bgcolor = 'white'
+            else
+              $log.warn "XXX: WARN ANSI not used #{att} "
+            end
+          } # args.ea
+        #} # e.each
+          $log.debug "XXX:  ANSI YIELDING #{color} , #{bgcolor} , #{attrib} "
+        yield [color,bgcolor,attrib] if block_given?
+      else
+        text = e
+        yield text if block_given?
+      end
+    } # a.each
+  end
+
+end

data/{examples → lib/rbcurse/common}/appmethods.rb

@@ -1,5 +1,6 @@
 module RubyCurses
   module Utils
+    private
     def _suspend clear=true
       return unless block_given?
       Ncurses.def_prog_mode
@@ -22,6 +23,11 @@ module RubyCurses
       @window.wrefresh if @window
       Ncurses::Panel.update_panels
     end
+    #
+    # Suspends to shell so user can execute commands.
+    # Maybe not be able to get your prompt correctly.
+    # 
+    public
     def suspend
       _suspend(false) do
         system("tput cup 26 0")
@@ -32,6 +38,10 @@ module RubyCurses
       end
     end
 
+    #
+    # Displays application help using either array provided
+    # or checking for :help_text method
+    # @param [Array] help text
     def display_app_help help_array= nil
       if help_array
         arr = help_array
@@ -64,12 +74,19 @@ module RubyCurses
       t.attr = :reverse
       end
     end
+    #
+    # prompts user for unix command and displays output in viewer
+    # 
     def shell_output
       cmd = get_string("Enter shell command:", 50)
       if cmd && !cmd.empty?
         run_command cmd
       end
     end
+
+    #
+    # executes given command and displays in viewer
+    # @param [String] unix command, e.g., git -st
     def run_command cmd
       # http://whynotwiki.com/Ruby_/_Process_management#What_happens_to_standard_error_.28stderr.29.3F
       require 'rbcurse/extras/viewer'
@@ -82,6 +99,14 @@ module RubyCurses
       res.gsub!("\t","   ")
       RubyCurses::Viewer.view(res.split("\n"), :close_key => KEY_RETURN, :title => "<Enter> to close, M-l M-h to scroll")
     end
+    def shell_out command
+      @window.hide
+      Ncurses.endwin
+      system command
+      Ncurses.refresh
+      #Ncurses.curs_set 0  # why ?
+      @window.show
+    end
   end # utils
 end # module RubyC
 include RubyCurses::Utils

data/lib/rbcurse/common/basestack.rb

@@ -0,0 +1,407 @@
+# 
+# Common stack flow functionality
+# * Name: basestack.rb
+# * Description: Classes that allow user to stack and flow components
+#
+# * Date: 30.10.11 - 12:57
+# * Last update: 30.10.11 - 12:57
+#
+module RubyCurses
+  module ModStack
+    #
+    # Base class for stacks and flows.
+    # Will manage determining row col and width height of objects
+    # Stacks place objects one below another. Flows place objects to the
+    # right of the previous. Orientation can be reversed.
+    #
+  class BaseStack
+    attr_accessor :components
+    attr_reader :config
+    attr_accessor :form
+    def initialize config={}, components=[]
+      @config = config
+      config.each do |k, v|
+        instance_variable_set "@#{k}", v
+      end
+      @components = components
+      @calc_needed = true
+    end
+    # XXX if user sets later, we won't be checking the config
+    # We check the actual variables which config sets in init
+    %w[ parent_component width height weight row col orientation].each { |e|
+      eval(
+           "def #{e} 
+              @config[:#{e}]
+            end
+            def #{e}=(val) 
+              @config[:#{e}]=val
+              instance_variable_set \"@#{e}\", val
+              @calc_needed = true
+            end"
+          )
+    }
+    alias :parent :parent_component
+    #alias :parent= :parent_component
+    def repaint # stack
+      $log.debug "XXX: stack repaint recalc #{@calc_needed} "
+      @components.each { |e| e.form = @form unless e.form } #unless @calc_needed
+      recalc if @calc_needed
+      @components.each { |e| e.repaint }
+    end
+    def repaint_all x
+      @calc_needed = true
+    end
+    def override_graphic gr
+      @graphic = gr
+    end
+    def focusable; false; end
+    # Calculates row col and width height
+    # for each subc-omponent based on coords of Container
+    # This is to be called only when the container has got its coordinates (i.e
+    # Containers repaint). This should be in this objects repaint.
+    def recalc
+      @calc_needed = false
+      comp = self
+      if comp.is_a? BaseStack
+        check_coords comp
+        @margin_left   ||= 0
+        @margin_right  ||= 0
+        @margin_top    ||= 0
+        @margin_bottom ||= 0
+        if comp.is_a? Stack
+          r   = row + @margin_top
+          rem = 0
+          ht = height - (@margin_top + @margin_bottom)
+          if @orientation == :bottom 
+            mult = -1
+            comps = @components.reverse
+            r = row + height - @margin_bottom
+    
+          else
+            mult = 1
+            comps = @components
+   
+          end
+          comps.each { |e| 
+            # should only happen if expandable FIXME
+            e.height = 0.01 * e.weight * (ht - (e.margin_top + e.margin_bottom)) 
+            hround = e.height.floor
+            rem += e.height - hround
+            e.height = hround #- (@margin_top + @margin_bottom)
+            # rounding creates a problem, since 0.5 gets rounded up and we can exceed bound
+            # So i floor, and maintain the lost space, and add it back when it exceeds 1
+            # This way the last components gets stretched to meet the end, which is required
+            # when the height of the stack is odd and there's a left-over row
+            if rem >= 1
+              e.height += 1
+              rem = 0
+            end
+            # Item level margins have not been accounted for when calculating weightages, and
+            # should not be used on the weightage axis
+            r += e.margin_top
+            if @orientation == :bottom
+              r += e.height * mult
+              e.row = r 
+            else
+              e.row = r 
+              r += e.height + 0
+            end
+            e.width = width - (@margin_left + @margin_right + e.margin_left + e.margin_right)
+            e.col = col + @margin_left + e.margin_left # ??? XXX
+            $log.debug "XXX: recalc stack #{e.widget.class} r:#{e.row} c:#{e.col} h:#{e.height} = we:#{e.weight} * h:#{height} "
+            #e.col_offset = col_offset # ??? XXX
+            check_coords e
+            e.repaint_all(true)
+            e.recalc if e.is_a? BaseStack
+          }
+        elsif comp.is_a? Flow
+          c = col + @margin_left #+ col_offset
+          rem = 0
+          wd = width - (@margin_left + @margin_right)
+          # right_to_left orientation
+          if @orientation == :right
+            mult = -1
+            comps = @components.reverse
+            c = col + width - @margin_right
+            $log.debug "XXX:  ORIENT1f recalc #{@orientation} "
+          else
+            mult = 1
+            comps = @components
+            $log.debug "XXX:  ORIENT2f recalc #{@orientation} "
+          end
+          comps.each { |e| 
+            e.width = e.weight * wd  * 0.01
+            wround = e.width.floor
+            rem += e.width - wround
+            e.width = wround
+            # see comment in prev block regarding remaininder
+            if rem >= 1
+              e.width += 1
+              rem = 0
+            end
+            e.height = height - (@margin_top + @margin_bottom) #* weight * 0.01
+            #e.height = e.height.round
+            if @orientation == :right
+              c += e.width * mult # mult 1 or -1
+              e.col = c
+            else
+              e.col = c
+              c += e.width * mult # mult 1 or -1
+            end
+            e.row = row + @margin_top
+            check_coords e
+            $log.debug "XXX: recalc flow #{e.widget.class} r:#{e.row} c:#{e.col} h:#{e.height} = we:#{e.weight} * w:#{width} "
+            e.repaint_all(true)   # why not happening when we change row, hieght etc
+            e.recalc if e.is_a? BaseStack
+          }
+        end
+      else
+        alert "in else recalc DOES NOT COME HERE "
+        comp.col    = comp.parent.col
+        comp.row    = comp.parent.row
+        comp.height = comp.parent.height
+        comp.width  = comp.parent.width
+        $log.debug "XXX: recalc else #{comp.class} r #{comp.row} c #{comp.col} . h #{comp} height w #{comp.width} "
+      end
+    end
+    # Traverses the comopnent tree and calculates weightages for all components
+    # based on what has been specified by user
+    def check_coords e # stack
+      r = e.row
+      c = e.col
+      if r >= row + height
+        $log.warn "XXX: WARN e.class is out of bounds row #{r} "
+        e.visible = false
+      end
+      if c >= col + width
+        $log.warn "XXX: WARN e.class is out of bounds col #{c} "
+        e.visible = false
+      end
+    end
+    def increase c=@current_component
+      p = self #c.parent_component
+      ci = p.components.index(c)
+      ni = ci + 1
+      if p.components[ni].nil?
+        ni = nil
+      end
+      case p
+      when Flow
+        # increase width of current and reduce from neighbor
+        if ni
+          n = p.components[ni]
+          $log.debug "XXX: INC fl current #{ci}, total#{p.components.count}, next #{n} "
+
+          c.width += 1
+          n.width -= 1
+          n.col   += 1
+        end
+
+      when Stack
+        if ni
+          n = p.components[ni]
+          $log.debug "XXX: INC fl current #{ci}, total#{p.components.count}, next #{n} "
+
+          c.height += 1
+          n.height -= 1
+          n.row   += 1
+        end
+        $log.debug "XXX: INC st current #{ci}, total#{p.components.count} "
+      end
+
+    end
+    def decrease c=@current_component
+      p = self #c.parent_component
+      ci = p.components.index(c)
+      ni = ci + 1
+      if p.components[ni].nil?
+        ni = nil
+      end
+      case p
+      when Flow
+        # increase width of current and reduce from neighbor
+        if ni
+          n = p.components[ni]
+          $log.debug "XXX: INC fl current #{ci}, total#{p.components.count}, next #{n} "
+
+          c.width -= 1
+          n.width += 1
+          n.col   -= 1
+        end
+
+      when Stack
+        if ni
+          n = p.components[ni]
+          $log.debug "XXX: INC fl current #{ci}, total#{p.components.count}, next #{n} "
+
+          c.height -= 1
+          n.height += 1
+          n.row   -= 1
+        end
+        $log.debug "XXX: INC st current #{ci}, total#{p.components.count} "
+      end
+
+    end
+    def to_s
+      @components
+    end
+  end # class Base
+  # A stack positions objects one below the other
+  class Stack < BaseStack; end
+  # A flow positions objects in a left to right
+  class Flow  < BaseStack; end
+  #
+  # A wrapper over widget mostly because it adds weight and margins
+  #
+  class Item
+    attr_reader :config, :widget
+    attr_reader :margin_top, :margin_left, :margin_bottom, :margin_right
+    def initialize config={}, widget
+      @config = config
+      config.each do |k, v|
+        instance_variable_set "@#{k}", v
+      end
+      @margin_left   ||= 0
+      @margin_right  ||= 0
+      @margin_top    ||= 0
+      @margin_bottom ||= 0
+      @widget = widget
+    end
+    def weight;  @config[:weight]||100; end
+    def weight=(val); @config[:weight]=val; end
+    def repaint; @widget.repaint; end
+    %w[ form parent parent_component width height row col row_offset col_offset focusable].each { |e|
+      eval(
+           "def #{e} 
+              @widget.#{e} 
+            end
+            def #{e}=(val) 
+              @widget.#{e}=val 
+            end"
+          )
+    }
+    def method_missing(sym, *args, &block)
+      @widget.send sym, *args, &block
+    end
+  end # class Item
+
+  # --------------------- module level ------------------------------#
+    # General routin to traverse components and their components
+    def traverse c, &block
+      if c.is_a? BaseStack
+        yield c
+        c.components.each { |e| 
+          yield e
+        }
+        c.components.each { |e| traverse(e, &block)  }
+        @ctr -= 1
+      else
+      end
+    end
+
+    # traverse the components and their children
+    #
+    def each &block
+      @components.each { |e| traverse e, &block }
+    end
+    # module level
+    private
+    def _stack type, config={}, &block
+      case type
+      when :stack
+        s = Stack.new(config)
+      when :flow
+        s = Flow.new(config)
+      end
+      _add s
+      @active << s
+      yield_or_eval &block if block_given? 
+      @active.pop
+      # if active is empty then this is where we could calculate
+      # percentatges and do recalc, thus making it independent
+    end
+    # module level
+    private
+    private
+    def _add s
+      if @active.empty?
+        $log.debug "XXX:  ADDING TO components #{s} "
+        unless s.is_a? BaseStack
+          raise "No stack or flow to add to. Results may not be what you want"
+        end
+        @components << s
+      else
+        @active.last.components << s
+      end
+      __add s
+    end
+
+    # module level
+    private
+    public
+    def stack config={}, &block
+      _stack :stack, config, &block
+    end
+    def flow config={}, &block
+      _stack :flow, config, &block
+    end
+    # module level
+    private
+    def add w, config={}
+      i = Item.new config, w
+      _add i
+    end
+    alias :add_widget :add
+    # module level
+    private
+    def calc_weightages2 components, parent
+        #puts " #{@ctr} --> #{c.type}, wt: #{c.config[:weight]} "
+        @ctr += 1
+        wt  = 0
+        cnt = 0
+        sz = components.count
+        $log.debug "XXX: calc COMP COUNT #{sz} "
+        # calculate how much weightage has been given by user
+        # so we can allocate average to other components
+        components.each { |e| 
+          if e.config[:weight]  
+            wt += e.config[:weight]
+            cnt += 1
+          end
+          $log.debug "XXX: INC setting parent #{parent} to #{e} "
+          e.config[:parent] = parent
+          e.config[:level] = @ctr
+        }
+        used = sz - cnt
+        $log.debug "XXX: ADDING calc COMP COUNT #{sz} - #{cnt} "
+        if used > 0
+          avg = (100-wt)/used
+          # Allocate average to other components
+          components.each { |e| e.config[:weight] = avg unless e.config[:weight]  }
+        end
+        components.each { |e| calc_weightages2(e.components, e) if e.respond_to? :components  }
+        @ctr -= 1
+    end
+    # module level
+    private
+    # given an widget, return the item, so we can change weight or some other config
+    def item_for widget
+      each do |e|
+        if e.is_a? Item
+          if e.widget == widget
+            return e
+          end
+        end
+      end
+      return nil
+    end
+    # module level
+    # returns the parent (flow or stack) for a given widget
+    #  allowing user to change configuration such as weight
+    def parent_of widget
+      f = item_for widget
+      return f.config[:parent] if f
+      return nil
+    end
+  end # mod modstack
+end # mod