canis 0.0.4

data/lib/canis/core/include/listeditable.rb

@@ -0,0 +1,319 @@
+# Some methods for manipulating lists
+# Different components may bind different keys to these
+# Currently will be called by TextArea and the editable version
+# of TextView (vieditable).
+#
+require 'canis/core/include/rinputdataevent'
+module ListEditable
+
+    def remove_all
+      # don't create a new object, other dependents like selection model may suffer 2014-04-08 - 20:00 
+      #@list = []
+      @list.clear
+      set_modified  # added 2009-02-13 22:28 so repaints
+    end
+    # current behav is a mix of vim's D and C-k from alpine, i don;t know how i screwed it up like this
+    # Should be:
+    # 1. do not take cursor back by 1 (this is vims D behavior)
+    # 2. retain EOL, we need to evaluate at undo
+    # 3. if nothing coming in delete buffer then join next line here
+    # 4. if line is blank, it will go to delete line (i think).
+    # Earlier, a C-k at pos 0 would blank the line and not delete it (copied from alpine).
+    # The next C-k would delete. emacs deletes if C-k at pos 0.
+    def delete_eol
+      return -1 unless @editable
+      pos = @curpos -1 # retain from 0 till prev char
+      @delete_buffer = @buffer[@curpos..-1]
+      # currently eol is there in delete_buff often. Should i maintain it ? 2010-03-08 18:29 UNDO
+      #@delete_buffer.chomp! # new 2010-03-08 18:29 UNDO - this worked but hope does not have othe impact
+
+      # if pos is 0, pos-1 becomes -1, end of line!
+      @list[@current_index] = pos == -1 ? "" : @buffer[0..pos]
+      $log.debug "delete EOL :pos=#{pos}, #{@delete_buffer}: row: #{@list[@current_index]}:"
+      @buffer = @list[@current_index]
+      if @delete_buffer == ""
+        $log.debug " TA: DELETE going to join next "
+        join_next_line # pull next line in
+      end
+      oldcur = @curpos
+      #x cursor_backward if @curpos > 0 #  this was vims behavior -- knoecked off
+      #fire_handler :CHANGE, self  # 2008-12-09 14:56 
+      fire_handler :CHANGE, InputDataEvent.new(oldcur,oldcur+@delete_buffer.length, self, :DELETE, @current_index, @delete_buffer)     #  2008-12-24 18:34 
+      set_modified 
+      return @delete_buffer
+    end
+    def join_next_line
+      # return if last line  TODO
+      buff = @list.delete_at(@current_index + 1)
+      if buff
+        $log.debug " TA: DELETE inside to join next #{buff}  "
+        fire_handler :CHANGE, InputDataEvent.new(0,0+buff.length, self, :DELETE_LINE, @current_index+1, buff)  
+        @buffer << buff
+      end
+    end
+  # deletes given line or current
+  # now fires DELETE_LINE so no guessing by undo manager
+  def delete_line line=@current_index
+    return -1 unless @editable
+    if !$multiplier || $multiplier == 0 
+      @delete_buffer = @list.delete_at line
+    else
+      @delete_buffer = @list.slice!(line, $multiplier)
+    end
+    @curpos ||= 0 # rlist has no such var
+    $multiplier = 0
+    add_to_kill_ring @delete_buffer
+    @buffer = @list[@current_index]
+    if @buffer.nil?
+      up
+      setrowcol @row + 1, nil # @form.col
+    end
+    # warning: delete buffer can now be an array
+    fire_handler :CHANGE, InputDataEvent.new(@curpos,@curpos+@delete_buffer.length, self, :DELETE_LINE, line, @delete_buffer)     #  2008-12-24 18:34 
+    set_modified 
+    # next line being called from textarea which is old style and thus bombs
+    fire_dimension_changed if respond_to? :fire_dimension_changed
+  end
+    def delete_curr_char num=($multiplier == 0 ? 1 : $multiplier)
+      return -1 unless @editable
+      delete_at @curpos, num # changed so only one event, and one undo
+      set_modified 
+      $multiplier = 0
+    end
+    # 
+    # 2010-03-08 23:30 does not seem to be working well when backspacing at first char of line
+    # FIXME should work as a unit, so one undo and one fire_handler, at least if on one line.
+    def delete_prev_char num=($multiplier == 0 ? 1 : $multiplier)
+      return -1 if !@editable 
+      num.times do
+        if @curpos <= 0
+          join_to_prev_line
+          return
+        end
+        @curpos -= 1 if @curpos > 0
+        delete_at
+        set_modified 
+        addcol -1
+      end
+      $multiplier = 0
+    end
+    # open a new line and add chars to it.
+    # FIXME does not fire handler, thus won't undo
+    def append_row lineno=@current_index, chars=""
+        $log.debug "append row sapce:#{chars}."
+      @list.insert lineno+1, chars
+    end
+    ##
+    # delete character/s on current line
+    def delete_at index=@curpos, howmany=1
+      return -1 if !@editable 
+      $log.debug "delete_at (characters) : #{@current_index} #{@buffer} #{index}"
+      char = @buffer.slice!(@curpos,howmany)  # changed added ,1 and take char for event
+      # if no newline at end of this then bring up prev character/s till maxlen
+      # NO WE DON'T DO THIS ANYLONGER 2008-12-26 21:09 lets see
+=begin
+      if @buffer[-1,1]!="\r"
+        @buffer[-1]=" " if @buffer[-1,1]=="\n"
+        if !next_line.nil? and next_line.length > 0
+          move_chars_up
+        end
+      end
+=end
+      set_modified true
+      fire_handler :CHANGE, InputDataEvent.new(@curpos,@curpos+howmany, self, :DELETE, @current_index, char)     #  2008-12-24 18:34 
+    end
+    def undo_handler(uh)
+      @undo_handler = uh
+    end
+    ## THIS ONE SHOULD BE IN TEXTVIEW ALSO
+    # saves current or n lines into kill ring, appending to earlier contents
+    # Use yank (paste) or yank-pop to retrieve
+    def kill_ring_save
+      pointer = @current_index
+      list = []
+      repeatm {
+        line =  @list[pointer] 
+        list << line unless line.nil?
+        pointer += 1
+      }
+      add_to_kill_ring list
+    end
+    ## THIS ONE SHOULD BE IN TEXTVIEW ALSO
+    # add given line or lines to kill_ring
+    def add_to_kill_ring list
+      # directly referenceing kill_ring.  We need to OO it a bit, so we can change internals w'o breaking all.
+      # FIXME
+      if $append_next_kill
+        # user requested this kill to be appened to last kill, so it can be yanked as one
+        #$kill_ring.last << list
+        last = $kill_ring.pop 
+        $log.debug "YANK: addto : last= #{last} , list= #{list} "
+        case list
+        when Array
+          #list.insert 0, last
+          list.insert 0, *last # 2011-10-10 changed as it was wrong in textarea
+          $kill_ring << list
+        when String
+          $kill_ring << [last, list]
+        end
+      else
+        $kill_ring << list
+      end
+      $kill_ring_pointer = $kill_ring.size
+      $append_next_kill = false
+      $log.debug "YANK: kill_ring: #{$kill_ring} "
+    end
+
+    # pastes recent (last) entry of kill_ring.
+    # This can be one or more lines. Please note that for us vimmer's yank means copy
+    # but for emacsers it seems to mean paste. Aargh!!
+    # earlier it was not +1, it was pasting before not after
+    def yank where=@current_index+1
+      return -1 if !@editable 
+      return if $kill_ring.empty?
+      row = $kill_ring.last
+      $log.debug "YANK: row #{row} "
+      index = where
+      case row
+      when Array
+        #index = @current_index
+        row.each{ |r|
+          @list.insert index, r.dup
+          index += 1
+        }
+        $kill_last_pop_size = row.size
+      when String
+        #@list[@current_index].insert row.dup
+        #@list.insert @current_index, row.dup
+        @list.insert index, row.dup
+        $kill_last_pop_size = 1
+      else
+        raise "textarea yank got uncertain datatype from kill_ring  #{row.class} "
+      end
+      $kill_ring_pointer = $kill_ring.size - 1
+      $kill_ring_index = @current_index # pops will replace data in this row, never an insert
+      @repaint_required = true
+      @widget_scrolled  = true
+      # XXX not firing anything here, so i can't undo. yet, i don't know whether a yank will
+      # be followed by a yank-pop, in which case it will not be undone.
+      # object row can be string or array - time to use INSERT_LINE so we are clear
+      # row.length can be array's size or string length - beware
+      fire_handler :CHANGE, InputDataEvent.new(0,row.length, self, :INSERT_LINE, @current_index, row)
+      return 0 # don't want a UNHANDLED or NO_BLOCK going back
+    end
+
+    # paste previous entries from kill ring
+    # I am not totally clear on this, not being an emacs user. but seems you have to do C-y
+    # once (yank) before you can do a yank pop. 
+    def yank_pop
+      return -1 if !@editable 
+      return if $kill_ring.empty?
+      mapped_key = @current_key # we are mapped to this
+      # checking that user has done a yank on this row. We only replace on the given row, never
+      # insert. But what if user edited after yank, Sheesh ! XXX
+      if $kill_ring_index != @current_index
+        Ncurses.beep
+        return # error message required that user must yank first
+      end
+      # the real reason i put this into a loop is so that i can properly undo the
+      # action later if required. I only need to store the final selection.
+      # This also ensures the user doesn't wander off in between and come back.
+      row = nil
+      while true
+        # remove lines from last replace, then insert
+        index = @current_index
+        $kill_last_pop_size.times {
+          del = @list.delete_at index
+        }
+        row = $kill_ring[$kill_ring_pointer-$multiplier]
+        $multiplier = 0
+        index = @current_index
+        case row
+        when Array
+          row.each{ |r|
+            @list.insert index, r.dup
+            index += 1
+          }
+          $kill_last_pop_size = row.size
+        when String
+          @list.insert index, row.dup
+          $kill_last_pop_size = 1
+        else
+          raise "textarea yank_pop got uncertain datatype from kill_ring  #{row.class} "
+        end
+
+        $kill_ring_pointer -= 1
+        if $kill_ring_pointer < 0
+          # should be size, but that'll give an error. need to find a way!
+          $kill_ring_pointer = $kill_ring.size - 1
+        end
+        @repaint_required = true
+        @widget_scrolled  = true
+        my_win = @form || @parent_component.form # 2010-02-12 12:51 
+        my_win.repaint
+        ch = @graphic.getchar
+        if ch != mapped_key
+          @graphic.ungetch ch # seems to work fine
+          return ch # XXX to be picked up by handle_key loop and processed
+        end
+      end
+      # object row can be string or array - time to use INSERT_LINE so we are clear
+      # row.length can be array's size or string length - beware
+      fire_handler :CHANGE, InputDataEvent.new(0,row.length, self, :INSERT_LINE, @current_index, row)
+      return 0
+    end
+    def append_next_kill
+      $append_next_kill = true
+    end
+    # deletes count words on current line
+    # Does not at this point go beyond the line
+    def delete_word
+      return -1 unless @editable
+      $multiplier = 1 if !$multiplier || $multiplier == 0 
+      line = @current_index
+      pos = @curpos
+      @delete_buffer = ""
+      # currently only look in current line
+      $multiplier.times {
+        found = @buffer.index(/[[:punct:][:space:]]/, pos)
+        break if !found
+        $log.debug " delete_word: pos #{pos} found #{found} buff: #{@buffer} "
+        @delete_buffer << @buffer.slice!(pos..found)
+      }
+      return if @delete_buffer == ""
+      $log.debug " delete_word: delbuff #{@delete_buffer} "
+      add_to_kill_ring @delete_buffer
+      fire_handler :CHANGE, InputDataEvent.new(@curpos,@curpos+@delete_buffer.length, self, :DELETE, line, @delete_buffer)     #  2008-12-24 18:34 
+      set_modified 
+    end
+    ##
+    # deletes forward till the occurence of a character
+    # it gets the char from the user
+    # Should we pass in the character (and accept it as a separate func) ???
+    def delete_forward
+      return -1 unless @editable
+      ch = @graphic.getchar
+      return if ch < 0 || ch > 255
+      char = ch.chr
+      $multiplier = 1 if !$multiplier || $multiplier == 0 
+      line = @current_index
+      pos = @curpos
+      tmpbuf = ""
+      # currently only look in current line
+      $multiplier.times {
+        found = @buffer.index(char, pos)
+        break if !found
+        #$log.debug " delete_forward: pos #{pos} found #{found} buff: #{@buffer} "
+        # ideally do this in one shot outside loop, but its okay here for now
+        tmpbuf << @buffer.slice!(pos..found)
+      }
+      return if tmpbuf == ""
+      @delete_buffer = tmpbuf
+      $log.debug " delete_forward: delbuff #{@delete_buffer} "
+      add_to_kill_ring @delete_buffer
+      fire_handler :CHANGE, InputDataEvent.new(@curpos,@curpos+@delete_buffer.length, self, :DELETE, line, @delete_buffer)     #  2008-12-24 18:34 
+      set_modified 
+      $multiplier = 0
+    end
+
+end # end module

