rbcurse-experimental 0.0.1 → 0.0.2

data/CHANGELOG

@@ -0,0 +1,3 @@
+ 2013-04-12 - 13:06 
+   Added tablewidget which will very soon move to core, as soon as I figure
+   out how to go about this.

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/lib/rbcurse/experimental/widgets/tablewidget.rb

@@ -0,0 +1,843 @@
+#!/usr/bin/env ruby
+# ----------------------------------------------------------------------------- #
+#         File: tablewidget.rb
+#  Description: A tabular widget based on textpad
+#       Author: rkumar http://github.com/rkumar/rbcurse/
+#         Date: 2013-03-29 - 20:07
+#      License: Same as Ruby's License (http://www.ruby-lang.org/LICENSE.txt)
+#  Last update: 2013-04-12 13:04
+# ----------------------------------------------------------------------------- #
+#   tablewidget.rb  Copyright (C) 2012-2013 rahul kumar
+
+require 'logger'
+require 'rbcurse'
+require 'rbcurse/core/widgets/textpad'
+
+## 
+# The motivation to create yet another table widget is because tabular_widget
+# is based on textview etc which have a lot of complex processing and rendering
+# whereas textpad is quite simple. It is easy to just add one's own renderer
+# making the code base simpler to understand and maintain.
+# TODO
+#   _ compare to tabular_widget and see what's missing
+#   _ filtering rows without losing data
+#   . selection stuff
+#   x test with resultset from sqlite to see if we can use Array or need to make model
+#     should we use a datamodel so resultsets can be sent in, what about tabular
+#   _ header to handle events ?
+#
+#
+module RubyCurses
+  # column data, one instance for each column
+  # index is the index in the data of this column. This index will not change.
+  # Order of printing columns is determined by the ordering of the objects.
+  class ColumnInfo < Struct.new(:name, :index, :offset, :width, :align, :hidden, :attrib, :color, :bgcolor)
+  end
+  # a structure that maintains position and gives
+  # next and previous taking max index into account.
+  # it also circles. Can be used for traversing next component
+  # in a form, or container, or columns in a table.
+  class Circular < Struct.new(:max_index, :current_index)
+    attr_reader :last_index
+    attr_reader :current_index
+    def initialize  m, c=0
+      raise "max index cannot be nil" unless m
+      @max_index = m
+      @current_index = c
+      @last_index = c
+    end
+    def next
+      @last_index = @current_index
+      if @current_index + 1 > @max_index
+        @current_index = 0
+      else
+        @current_index += 1
+      end
+    end
+    def previous
+      @last_index = @current_index
+      if @current_index - 1 < 0
+        @current_index = @max_index
+      else
+        @current_index -= 1
+      end
+    end
+    def is_last?
+      @current_index == @max_index
+    end
+  end
+
+    # This is our default table row sorter.
+    # It does a multiple sort and allows for reverse sort also.
+    # It's a pretty simple sorter and uses sort, not sort_by.
+    # Improvements welcome.
+    # Usage: provide model in constructor or using model method
+    # Call toggle_sort_order(column_index) 
+    # Call sort. 
+    # Currently, this sorts the provided model in-place. Future versions
+    # may maintain a copy, or use a table that provides a mapping of model to result.
+    # # TODO check if column_sortable
+    class DefaultTableRowSorter
+      attr_reader :sort_keys
+      # model is array of data
+      def initialize data_model=nil
+        self.model = data_model
+        @columns_sort = []
+        @sort_keys = nil
+      end
+      def model=(model)
+        @model = model
+        @sort_keys = nil
+      end
+      def sortable colindex, tf
+        @columns_sort[colindex] = tf
+      end
+      def sortable? colindex
+        return false if @columns_sort[colindex]==false
+        return true
+      end
+      # should to_s be used for this column
+      def use_to_s colindex
+        return true # TODO
+      end
+      # sorts the model based on sort keys and reverse flags
+      # @sort_keys contains indices to sort on
+      # @reverse_flags is an array of booleans, true for reverse, nil or false for ascending
+      def sort
+        return unless @model
+        return if @sort_keys.empty?
+        $log.debug "TABULAR SORT KEYS #{sort_keys} "
+        # first row is the header which should remain in place
+        # We could have kept column headers separate, but then too much of mucking around
+        # with textpad, this way we avoid touching it
+        header = @model.delete_at 0
+        begin
+          # next line often can give error "array within array" - i think on date fields that 
+          #  contain nils
+        @model.sort!{|x,y| 
+          res = 0
+          @sort_keys.each { |ee| 
+            e = ee.abs-1 # since we had offsetted by 1 earlier
+            abse = e.abs
+            if ee < 0
+              res = y[abse] <=> x[abse]
+            else
+              res = x[e] <=> y[e]
+            end
+            break if res != 0
+          }
+          res
+        }
+        ensure
+          @model.insert 0, header if header
+        end
+      end
+      # toggle the sort order if given column offset is primary sort key
+      # Otherwise, insert as primary sort key, ascending.
+      def toggle_sort_order index
+        index += 1 # increase by 1, since 0 won't multiple by -1
+        # internally, reverse sort is maintained by multiplying number by -1
+        @sort_keys ||= []
+        if @sort_keys.first && index == @sort_keys.first.abs
+          @sort_keys[0] *= -1 
+        else
+          @sort_keys.delete index # in case its already there
+          @sort_keys.delete(index*-1) # in case its already there
+          @sort_keys.unshift index
+          # don't let it go on increasing
+          if @sort_keys.size > 3
+            @sort_keys.pop
+          end
+        end
+      end
+      def set_sort_keys list
+        @sort_keys = list
+      end
+    end #class
+  #
+  # TODO see how jtable does the renderers and columns stuff.
+  #
+  # perhaps we can combine the two but have different methods or some flag
+  # that way oter methods can be shared
+  class DefaultTableRenderer
+
+    # source is the textpad or extending widget needed so we can call show_colored_chunks
+    # if the user specifies column wise colors
+    def initialize source
+      @source = source
+      @y = '|'
+      @x = '+'
+      @coffsets = []
+      @header_color = :red
+      @header_bgcolor = :white
+      @header_attrib = NORMAL
+      @color = :white
+      @bgcolor = :black
+      @color_pair = $datacolor
+      @attrib = NORMAL
+      @_check_coloring = nil
+    end
+    def header_colors fg, bg
+      @header_color = fg
+      @header_bgcolor = bg
+    end
+    def header_attrib att
+      @header_attrib = att
+    end
+    # set fg and bg color of content rows, default is $datacolor (white on black).
+    def content_colors fg, bg
+      @color = fg
+      @bgcolor = bg
+      @color_pair = get_color($datacolor, fg, bg)
+    end
+    def content_attrib att
+      @attrib = att
+    end
+    def column_model c
+      @chash = c
+    end
+    ##
+    # Takes the array of row data and formats it using column widths
+    # and returns a string which is used for printing
+    #
+    # TODO return an array so caller can color columns if need be
+    def convert_value_to_text r  
+      str = []
+      fmt = nil
+      field = nil
+      # we need to loop through chash and get index from it and get that row from r
+      #r.each_with_index { |e, i| 
+        #c = @chash[i]
+      #@chash.each_with_index { |c, i| 
+        #next if c.hidden
+      each_column {|c,i|
+        e = r[c.index]
+        w = c.width
+        l = e.to_s.length
+        # if value is longer than width, then truncate it
+        if l > w
+          fmt = "%.#{w}s "
+        else
+          case c.align
+          when :right
+            fmt = "%#{w}s "
+          else
+            fmt = "%-#{w}s "
+          end
+        end
+        field = fmt % e
+        # if we really want to print a single column with color, we need to print here itself
+        # each cell. If we want the user to use tmux formatting in the column itself ...
+        # FIXME - this must not be done for headers.
+        #if c.color
+          #field = "#[fg=#{c.color}]#{field}#[/end]"
+        #end
+        str << field
+      }
+      return str
+    end
+    #
+    # @param pad for calling print methods on
+    # @param lineno the line number on the pad to print on
+    # @param text data to print
+    def render pad, lineno, str
+      #lineno += 1 # header_adjustment
+      return render_header pad, lineno, 0, str if lineno == 0
+      #text = str.join " | "
+      #text = @fmstr % str
+      text = convert_value_to_text str
+      if @_check_coloring
+        $log.debug "XXX:  INSIDE COLORIIN"
+        text = colorize pad, lineno, text
+        return
+      end
+      # check if any specific colors , if so then print colors in a loop with no dependence on colored chunks
+      # then we don't need source pointer
+      text = text.join
+      $log.debug "XXX:  NOTINSIDE COLORIIN"
+      #if text.index "#["
+        #require 'rbcurse/core/include/chunk'
+        #@parser ||= Chunks::ColorParser.new :tmux
+        #text = @parser.convert_to_chunk text
+        #FFI::NCurses.wmove pad, lineno, 0
+        #@source.show_colored_chunks text, nil, nil
+        #return
+      #end
+      # FIXME why repeatedly getting this colorpair
+      cp = @color_pair
+      att = @attrib
+      FFI::NCurses.wattron(pad,FFI::NCurses.COLOR_PAIR(cp) | att)
+      FFI::NCurses.mvwaddstr(pad, lineno, 0, text)
+      FFI::NCurses.wattroff(pad,FFI::NCurses.COLOR_PAIR(cp) | att)
+
+    end
+    def render_header pad, lineno, col, columns
+      # I could do it once only but if user sets colors midway we can check once whenvever
+      # repainting
+      check_colors #if @_check_coloring.nil?
+      #text = columns.join " | "
+      #text = @fmstr % columns
+      text = convert_value_to_text columns
+      text = text.join
+      bg = @header_bgcolor
+      fg = @header_color
+      att = @header_attrib
+      #cp = $datacolor
+      cp = get_color($datacolor, fg, bg)
+      FFI::NCurses.wattron(pad,FFI::NCurses.COLOR_PAIR(cp) | att)
+      FFI::NCurses.mvwaddstr(pad, lineno, col, text)
+      FFI::NCurses.wattroff(pad,FFI::NCurses.COLOR_PAIR(cp) | att)
+    end
+    # check if we need to individually color columns or we can do the entire
+    # row in one shot
+    def check_colors
+      each_column {|c,i|
+      #@chash.each_with_index { |c, i| 
+        #next if c.hidden
+        if c.color || c.bgcolor || c.attrib
+          @_check_coloring = true
+          return
+        end
+        @_check_coloring = false
+      }
+    end
+    def each_column
+      @chash.each_with_index { |c, i| 
+        next if c.hidden
+        yield c,i if block_given?
+      }
+    end
+  def colorize pad, lineno, r
+    # the incoming data is already in the order of display based on chash,
+    # so we cannot run chash on it again, so how do we get the color info
+    _offset = 0
+    # we need to get coffsets here FIXME
+    #@chash.each_with_index { |c, i| 
+      #next if c.hidden
+    each_column {|c,i|
+      text = r[i]
+      color = c.color
+      bg = c.bgcolor
+      if color || bg
+        cp = get_color(@color_pair, color || @color, bg || @bgcolor)
+      else
+        cp = @color_pair
+      end
+      att = c.attrib || @attrib
+      FFI::NCurses.wattron(pad,FFI::NCurses.COLOR_PAIR(cp) | att)
+      FFI::NCurses.mvwaddstr(pad, lineno, _offset, text)
+      FFI::NCurses.wattroff(pad,FFI::NCurses.COLOR_PAIR(cp) | att)
+      _offset += text.length
+    }
+  end
+  end
+
+  # If we make a pad of the whole thing then the columns will also go out when scrolling
+  # So then there's no point storing columns separately. Might as well keep in content
+  # so scrolling works fine, otherwise textpad will have issues scrolling.
+  # Making a pad of the content but not column header complicates stuff,
+  # do we make a pad of that, or print it like the old thing.
+  class TableWidget < TextPad
+
+    dsl_accessor :print_footer
+    attr_reader :columns
+    attr_accessor :table_row_sorter
+
+    def initialize form = nil, config={}, &block
+
+      # hash of column info objects, for some reason a hash and not an array
+      @chash = []
+      # chash should be an array which is basically the order of rows to be printed
+      #  it contains index, which is the offset of the row in the data @content
+      #  When printing we should loop through chash and get the index in data
+      #
+      # should be zero here, but then we won't get textpad correct
+      @_header_adjustment = 0 #1
+      @col_min_width = 3
+
+      super
+      bind_key(?w, "next column") { self.next_column }
+      bind_key(?b, "prev column") { self.prev_column }
+      bind_key(?-, "contract column") { self.contract_column }
+      bind_key(?+, "expand column") { self.expand_column }
+      bind_key(?=, "expand column to width") { self.expand_column_to_width }
+      bind_key(?\M-=, "expand column to width") { self.expand_column_to_max_width }
+    end
+    
+    # retrieve the column info structure for the given offset. The offset
+    # pertains to the visible offset not actual offset in data model. 
+    # These two differ when we move a column.
+    # @return ColumnInfo object containing width align color bgcolor attrib hidden
+    def get_column index
+      return @chash[index] if @chash[index]
+      # create a new entry since none present
+      c = ColumnInfo.new
+      c.index = index
+      @chash[index] = c
+      return c
+    end
+    ## 
+    # returns collection of ColumnInfo objects
+    def column_model
+      @chash
+    end
+
+    # calculate pad width based on widths of columns
+    def content_cols
+      total = 0
+      #@chash.each_pair { |i, c| 
+      #@chash.each_with_index { |c, i| 
+        #next if c.hidden
+      each_column {|c,i|
+        w = c.width
+        # if you use prepare_format then use w+2 due to separator symbol
+        total += w + 1
+      }
+      return total
+    end
+
+    # 
+    # This calculates and stores the offset at which each column starts.
+    # Used when going to next column or doing a find for a string in the table.
+    # TODO store this inside the hash so it's not calculated again in renderer
+    #
+    def _calculate_column_offsets
+      @coffsets = []
+      total = 0
+
+      #@chash.each_pair { |i, c| 
+      #@chash.each_with_index { |c, i| 
+        #next if c.hidden
+      each_column {|c,i|
+        w = c.width
+        @coffsets[i] = total
+        c.offset = total
+        # if you use prepare_format then use w+2 due to separator symbol
+        total += w + 1
+      }
+    end
+    # Convert current cursor position to a table column
+    # calculate column based on curpos since user may not have
+    # user w and b keys (:next_column)
+    # @return [Fixnum] column index base 0
+    def _convert_curpos_to_column  #:nodoc:
+      _calculate_column_offsets unless @coffsets
+      x = 0
+      @coffsets.each_with_index { |i, ix| 
+        if @curpos < i 
+          break
+        else 
+          x += 1
+        end
+      }
+      x -= 1 # since we start offsets with 0, so first auto becoming 1
+      return x
+    end
+    # jump cursor to next column
+    # TODO : if cursor goes out of view, then pad should scroll right or left and down
+    def next_column
+      # TODO take care of multipliers
+      _calculate_column_offsets unless @coffsets
+      c = @column_pointer.next
+      cp = @coffsets[c] 
+      #$log.debug " next_column #{c} , #{cp} "
+      @curpos = cp if cp
+      down() if c < @column_pointer.last_index
+    end
+    # jump cursor to previous column
+    # TODO : if cursor goes out of view, then pad should scroll right or left and down
+    def prev_column
+      # TODO take care of multipliers
+      _calculate_column_offsets unless @coffsets
+      c = @column_pointer.previous
+      cp = @coffsets[c] 
+      #$log.debug " prev #{c} , #{cp} "
+      @curpos = cp if cp
+      up() if c > @column_pointer.last_index
+    end
+    def expand_column
+      x = _convert_curpos_to_column
+      w = get_column(x).width
+      column_width x, w+1 if w
+      @coffsets = nil
+      fire_dimension_changed
+    end
+    def expand_column_to_width w=nil
+      x = _convert_curpos_to_column
+      unless w
+        # expand to width of current cell
+        s = @content[@current_index][x]
+        w = s.to_s.length + 1
+      end
+      column_width x, w
+      @coffsets = nil
+      fire_dimension_changed
+    end
+    # find the width of the longest item in the current columns and expand the width
+    # to that.
+    def expand_column_to_max_width
+      x = _convert_curpos_to_column
+      w = calculate_column_width x
+      expand_column_to_width w
+    end
+    def contract_column
+      x = _convert_curpos_to_column
+      w = get_column(x).width 
+      return if w <= @col_min_width
+      column_width x, w-1 if w
+      @coffsets = nil
+      fire_dimension_changed
+    end
+
+    #def method_missing(name, *args)
+    #@tp.send(name, *args)
+    #end
+    #
+    # supply a custom renderer that implements +render()+
+    # @see render
+    def renderer r
+      @renderer = r
+    end
+
+    ##
+    # Set column titles with given array of strings.
+    # NOTE: This is only required to be called if first row of file or content does not contain
+    # titles. In that case, this should be called before setting the data as the array passed
+    # is appended into the content array.
+    #
+    def columns=(array)
+      @_header_adjustment = 1
+      # I am eschewing using a separate field for columns. This is simpler for textpad.
+      # We always assume first row is columns.
+      #@columns = array
+      # should we just clear column, otherwise there's no way to set the whole thing with new data
+      # but then if we need to change columns what do it do, on moving or hiding a column ?
+      # Maybe we need a separate clear method or remove_all TODO
+      @content ||= []
+      @content << array
+      # This needs to go elsewhere since this method will not be called if file contains
+      # column titles as first row.
+      _init_model array
+    end
+    alias :headings= :columns=
+
+    def _init_model array
+      array.each_with_index { |c,i| 
+        # if columns added later we could be overwriting the width
+        c = get_column(i)
+        c.width ||= 10
+      }
+      # maintains index in current pointer and gives next or prev
+      @column_pointer = Circular.new array.size()-1
+    end
+    def model_row index
+      array = @content[index]
+      array.each_with_index { |c,i| 
+        # if columns added later we could be overwriting the width
+        ch = get_column(i)
+        ch.width = c.to_s.length + 2
+      }
+      # maintains index in current pointer and gives next or prev
+      @column_pointer = Circular.new array.size()-1
+    end
+
+    ## 
+    # insert entire database in one shot
+    # WARNING: overwrites columns if put there, should contain columns already as in CSV data
+    # @param lines is an array or arrays
+    def text lines, fmt=:none
+      _init_model lines[0]
+      fire_dimension_changed
+      super
+    end
+
+    ##
+    # set column array and data array in one shot
+    # Erases any existing content
+    def resultset columns, data
+      @content = []
+      _init_model columns
+      @content << columns
+      @_header_adjustment = 1
+      
+      @content.concat( data)
+      fire_dimension_changed
+    end
+
+
+      ## add a row to the table
+    def add array
+      unless @content
+        # columns were not added, this most likely is the title
+        @content ||= []
+        _init_model array
+      end
+      @content << array
+      fire_dimension_changed
+      self
+    end
+    def delete_at ix
+      return unless @content
+      fire_dimension_changed
+      @content.delete_at ix
+    end
+    alias :<< :add
+    # convenience method to set width of a column
+    # @param index of column
+    # @param width
+    # For setting other attributes, use get_column(index)
+    def column_width colindex, width
+      get_column(colindex).width = width
+      _invalidate_width_cache
+    end
+    # convenience method to set alignment of a column
+    # @param index of column
+    # @param align - :right (any other value is taken to be left)
+    def column_align colindex, align
+      get_column(colindex).align = align
+    end
+    # convenience method to hide or unhide a column
+    # Provided since column offsets need to be recalculated in the case of a width
+    # change or visibility change
+    def column_hidden colindex, hidden
+      get_column(colindex).hidden = hidden
+      _invalidate_width_cache
+    end
+    # http://www.opensource.apple.com/source/gcc/gcc-5483/libjava/javax/swing/table/DefaultTableColumnModel.java
+    def _invalidate_width_cache    #:nodoc:
+      @coffsets = nil
+    end
+    ## 
+    # should all this move into table column model or somepn
+    # move a column from offset ix to offset newix
+    def move_column ix, newix
+      acol = @chash.delete_at ix 
+      @chash.insert newix, acol
+      _invalidate_width_cache
+      #tmce = TableColumnModelEvent.new(ix, newix, self, :MOVE)
+      #fire_handler :TABLE_COLUMN_MODEL_EVENT, tmce
+    end
+    def add_column tc
+      raise "to figure out add_column"
+      _invalidate_width_cache
+    end
+    def remove_column tc
+      raise "to figure out add_column"
+      _invalidate_width_cache
+    end
+    def calculate_column_width col, maxrows=99
+      ret = 3
+      ctr = 0
+      @content.each_with_index { |r, i| 
+        #next if i < @toprow # this is also a possibility, it checks visible rows
+        break if ctr > maxrows
+        ctr += 1
+        #next if r == :separator
+        c = r[col]
+        x = c.to_s.length
+        ret = x if x > ret
+      }
+      ret
+    end
+    ##
+    # refresh pad onto window
+    # overrides super
+    def padrefresh
+      top = @window.top
+      left = @window.left
+      sr = @startrow + top
+      sc = @startcol + left
+      # first do header always in first row
+      retval = FFI::NCurses.prefresh(@pad,0,@pcol, sr , sc , 2 , @cols+ sc );
+      # now print rest of data
+      # h is header_adjustment
+      h = 1 
+      retval = FFI::NCurses.prefresh(@pad,@prow + h,@pcol, sr + h , sc , @rows + sr  , @cols+ sc );
+      $log.warn "XXX:  PADREFRESH #{retval}, #{@prow}, #{@pcol}, #{sr}, #{sc}, #{@rows+sr}, #{@cols+sc}." if retval == -1
+      # padrefresh can fail if width is greater than NCurses.COLS
+    end
+
+    def create_default_sorter
+      raise "Data not sent in." unless @content
+      @table_row_sorter = DefaultTableRowSorter.new @content
+    end
+    def header_row?
+      @prow == 0
+    end
+
+    def fire_action_event
+      if header_row?
+        if @table_row_sorter
+          x = _convert_curpos_to_column
+          c = @chash[x]
+          # convert to index in data model since sorter only has data_model
+          index = c.index
+          @table_row_sorter.toggle_sort_order index
+          @table_row_sorter.sort
+          fire_dimension_changed
+        end
+      end
+      super
+    end
+    ## 
+    # Find the next row that contains given string
+    # Overrides textpad since each line is an array
+    # NOTE does not go to next match within row
+    # NOTE: FIXME ensure_visible puts prow = current_index so in this case, the header
+    #   overwrites the matched row.
+    # @return row and col offset of match, or nil
+    # @param String to find
+    def next_match str
+      _calculate_column_offsets unless @coffsets
+      first = nil
+      ## content can be string or Chunkline, so we had to write <tt>index</tt> for this.
+      @content.each_with_index do |fields, ix|
+        #col = line.index str
+        #fields.each_with_index do |f, jx|
+        #@chash.each_with_index do |c, jx|
+          #next if c.hidden
+        each_column do |c,jx|
+          f = fields[c.index]
+          # value can be numeric
+          col = f.to_s.index str
+          if col
+            col += @coffsets[jx] 
+            first ||= [ ix, col ]
+            if ix > @current_index
+              return [ix, col]
+            end
+          end
+        end
+      end
+      return first
+    end
+    # yields each column to caller method
+    # for true returned, collects index of row into array and returns the array
+    # @returns array of indices which can be empty
+    # Value yielded can be fixnum or date etc
+    def matching_indices 
+      raise "block required for matching_indices" unless block_given?
+      @indices = []
+      ## content can be string or Chunkline, so we had to write <tt>index</tt> for this.
+      @content.each_with_index do |fields, ix|
+        flag = yield ix, fields
+        if flag
+          @indices << ix 
+        end
+      end
+      $log.debug "XXX:  INDICES found #{@indices}"
+      if @indices.count > 0
+        fire_dimension_changed
+        init_vars
+      else
+        @indices = nil
+      end
+      #return @indices
+    end
+    def clear_matches
+      # clear previous match so all data can show again
+      if @indices && @indices.count > 0
+        fire_dimension_changed
+        init_vars
+      end
+      @indices = nil
+    end
+    ## 
+    # Ensure current row is visible, if not make it first row
+    #  This overrides textpad due to header_adjustment, otherwise
+    #  during next_match, the header overrides the found row.
+    # @param current_index (default if not given)
+    #
+    def ensure_visible row = @current_index
+      unless is_visible? row
+          @prow = @current_index - @_header_adjustment
+      end
+    end
+    #
+    # yields non-hidden columns (ColumnInfo) and the offset/index
+    # This is the order in which columns are to be printed
+    def each_column
+      @chash.each_with_index { |c, i| 
+        next if c.hidden
+        yield c,i if block_given?
+      }
+    end
+    def render_all
+      if @indices && @indices.count > 0
+        @indices.each_with_index do |ix, jx|
+          render @pad, jx, @content[ix]
+        end
+      else
+        @content.each_with_index { |line, ix|
+          #FFI::NCurses.mvwaddstr(@pad,ix, 0, @content[ix])
+          render @pad, ix, line
+        }
+      end
+    end
+
+  end # class TableWidget
+
+  ##
+  # Handles selection of items in a list or table or tree that uses stable indices.
+  # Indexes are in the order they were places, not sorted.
+  # This is just a wrapper over an array, except that it fires an event so users can bind
+  # to row selection and deselection
+  # TODO - fire events to listeners
+  #
+  class ListSelectionModel
+    ##
+    # obj is the source object, I am wondering whether i need it or not
+    def initialize component
+      @obj = component
+      @selected_indices = []
+    end
+    def toggle_row_selection crow
+      if is_row_selected? crow
+        unselect crow
+      else
+        select crow
+      end
+    end
+    def select ix
+      @selected_indices << ix
+      _fire_event ix, ix, :INSERT
+    end
+    def unselect ix
+      @selected_indices.delete ix
+      _fire_event ix, ix, :DELETE
+    end
+    alias :add_to_selection :select
+    alias :remove_from_selection :unselect
+    def clear_selection
+      @selected_indices = []
+      _fire_event 0, 0, :CLEAR
+    end
+    def is_row_selected? crow
+      @selected_indices.include? crow
+    end
+    def is_selection_empty?
+      return @selected_indices.empty?
+    end
+    # if row deleted in list, then synch with list
+    # (No listeners  are informed)
+    def remove_index crow
+      @selected_indices.delete crow
+    end
+    def _fire_event firsti, lasti, event
+      lse = ListSelectionEvent.new(firsti, lasti, self, event)
+      fire_handler :LIST_SELECTION_EVENT, lse
+    end
+
+    def select_all
+      # how do we do this since we don't know what the indices are. 
+      # What is the user using as identifier?
+    end
+     
+    # returns a list of selected indices in the same order as added
+    def selected_rows
+      @selected_indices
+    end
+  end # class
+  class ListSelectionEvent < Struct.new(:firstrow, :lastrow, :source, :type)
+  end
+end # module

