rbcurse-core 0.0.0

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

@@ -0,0 +1,264 @@
+# File created: 2010-10-29 14:09 
+# Author      : rkumar
+#
+# this is a new, simpler version of listselectable
+# the original gets into models and has complicated operation as well
+# as difficult to remember method names. This attempts to be a simple plugin.
+# Currently being used by rbasiclistbox (rlist) and now tabularwidget.
+# NOTE: pls define @_header_adjustment to 0 if you don't use it or know what it means.
+# TODO: of course we need to fire events so user can do something.
+module RubyCurses
+  module NewListSelectable
+
+    # @group selection related
+
+    # change selection of current row on pressing space bar
+    # If mode is multiple, then other selections are cleared and this is added
+    # @example
+    #     bind_key(32) { toggle_row_selection }
+    # current_index is not account for header_adjustment
+    # if current row is selected in mulitple we should deselect ?? FIXME
+    def toggle_row_selection crow=@current_index-@_header_adjustment
+      @last_clicked = crow
+      @repaint_required = true
+      case @selection_mode 
+      when :multiple
+        @widget_scrolled = true # FIXME we need a better name
+        if @selected_indices.include? crow
+          @selected_indices.delete crow
+          lse = ListSelectionEvent.new(crow, crow, self, :DELETE)
+          fire_handler :LIST_SELECTION_EVENT, lse
+        else
+          @selected_indices << crow
+          lse = ListSelectionEvent.new(crow, crow, self, :INSERT)
+          fire_handler :LIST_SELECTION_EVENT, lse
+        end
+      else
+        if @selected_index == crow 
+          @old_selected_index = @selected_index # 2011-10-15 so we can unhighlight
+          @selected_index = nil
+          lse = ListSelectionEvent.new(crow, crow, self, :DELETE)
+          fire_handler :LIST_SELECTION_EVENT, lse
+        else
+          @old_selected_index = @selected_index # 2011-10-15 so we can unhighlight
+          @selected_index = crow 
+          lse = ListSelectionEvent.new(crow, crow, self, :INSERT)
+          fire_handler :LIST_SELECTION_EVENT, lse
+        end
+      end
+    end
+    #
+    # Only for multiple mode.
+    # add an item to selection, if selection mode is multiple
+    # if item already selected, it is deselected, else selected
+    # typically bound to Ctrl-Space
+    # @example
+    #     bind_key(0) { add_to_selection }
+    def add_to_selection crow=@current_index-@_header_adjustment
+      @last_clicked ||= crow
+      min = [@last_clicked, crow].min
+      max = [@last_clicked, crow].max
+      case @selection_mode 
+      when :multiple
+        @widget_scrolled = true # FIXME we need a better name
+        if @selected_indices.include? crow
+          # delete from last_clicked until this one in any direction
+          min.upto(max){ |i| @selected_indices.delete i }
+          lse = ListSelectionEvent.new(min, max, self, :DELETE)
+          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) }
+          lse = ListSelectionEvent.new(min, max, self, :INSERT)
+          fire_handler :LIST_SELECTION_EVENT, lse
+        end
+      else
+      end
+      @repaint_required = true
+      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?
+      @selected_indices = []
+      @selected_index = nil
+      @old_selected_index = nil
+      # Not sure what event type I should give, DELETE or a new one, user should
+      #  understand that selection has been cleared, and ignore first two params
+      lse = ListSelectionEvent.new(0, @list.size, self, :CLEAR)
+      fire_handler :LIST_SELECTION_EVENT, lse
+      @repaint_required = true
+      @widget_scrolled = true # FIXME we need a better name
+    end
+    def is_row_selected crow=@current_index-@_header_adjustment
+      case @selection_mode 
+      when :multiple
+        @selected_indices.include? crow
+      else
+        crow == @selected_index
+      end
+    end
+    alias :is_selected? is_row_selected
+    # FIXME add adjustment and test
+    def goto_next_selection
+      return if selected_rows().length == 0 
+      row = selected_rows().sort.find { |i| i > @current_index }
+      row ||= @current_index
+      @current_index = row
+      @repaint_required = true # fire list_select XXX
+    end
+    # FIXME add adjustment and test
+    def goto_prev_selection
+      return if selected_rows().length == 0 
+      row = selected_rows().sort{|a,b| b <=> a}.find { |i| i < @current_index }
+      row ||= @current_index
+      @current_index = row
+      @repaint_required = true # fire list_select XXX
+    end
+    # add the following range to selected items, unless already present
+    # should only be used if multiple selection interval
+    def add_selection_interval ix0, ix1
+      return if @selection_mode != :multiple
+      @widget_scrolled = true # FIXME we need a better name
+      @anchor_selection_index = ix0
+      @lead_selection_index = ix1
+      ix0.upto(ix1) {|i| @selected_indices  << i unless @selected_indices.include? i }
+      lse = ListSelectionEvent.new(ix0, ix1, self, :INSERT)
+      fire_handler :LIST_SELECTION_EVENT, lse
+      #$log.debug " DLSM firing LIST_SELECTION EVENT #{lse}"
+    end
+    alias :add_row_selection_interval :add_selection_interval
+    def remove_selection_interval ix0, ix1
+      @anchor_selection_index = ix0
+      @lead_selection_index = ix1
+      @selected_indices.delete_if {|x| x >= ix0 and x <= ix1}
+      lse = ListSelectionEvent.new(ix0, ix1, self, :DELETE)
+      fire_handler :LIST_SELECTION_EVENT, lse
+    end
+    alias :remove_row_selection_interval :remove_selection_interval
+    # convenience method to select next len rows
+    def insert_index_interval ix0, len
+      @anchor_selection_index = ix0
+      @lead_selection_index = ix0+len
+      add_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
+      @repaint_required = true
+      # 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, row_count()
+    end
+    def invert_selection start_row=0 #+@_header_adjustment
+      start_row.upto(row_count()){|i| invert_row_selection i }
+    end
+     
+    def invert_row_selection row=@current_index-@_header_adjustment
+      @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)
+    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
+    # 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
+    # please override this, this is just very basic and default
+    # Please implement get_matching_indices(String).
+    def ask_select prompt="Enter selection pattern: "
+      ret = ask(prompt, String) {|q| yield q if block_given? }
+      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
+        add_row_selection_interval e,e
+      }
+      @repaint_required = true
+    end
+    def get_matching_indices pattern
+      alert "please implement this method get_matching_indices(pattern)->[] in your class  "
+      return []
+    end # mod
+    # Applications may call this or just copy and modify
+    def list_bindings
+      # what about users wanting 32 and ENTER to also go to next row automatically
+      # should make that optional, TODO
+      bind_key(32, 'toggle selection') { toggle_row_selection }
+      bind_key(0, 'range select') { add_to_selection }
+      bind_key(?+, :ask_select) # --> calls select_values
+      bind_key(?-, :ask_unselect) # please implement FIXME TODO
+      bind_key(?a, :select_all)
+      bind_key(?*, :invert_selection)
+      bind_key(?u, :clear_selection)
+      @_header_adjustment ||= 0 #  incase caller does not use
+      @_events << :LIST_SELECTION_EVENT unless @_events.include? :LIST_SELECTION_EVENT
+    end
+    def list_init_vars
+      @selected_indices = []
+      @selected_index = nil
+      @old_selected_index = nil
+      #@row_selected_symbol = ''
+      if @show_selector
+        @row_selected_symbol ||= '*'
+        @row_unselected_symbol ||= ' '
+        @left_margin ||= @row_selected_symbol.length
+      end
+    end
+    # paint the selector. Called from repaint, prior to printing data row
+    # remember to set left_margin at top of repaint method as:
+    #    @left_margin ||= @row_selected_symbol.length
+    def paint_selector crow, r, c, acolor, attrib
+      selected = is_row_selected crow
+      selection_symbol = ''
+      if @show_selector
+        if selected
+          selection_symbol = @row_selected_symbol
+        else
+          selection_symbol =  @row_unselected_symbol
+        end
+        @graphic.printstring r, c, selection_symbol, acolor,attrib
+      end
+    end
+    def selected_rows
+      @selected_indices
+    end
+  end # mod
+  class ListSelectionEvent
+    attr_accessor :firstrow, :lastrow, :source, :type
+    def initialize firstrow, lastrow, source, type
+      @firstrow = firstrow
+      @lastrow = lastrow
+      @source = source
+      @type = type
+    end
+    def to_s
+      "#{@type.to_s}, firstrow: #{@firstrow}, lastrow: #{@lastrow}, source: #{@source}"
+    end
+    def inspect
+      to_s
+    end
+  end
+end # mod

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