data/lib/canis/core/include/listoperations.rb

@@ -0,0 +1,61 @@
+# Some methods for traversing list like widgets such as tree, listbox and maybe table
+# Different components may bind different keys to these
+#
+module Canis
+  module ListOperations
+
+    # get a char ensure it is a char or number
+    # In this state, it could accept control and other chars.
+    private
+    def _ask_a_char
+      ch = @graphic.getch
+      #message "achar is #{ch}"
+      if ch < 26 || ch > 255
+        @graphic.ungetch ch
+        return :UNHANDLED
+      end
+      return ch.chr
+    end
+    public
+    # sets the selection to the next row starting with char
+    # Trying to return unhandled is having no effect right now. if only we could pop it into a
+    # stack or unget it.
+    def set_selection_for_char char=nil
+      char = _ask_a_char unless char
+      #alert "got #{char} "
+      return :UNHANDLED if char == :UNHANDLED
+      @oldrow = @current_index
+      @last_regex = /^#{char}/
+      ix = next_regex @last_regex
+      #alert "next returned #{ix}"
+      return unless ix
+      @current_index = ix[0] 
+      @search_found_ix = @current_index
+      @curpos = ix[1]
+      ensure_visible
+      return @current_index
+    end
+    # Find the next row that contains given string
+    # @return row and col offset of match, or nil
+    # @param String to find
+    def  next_regex str
+      first = nil
+      ## content can be string or Chunkline, so we had to write <tt>index</tt> for this.
+      ## =~ does not give an error, but it does not work.
+      @list.each_with_index do |line, ix|
+        #col = line.index str
+        # for treemodel which will give us user_object.to_s
+        col = line.to_s.index str
+        if col
+          first ||= [ ix, col ]
+          if ix > @current_index
+            return [ix, col]
+          end
+        end
+      end
+      return first
+    end
+
+
+  end # end module
+end # end module