data/rbcurse-experimental.gemspec

@@ -0,0 +1,56 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "rbcurse-experimental"
+  s.version = "0.0.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Rahul Kumar"]
+  s.date = "2013-04-12"
+  s.description = "Ruby curses/ncurses widgets, experimental and minimally tested. Copy into your project, do not depend on this gem."
+  s.email = "sentinel1879@gmail.com"
+  s.extra_rdoc_files = [
+    "README.markdown"
+  ]
+  s.files = [
+    "CHANGELOG",
+    "README.markdown",
+    "VERSION",
+    "examples/teststackflow.rb",
+    "lib/rbcurse/experimental/widgets/directorylist.rb",
+    "lib/rbcurse/experimental/widgets/directorytree.rb",
+    "lib/rbcurse/experimental/widgets/masterdetail.rb",
+    "lib/rbcurse/experimental/widgets/multiform.rb",
+    "lib/rbcurse/experimental/widgets/resultsetbrowser.rb",
+    "lib/rbcurse/experimental/widgets/resultsettextview.rb",
+    "lib/rbcurse/experimental/widgets/rscrollform.rb",
+    "lib/rbcurse/experimental/widgets/stackflow.rb",
+    "lib/rbcurse/experimental/widgets/tablewidget.rb",
+    "lib/rbcurse/experimental/widgets/undomanager.rb",
+    "rbcurse-experimental.gemspec"
+  ]
+  s.homepage = "http://github.com/rkumar/rbcurse-experimental"
+  s.require_paths = ["lib"]
+  s.rubyforge_project = "rbcurse"
+  s.rubygems_version = "1.8.25"
+  s.summary = "Ruby Ncurses Toolkit experimental widgets"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rbcurse-core>, [">= 0.0.3"])
+      s.add_runtime_dependency(%q<rbcurse-extras>, [">= 0.0"])
+    else
+      s.add_dependency(%q<rbcurse-core>, [">= 0.0.3"])
+      s.add_dependency(%q<rbcurse-extras>, [">= 0.0"])
+    end
+  else
+    s.add_dependency(%q<rbcurse-core>, [">= 0.0.3"])
+    s.add_dependency(%q<rbcurse-extras>, [">= 0.0"])
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rbcurse-experimental
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-14 00:00:00.000000000 Z
+date: 2013-04-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbcurse-core
@@ -43,13 +43,15 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0.0'
-description: Ruby curses/ncurses widgets, experimental and minimally tested
+description: Ruby curses/ncurses widgets, experimental and minimally tested. Copy
+  into your project, do not depend on this gem.
 email: sentinel1879@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files:
 - README.markdown
 files:
+- CHANGELOG
 - README.markdown
 - VERSION
 - examples/teststackflow.rb
@@ -61,7 +63,9 @@ files:
 - lib/rbcurse/experimental/widgets/resultsettextview.rb
 - lib/rbcurse/experimental/widgets/rscrollform.rb
 - lib/rbcurse/experimental/widgets/stackflow.rb
+- lib/rbcurse/experimental/widgets/tablewidget.rb
 - lib/rbcurse/experimental/widgets/undomanager.rb
+- rbcurse-experimental.gemspec
 homepage: http://github.com/rkumar/rbcurse-experimental
 licenses: []
 post_install_message: 
@@ -82,7 +86,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: rbcurse
-rubygems_version: 1.8.23
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Ruby Ncurses Toolkit experimental widgets