@@ -0,0 +1,83 @@
+module RubyCurses
+  # this module makes it possible for a textview to maintain multiple buffers
+  # The first buffer has been placed using set_content(lines, config). 
+  # After this, additional buffers mst be supplied with add_content text, config.
+  # Also, please note that after you call set_content the first time, you must call 
+  # add_content so the buffer can be accessed while cycling. will try to fix this.
+  # (I don't want to touch textview, would prefer not to write a decorator).
+
+  # TODO allow setting of a limit, so in some cases where we keep adding
+  # programatically, the 
+  module MultiBuffers
+    extend self
+
+    # add content to buffers of a textview
+    # @param [Array] text
+    # @param [Hash] options, typically :content_type => :ansi or :tmux
+    def add_content text, config={}
+      unless @_buffers
+        bind_key(?\M-n, :buffer_next)
+        bind_key(?\M-p, :buffer_prev)
+        bind_key(KEY_BACKSPACE, :buffer_prev) # backspace, already hardcoded in textview !
+        bind_key(?:, :buffer_menu)
+      end
+      @_buffers ||= []
+      @_buffers_conf ||= []
+      @_buffers << text
+      @_buffers_conf << config
+      @_buffer_ctr ||= 0
+      $log.debug "XXX:  HELP adding text #{@_buffers.size} "
+    end
+
+    # display next buffer
+    def buffer_next
+      @_buffer_ctr += 1
+      x = @_buffer_ctr
+      l = @_buffers[x]
+      @_buffer_ctr = 0 unless l
+      set_content @_buffers[@_buffer_ctr], @_buffers_conf[@_buffer_ctr]
+    end
+    #
+    # display previous buffer if any
+    def buffer_prev
+      if @_buffer_ctr < 1
+        buffer_last
+        return
+      end
+      @_buffer_ctr -= 1 if @_buffer_ctr > 0
+      x = @_buffer_ctr
+      l = @_buffers[x]
+      if l
+        set_content l, @_buffers_conf[x]
+      end
+    end
+    def buffer_last
+      @_buffer_ctr = @_buffers.count - 1
+      l = @_buffers.last
+      set_content l, @_buffers_conf.last
+    end
+    # close window, a bit clever
+    def close
+      @graphic.ungetch(?q.ord)
+    end
+    # display a menu so user can do buffer management
+    # However, how can application add to these. Or disable, such as when we 
+    # add buffer delete or buffer insert or edit
+    def buffer_menu
+      menu = PromptMenu.new self do
+        item :n, :buffer_next
+        item :p, :buffer_prev
+        item :b, :scroll_backward
+        item :f, :scroll_forward
+        item :q, :close
+        submenu :m, "submenu..." do
+          item :p, :goto_last_position
+          item :r, :scroll_right
+          item :l, :scroll_left
+        end
+      end
+      menu.display_new :title => "Buffer Menu"
+    end
+
+  end
+end

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