data/lib/canis/core/include/listselectionmodel.rb

@@ -0,0 +1,388 @@
+#!/usr/bin/env ruby -w
+# ----------------------------------------------------------------------------- #
+#         File: listselectionmodel.rb
+#  Description: Used by textpad derivates to give selection of rows
+#       Author: j kepler  http://github.com/mare-imbrium/canis/
+#         Date: 2014-04-10 - 21:04
+#      License: Same as ruby license
+#  Last update: 2014-07-07 00:36
+# ----------------------------------------------------------------------------- #
+#  listselectionmodel.rb  Copyright (C) 2012-2014 j kepler
+# ----------------------------------------------------------------------------- #
+#
+require 'forwardable'
+
+# The +DefaultListSelection+ mixin provides Textpad derived classes with
+# selection methods and bindings.
+# == Example
+#  Inside the constructor of the multiline object use the following line, before the call to `super()`
+#
+#      self.extend DefaultListSelection
+#      
+# At any other portion, for example after the call to `super()` you may set the 
+# default model if the user has not done so in the calling block
+#
+#      @list_selection_model ||= Canis::DefaultListSelectionModel.new self
+# 
+# When clearing data, as in `clear`, +selected_indices+ should also be cleared.
+#
+# == Note
+#
+#  This module does not take care of rendering a selected row. This must still be handled
+#  by the default or custom renderer using `is_row_selected?`.
+#
+#  Note that changing the order of data, or deleting, inserting etc will not correct the selection
+#  indices. Indices are assumed to be stable, and they may be cleared using `clear` on +@selected_indices+
+#  if the data indices change.
+#
+module Canis
+  extend self
+  module DefaultListSelection
+    def self.extended(obj)
+      extend Forwardable
+      # selection modes may be :multiple, :single or :none
+      dsl_accessor :selection_mode
+      # color of selected rows, and attribute of selected rows
+      dsl_accessor :selected_color, :selected_bgcolor, :selected_attr
+      # indices of selected rows
+      dsl_accessor :selected_indices
+      # model that takes care of selection operations
+      dsl_accessor :list_selection_model
+      #
+      # all operations of selection are delegated to the ListSelectionModel
+      def_delegators :@list_selection_model, :is_row_selected?, :toggle_row_selection, :select, :unselect, :is_selection_empty?, :clear_selection, :selected_rows, :select_all, :selected_values, :selected_value
+
+
+      obj.instance_exec {
+        @selected_indices = []
+        @selection_mode = :multiple # default is multiple intervals
+        #@list_selection_model = DefaultListSelectionModel.new obj
+      }
+
+    end
+  end # mod DefaultListSelection
+  # Whenever user selects one or more rows, this object is sent via event
+  # giving start row and last row of selection, object
+  # and type which is :INSERT :DELETE :CLEAR
+  class ListSelectionEvent < Struct.new(:firstrow, :lastrow, :source, :type)
+  end
+
+  ##
+  # Object that takes care of selection of rows.
+  # This may be replace with a custom object at time of instantiation of list
+  # Note that there are only two selection modes: single and multiple.
+  # Multiple refers to multiple intervals. There is also a multiple row selection
+  # mode, single interval, which only allows one range to be selected, much like a
+  # text object, i.e. any text editor.
+  #
+  ## I am copying this from listselectable. that was a module so was included and shared variables
+  # but now this is a class, and cannot access state as directly
+
+  class DefaultListSelectionModel
+
+    def initialize component
+      raise "Components passed to DefaultListSelectionModel is nil" unless component
+      @obj = component
+    
+      @selected_indices = @obj.selected_indices
+      # in this case since it is called immediately upon extend, user cannot change this
+      # Need a method to let user change after extending
+      @selection_mode = @obj.selection_mode
+      list_bindings
+    end
+
+    # change selection of current row on pressing space bar (or keybinding)
+    # If mode is multiple, then this row is added to previous selections
+    # @example
+    #     bind_key(32) { toggle_row_selection }
+    # 
+    # 
+    def toggle_row_selection crow=@obj.current_index
+      @last_clicked = crow
+      @repaint_required = true
+      case @obj.selection_mode 
+      when :multiple
+        if @selected_indices.include? crow
+          @selected_indices.delete crow
+          lse = ListSelectionEvent.new(crow, crow, @obj, :DELETE)
+          @obj.fire_handler :LIST_SELECTION_EVENT, lse
+        else
+          @selected_indices << crow
+          lse = ListSelectionEvent.new(crow, crow, @obj, :INSERT)
+          @obj.fire_handler :LIST_SELECTION_EVENT, lse
+        end
+      else
+        # single - now change to use array only
+        @selected_index = @selected_indices[0]
+        if @selected_index == crow 
+          @old_selected_index = @selected_index # 2011-10-15 so we can unhighlight
+          @selected_index = nil
+          @selected_indices.clear
+          lse = ListSelectionEvent.new(crow, crow, @obj, :DELETE)
+          @obj.fire_handler :LIST_SELECTION_EVENT, lse
+        else
+          @selected_indices[0] = crow
+          @obj.fire_row_changed(@old_selected_index) if @old_selected_index
+          @old_selected_index = crow # 2011-10-15 so we can unhighlight
+          lse = ListSelectionEvent.new(crow, crow, @obj, :INSERT)
+          @obj.fire_handler :LIST_SELECTION_EVENT, lse
+        end
+      end
+      @obj.fire_row_changed crow
+      #alert "toggling #{@selected_indices.join(',')}"
+    end
+    #
+    # Range select.
+    # Only for multiple mode.
+    # Uses the last row clicked on, till the current one.
+    # If user clicks inside a selcted range, then deselect from last click till current (remove from earlier)
+    # If user clicks outside selected range, then select from last click till current (add to earlier)
+    # typically bound to Ctrl-Space (0)
+    #
+    # @example
+    #
+    #     bind_key(0) { range_select }
+    #
+    def range_select crow=@obj.current_index
+      #alert "add to selection fired #{@last_clicked}"
+      @last_clicked ||= crow
+      min = [@last_clicked, crow].min
+      max = [@last_clicked, crow].max
+      case @obj.selection_mode 
+      when :multiple
+        if @selected_indices.include? crow
+          # delete from last_clicked until this one in any direction
+          min.upto(max){ |i| @selected_indices.delete i 
+                         @obj.fire_row_changed i
+          }
+          lse = ListSelectionEvent.new(min, max, @obj, :DELETE)
+          @obj.fire_handler :LIST_SELECTION_EVENT, lse
+        else
+          # add to selection from last_clicked until this one in any direction
+          min.upto(max){ |i| @selected_indices << i unless @selected_indices.include?(i) 
+                         @obj.fire_row_changed i
+          }
+          lse = ListSelectionEvent.new(min, max, @obj, :INSERT)
+          @obj.fire_handler :LIST_SELECTION_EVENT, lse
+        end
+      else
+      end
+      @last_clicked = crow # 2014-04-08 - 01:21 this was missing, i think it is required
+      self
+    end
+    # clears selected indices, typically called when multiple select
+    # Key binding is application specific
+    def clear_selection
+      return if @selected_indices.nil? || @selected_indices.empty?
+      arr = @selected_indices.dup # to un highlight
+      @selected_indices.clear
+      arr.each {|i| @obj.fire_row_changed(i) }
+      @selected_index = nil
+      @old_selected_index = nil
+      #  User should ignore first two params
+      lse = ListSelectionEvent.new(0, arr.size, @obj, :CLEAR)
+      @obj.fire_handler :LIST_SELECTION_EVENT, lse
+      arr = nil
+    end
+
+    # returns +true+ if given row has been selected
+    # Now that we use only the array, the multiple check is good enough
+    def is_row_selected? crow
+      case @obj.selection_mode 
+      when :multiple
+        @selected_indices.include? crow
+      else
+        @selected_index = @selected_indices[0]
+        crow == @selected_index
+      end
+    end
+    alias :is_selected? is_row_selected?
+   
+    # after selecting, traverse selections forward
+    def goto_next_selection
+      return if selected_rows().length == 0 
+      row = selected_rows().sort.find { |i| i > @obj.current_index }
+      row ||= @obj.current_index
+      #@obj.current_index = row
+      @obj.goto_line row
+    end
+    
+    # after selecting, traverse selections backward
+    def goto_prev_selection
+      return if selected_rows().length == 0 
+      row = selected_rows().sort{|a,b| b <=> a}.find { |i| i < @obj.current_index }
+      row ||= @obj.current_index
+      #@obj.current_index = row
+      @obj.goto_line row
+    end
+    # add the following range to selected items, unless already present
+    # should only be used if multiple selection interval
+    def add_row_selection_interval ix0, ix1
+      return if @obj.selection_mode != :multiple
+      @anchor_selection_index = ix0
+      @lead_selection_index = ix1
+      ix0.upto(ix1) {|i| 
+                     @selected_indices  << i unless @selected_indices.include? i
+                     @obj.fire_row_changed i
+      }
+      lse = ListSelectionEvent.new(ix0, ix1, @obj, :INSERT)
+      @obj.fire_handler :LIST_SELECTION_EVENT, lse
+      #$log.debug " DLSM firing LIST_SELECTION EVENT #{lse}"
+    end
+
+    # remove selected indices between given indices inclusive
+    def remove_row_selection_interval ix0, ix1
+      @anchor_selection_index = ix0
+      @lead_selection_index = ix1
+      arr = @selected_indices.dup # to un highlight
+      @selected_indices.delete_if {|x| x >= ix0 and x <= ix1 }
+      arr.each {|i| @obj.fire_row_changed(i) }
+      lse = ListSelectionEvent.new(ix0, ix1, @obj, :DELETE)
+      @obj.fire_handler :LIST_SELECTION_EVENT, lse
+    end
+    # convenience method to select next len rows
+    def insert_index_interval ix0, len
+      @anchor_selection_index = ix0
+      @lead_selection_index = ix0+len
+      add_row_selection_interval @anchor_selection_index, @lead_selection_index
+    end
+    # select all rows, you may specify starting row.
+    # if header row, then 1 else should be 0. Actually we should have a way to determine
+    # this, and the default should be zero.
+    def select_all start_row=0 #+@_header_adjustment
+      # don't select header row - need to make sure this works for all cases. we may 
+      # need a variable instead of hardoded value
+      add_row_selection_interval start_row, @obj.list.count()-1
+    end
+
+    # toggle selection of entire list
+    # Requires application specific key binding
+    def invert_selection start_row=0 #+@_header_adjustment
+      start_row.upto(@obj.list.count()-1){|i| invert_row_selection i }
+    end
+     
+    # toggles selection for given row
+    # Typically called by invert_selection
+    def invert_row_selection row=@obj.current_index
+      @repaint_required = true
+      if is_selected? row
+        remove_row_selection_interval(row, row)
+      else
+        add_row_selection_interval(row, row) 
+      end
+    end
+    # selects all rows with the values given, leaving existing selections
+    # intact. Typically used after accepting search criteria, and getting a list of values
+    # to select (such as file names). Will not work with tables (array or array)
+    # TODO is this even needed, scrap
+    def select_values values
+      return unless values
+      values.each do |val|
+        row = @list.index val
+        add_row_selection_interval row, row unless row.nil?
+      end
+    end
+    # TODO is this even needed, scrap
+    # unselects all rows with the values given, leaving all other rows intact
+    # You can map "-" to ask_select and call this from there.
+    #   bind_key(?+, :ask_select) # --> calls select_values
+    #   bind_key(?-, :ask_unselect)
+    def unselect_values values
+      return unless values
+      values.each do |val|
+        row = @list.index val
+        remove_row_selection_interval row, row unless row.nil?
+      end
+    end
+    #
+    # Asks user to enter a string or pattern for selecting rows
+    # Selects rows based on pattern, leaving other selections as-is
+    def ask_select prompt="Enter selection pattern: "
+      ret = get_string prompt
+      return if ret.nil? || ret ==  ""
+      indices = get_matching_indices ret
+      #$log.debug "listselectionmodel: ask_select got matches#{@indices} "
+      return if indices.nil? || indices.empty?
+      indices.each { |e|
+        # will not work if single select !! FIXME
+        add_row_selection_interval e,e
+      }
+    end
+    # returns a list of matching indices using a simple regex match on given pattern
+    # returns an empty list if no match
+    def get_matching_indices pattern
+      matches = []
+      @obj.content.each_with_index { |e,i| 
+        # convert to string for tables
+        e = e.to_s unless e.is_a? String
+        if e  =~ /#{pattern}/
+          matches << i
+        end
+      }
+      return matches
+    end 
+    # Asks user to enter a string or pattern for UNselecting rows
+    # UNSelects rows based on pattern, leaving other selections as-is
+    def ask_unselect prompt="Enter selection pattern: "
+      ret = get_string prompt
+      return if ret.nil? || ret ==  ""
+      indices = get_matching_indices ret
+      return if indices.nil? || indices.empty?
+      indices.each { |e|
+        # will not work if single select !! FIXME
+        remove_row_selection_interval e,e
+      }
+    end
+
+    ## 
+    # bindings related to selection
+    #
+    def list_bindings
+      # freeing space for paging, now trying out 'v' as selector. 2014-04-14 - 18:57 
+      @obj.bind_key($row_selector || 'v'.ord, 'toggle selection') { toggle_row_selection }
+      
+      # the mode may be set to single after the constructor, so this would have taken effect.
+      if @obj.selection_mode == :multiple
+      # freeing ctrl_space for back paging, now trying out 'V' as selector. 2014-04-14 - 18:57 
+        @obj.bind_key($range_selector || 'V'.ord, 'range select') { range_select }
+        @obj.bind_key(?+, 'ask_select') { ask_select } 
+        @obj.bind_key(?-, 'ask_unselect') { ask_unselect } 
+        @obj.bind_key(?a, 'select_all') {select_all}
+        @obj.bind_key(?*, 'invert_selection') { invert_selection }
+        @obj.bind_key(?u, 'clear_selection') { clear_selection }
+        @obj.bind_key([?g,?n], 'goto next selection'){ goto_next_selection } # mapping double keys like vim
+        @obj.bind_key([?g,?p], 'goto prev selection'){ goto_prev_selection } # mapping double keys like vim
+      end
+      @_header_adjustment ||= 0 #  incase caller does not use
+      #@obj._events << :LIST_SELECTION_EVENT unless @obj._events.include? :LIST_SELECTION_EVENT
+    end
+    def list_init_vars
+      # uncommenting since link with obj will be broken
+      #@selected_indices = []
+      @selected_index = nil
+      @old_selected_index = nil
+      #@row_selected_symbol = ''
+      ## FIXME we are not doing selectors at present. should we, else remove this
+      if @show_selector
+        @row_selected_symbol ||= '*'
+        @row_unselected_symbol ||= ' '
+        @left_margin ||= @row_selected_symbol.length
+      end
+    end
+    # return the indices selected
+    def selected_rows
+      @selected_indices
+    end
+    # return the values selected
+    def selected_values
+      @obj.values_at(*@selected_indices)
+    end
+    # returns first selection, meant for convenience of single select listboxes
+    # earlier called selected_item
+    def selected_value
+      return nil if @selected_indices.empty?
+      @obj[@selected_indices.first]
+      #selected_values.first
+    end
+  end # class
+end # mod Canis