@@ -0,0 +1,77 @@
+## Insert order preserving hash
+# Thanks to Bill Kelly, posted on http://www.ruby-forum.com/topic/166075
+#
+class OrderedHash
+  include Enumerable
+
+  def initialize(*args, &block)
+    @h = Hash.new(*args, &block)
+    @ordered_keys = []
+  end
+
+  def []=(key, val)
+    @ordered_keys << key unless @h.has_key? key
+    @h[key] = val
+  end
+
+  def each
+    @ordered_keys.each {|k| yield(k, @h[k])}
+  end
+  alias :each_pair :each
+
+  def each_value
+    @ordered_keys.each {|k| yield(@h[k])}
+  end
+
+  def each_key
+    @ordered_keys.each {|k| yield k}
+  end
+
+  def keys
+    @ordered_keys
+  end
+
+  def values
+    @ordered_keys.map {|k| @h[k]}
+  end
+
+  def clear
+    @ordered_keys.clear
+    @h.clear
+  end
+
+  def delete(k, &block)
+    @ordered_keys.delete k
+    @h.delete(k, &block)
+  end
+
+  def reject!
+    del = []
+    each_pair {|k,v| del << k if yield k,v}
+    del.each {|k| delete k}
+    del.empty? ? nil : self
+  end
+
+  def delete_if(&block)
+    reject!(&block)
+    self
+  end
+  ## added since the normal hash will give it in unordered. so debugging sucks
+  def inspect
+    out = []
+    each do | k,v |
+      out << " #{k} => #{v} "
+    end
+    res = %Q[  { #{out.join(",\n ")} } ]
+  end
+
+  %w(merge!).each do |name|
+    define_method(name) do |*args|
+      raise NotImplementedError, "#{name} not implemented"
+    end
+  end
+
+  def method_missing(*args)
+    @h.send(*args)
+  end
+end

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

@@ -0,0 +1,67 @@
+=begin
+  * Name: ActionEvent
+  * Description: Event used to notify interested parties that an action has happened on component
+                 Usually a button press. Nothing more.
+  * Author: rkumar (arunachalesha)
+  
+  --------
+  * Date: 2010-09-12 18:53 
+  * License:
+    Same as Ruby's License (http://www.ruby-lang.org/LICENSE.txt)
+
+=end
+
+# Event created when state changed (as in ViewPort)
+module RubyCurses
+  # source - as always is the object whose event has been fired
+  # id     - event identifier (seems redundant since we bind events often separately.
+  # event  - is :PRESS
+  # action_command - command string associated with event (such as title of button that changed
+  ActionEvent = Struct.new(:source, :event, :action_command) do
+    # This should always return the most relevant text associated with this object
+    # so the user does not have to go through the source object's documentation.
+    # It should be a user-friendly string 
+    # @return text associated with source (label of button)
+    def text
+      source.text
+    end
+
+    # This is similar to text and can often be just an alias.
+    # However, i am putting this for backward compatibility with programs
+    # that received the object and called it's getvalue. It is better to use text.
+    # @return text associated with source (label of button)
+    def getvalue
+      source.getvalue
+    end
+  end
+  # a derivative of Action Event for textviews
+  # We allow a user to press ENTER on a row and use that for processing.
+  # We are basically using TextView as a list in which user can scroll around
+  # and move cursor at will.
+  class TextActionEvent < ActionEvent
+    # current_index or line number starting 0
+    attr_accessor :current_index
+    # cursor position on the line
+    attr_accessor :curpos
+    def initialize source, event, action_command, current_index, curpos
+      super source, event, action_command
+      @current_index = current_index
+      @curpos = curpos
+    end
+    # the text of the line on which the user is
+    def text
+      source.current_value.to_s
+    end
+    # the word under the cursor TODO
+    # if its a text with pipe delim, then ??
+    def word_under_cursor line=text(), pos=@curpos, delim=" "
+      line ||= text()
+      pos ||= @curpos
+      finish = line.index(delim, pos)
+      start = line.rindex(delim,pos)
+      finish = -1 if finish.nil?
+      start = 0 if start.nil?
+      return line[start..finish]
+    end
+  end
+end