clevic 0.11.1 → 0.12.0

data/lib/clevic/table_view.rb

@@ -1,27 +1,28 @@
 require 'rubygems'
 require 'Qt4'
 require 'fastercsv'
-require 'clevic/model_builder.rb'
 require 'qtext/action_builder.rb'
 
+require 'clevic/model_builder.rb'
+require 'clevic/filter_command.rb'
+
 module Clevic
 
 # The view class
 class TableView < Qt::TableView
   include ActionBuilder
   
-  # whether the model is currently filtered
+  # the current filter command
   # TODO better in QAbstractSortFilter?
   attr_accessor :filtered
-  def filtered?; self.filtered; end
+  def filtered?; !@filtered.nil?; end
   
   # status_text is emitted when this object was to display something in the status bar
   # error_test is emitted when an error of some kind must be displayed to the user.
   # filter_status is emitted when the filtering changes. Param is true for filtered, false for not filtered.
   signals 'status_text(QString)', 'filter_status(bool)'
   
-  # model_builder_record is:
-  # - an ActiveRecord::Base subclass that includes Clevic::Record
+  # arg is:
   # - an instance of Clevic::View
   # - an instance of TableModel
   def initialize( arg, parent = nil, &block )
@@ -51,7 +52,7 @@ class TableView < Qt::TableView
     end
       
     # see closeEditor
-    @index_override = false
+    @next_index = nil
     
     # set some Qt things
     self.horizontal_header.movable = false
@@ -59,7 +60,6 @@ class TableView < Qt::TableView
     # but need to change the shortcut ideas of next and previous rows
     self.vertical_header.movable = false
     self.sorting_enabled = false
-    @filtered = false
     
     self.context_menu_policy = Qt::ActionsContextMenu
   end
@@ -74,9 +74,9 @@ class TableView < Qt::TableView
     end
   end
   
-  # find the row index for the given field
+  # find the row index for the given field id (symbol)
   def field_column( field )
-    model.fields.each_with_index {|x,i| return i if x.attribute == field }
+    raise "use model.field_column( field )"
   end
     
   # return menu actions for the model, or an empty array if there aren't any
@@ -104,12 +104,13 @@ class TableView < Qt::TableView
     # add model actions, if they're defined
     list( :model ) do |ab|
       entity_view.define_actions( self, ab )
+      separator
     end
-    separator
     
     # list of actions in the edit menu
     list( :edit ) do
       #~ new_action :action_cut, 'Cu&t', :shortcut => Qt::KeySequence::Cut
+      action :action_copy, '&Save', :shortcut => Qt::KeySequence::Save, :method => :save_current_row
       action :action_copy, '&Copy', :shortcut => Qt::KeySequence::Copy, :method => :copy_current_selection
       action :action_paste, '&Paste', :shortcut => Qt::KeySequence::Paste, :method => :paste
       separator
@@ -147,7 +148,13 @@ class TableView < Qt::TableView
       (selection_range.top..selection_range.bottom).each do |row|
         row_ary = Array.new
         selection_model.selected_indexes.each do |index|
-          row_ary << index.gui_value if index.row == row
+          if index.row == row
+            value = index.gui_value
+            row_ary << 
+            unless value.nil?
+              index.field.do_format( value )
+            end
+          end
         end
         text << row_ary.to_csv
       end
@@ -162,12 +169,13 @@ class TableView < Qt::TableView
     text = Qt::Application::clipboard.text.chomp
     arr = FasterCSV.parse( text )
     
+    selection_model.selected_indexes.
     return true if selection_model.selection.size != 1
     
-    selection_range = selection_model.selection[0]
-    selected_index = selection_model.selected_indexes[0]
+    selection_range = selection_model.selection.first
+    selected_index = selection_model.selected_indexes.first
     
-    if selection_range.single_cell?
+    if selection_model.selection.size == 1 && selection_range.single_cell?
       # only one cell selected, so paste like a spreadsheet
       if text.empty?
         # just clear the current selection
@@ -176,11 +184,29 @@ class TableView < Qt::TableView
         paste_to_index( selected_index, arr )
       end
     else
-      return true if selection_range.height != arr.size
-      return true if selection_range.width != arr[0].size
-      
-      # size is the same, so do the paste
-      paste_to_index( selected_index, arr )
+      if arr.size == 1 && arr.first.size == 1
+        # only one value to paste, and multiple selection, so
+        # set all selected indexes to the value
+        value = arr.first.first
+        selection_model.selected_indexes.each do |index|
+          model.setData( index, value.to_variant, Qt::PasteRole )
+          # save records to db
+          model.save( index )
+        end
+        
+        # notify of changed data
+        model.data_changed do |change|
+          sorted = selection_model.selected_indexes.sort
+          change.top_left = sorted.first
+          change.bottom_right = sorted.last
+        end
+      else
+        return true if selection_range.height != arr.size
+        return true if selection_range.width != arr.first.size
+        
+        # size is the same, so do the paste
+        paste_to_index( selected_index, arr )
+      end
     end
   end
   
@@ -217,7 +243,7 @@ class TableView < Qt::TableView
     previous_value = one_up_index.attribute_value
     if current_index.attribute_value != previous_value
       current_index.attribute_value = previous_value
-      emit model.dataChanged( current_index, current_index )
+      model.data_changed( current_index )
     end
   end
   
@@ -239,7 +265,7 @@ class TableView < Qt::TableView
       one_up_right = current_index.choppy {|i| i.row -= 1; i.column += 1 }
       sanity_check_types( one_up_right, current_index )
       current_index.attribute_value = one_up_right.attribute_value
-      emit model.dataChanged( current_index, current_index )
+      model.data_changed( current_index )
     end
   end
   
@@ -252,14 +278,14 @@ class TableView < Qt::TableView
       one_up_left = current_index.choppy { |i| i.row -= 1; i.column -= 1 }
       sanity_check_types( one_up_left, current_index )
       current_index.attribute_value = one_up_left.attribute_value
-      emit model.dataChanged( current_index, current_index )
+      model.data_changed( current_index )
     end
   end
   
   def insert_current_date
     sanity_check_read_only
     current_index.attribute_value = Time.now
-    emit model.dataChanged( current_index, current_index )
+    model.data_changed( current_index )
   end
   
   def open_editor
@@ -329,15 +355,20 @@ class TableView < Qt::TableView
   # force a complete reload of the current tab's data
   def refresh
     override_cursor( Qt::BusyCursor ) do
-      model.reload_data
+      restore_entity do
+        model.reload_data
+      end
     end
   end
   
-  # toggle the filter, based on current selection.
-  def filter_by_current( bool_filter )
-    # TODO if there's no selection, use the current index instead
-    filter_by_indexes( selection_model.selected_indexes )
-    emit filter_status( bool_filter )
+  # return an array of the current selection, or the
+  # current index in an array if the selection is empty
+  def selection_or_current
+    indexes_or_current( selection_model.selected_indexes )
+  end
+  
+  def selected_rows_or_current
+    indexes_or_current( selection_model.row_indexes )
   end
   
   # alternative access for auto_size_column
@@ -375,6 +406,7 @@ class TableView < Qt::TableView
     style.sizeFromContents( Qt::Style::CT_HeaderSection, opt, size );
   end
   
+  # TODO is this even used?
   def relational_delegate( attribute, options )
     col = model.attributes.index( attribute )
     delegate = RelationalDelegate.new( self, model.columns[col], options )
@@ -408,7 +440,6 @@ class TableView < Qt::TableView
     super
     
     # set delegates
-    #~ self.item_delegate = Clevic::ItemDelegate.new( self, field )
     model.fields.each_with_index do |field, index|
       set_item_delegate_for_column( index, field.delegate )
     end
@@ -468,8 +499,13 @@ class TableView < Qt::TableView
     end
     
     # make the gui refresh
-    bottom_right_index = top_left_index.choppy {|i| i.row += csv_arr.size - 1; i.column += csv_arr[0].size - 1 }
-    emit model.dataChanged( top_left_index, bottom_right_index )
+    model.data_changed do |change|
+      change.top_left = top_left_index
+      change.bottom_right = top_left_index.choppy do |i|
+        i.row += csv_arr.size - 1
+        i.column += csv_arr.first.size - 1
+      end
+    end
     emit model.headerDataChanged( Qt::Vertical, top_left_index.row, top_left_index.row + csv_arr.size )
   end
   
@@ -508,14 +544,16 @@ class TableView < Qt::TableView
         cells_deleted = true
       end
       
-      # deletes were done, so emit dataChanged
+      # deletes were done, so call data_changed
       if cells_deleted
         # save affected rows
-        selection_model.selected_rows.each { |index| index.entity.save }
+        selection_model.row_indexes.each do |index|
+          index.entity.save
+        end
         
         # emit data changed for all ranges
         selection_model.selection.each do |selection_range|
-          emit dataChanged( selection_range.top_left, selection_range.bottom_right )
+          model.data_changed( selection_range )
         end
       end
     end
@@ -603,37 +641,33 @@ class TableView < Qt::TableView
   
   # save record whenever its row is exited
   def currentChanged( current_index, previous_index )
-    @index_override = false
+    @next_index = nil
     if current_index.row != previous_index.row
       save_row( previous_index )
     end
     super
   end
   
-  # this is to allow entity model UI handlers to tell the view
-  # where to move the current editing index to. If it's left blank
-  # default is based on the editing hint.
-  # see closeEditor
+  # This is to allow entity model UI handlers to tell the view
+  # whence to move the cursor when the current editor closes
+  # (see closeEditor).
   def override_next_index( model_index )
-    set_current_index( model_index )
-    @index_override = true
+    @next_index = model_index
   end
   
-  # call set_current_index with model_index unless override is true.
+  # Call set_current_index with next_index ( from override_next_index )
+  # or model_index, in that order. Set next_index to nil afterwards.
   def set_current_unless_override( model_index )
-    if !@index_override
-      # move to next cell
-      # Qt seems to take care of tab wraparound
-      set_current_index( model_index )
-    end
-    @index_override = false
+    set_current_index( @next_index || model_index )
+    @next_index = nil
   end
   
   # work around situation where an ItemDelegate is open
   # when the surrouding tab is changed, but the right events
   # don't arrive.
   def hideEvent( event )
-    super
+    # can't call super here, for some reason. Qt binding says method not found.
+    # super
     @hiding = true
   end
   
@@ -677,59 +711,94 @@ class TableView < Qt::TableView
         super
     end
   end
-
-  # If self.filter is false, use the data in the indexes to filter the data set;
-  # otherwise turn filtering off.
-  # Sets self.filter to true if filtering worked, false otherwise.
-  # indexes is a collection of Qt::ModelIndex
-  # TODO combine with filter_by_current
-  def filter_by_indexes( indexes )
-    unless indexes[0].field.filterable?
-      emit status_text( "Can't filter on #{indexes[0].field.label}" )
-      return
+  
+  # toggle the filter, based on current selection.
+  def filter_by_current( bool_filter )
+    filter_by_indexes( selection_or_current )
+  end
+  
+  def filter_by_options( args )
+    filtered.undo if filtered?
+    self.filtered = FilterCommand.new( self, [], args )
+    emit filter_status( filtered.doit )
+  end
+  
+  # Save the current entity, do something, then restore
+  # the cursor position to the entity if possible.
+  # Return the result of the block.
+  def restore_entity( &block )
+    save_entity = current_index.entity
+    unless save_entity.nil?
+      save_entity.save if save_entity.changed?
+      save_index = current_index
     end
     
-    save_entity = current_index.entity
-    save_entity.save if save_entity.changed?
-    save_index = current_index
+    retval = yield
     
-    unless self.filtered
-      # filter by current selection
-      # TODO handle a multiple-selection
-      if indexes.empty?
-        self.filtered = false
-      elsif indexes.size > 1
+    # find the entity if possible
+    select_entity( save_entity, save_index.column ) unless save_entity.nil?
+    
+    retval
+  end
+
+  # Filter by the value in the current index.
+  # indexes is a collection of Qt::ModelIndex
+  def filter_by_indexes( indexes )
+    case
+      when filtered?
+        # unfilter
+        restore_entity do
+          filtered.undo
+          self.filtered = nil
+          # update status bar
+          emit status_text( nil )
+          emit filter_status( false )
+        end
+        
+      when indexes.empty?
+        emit status_text( "No field selected for filter" )
+        
+      when !indexes.first.field.filterable?
+        emit status_text( "Can't filter on #{indexes.first.field.label}" )
+      
+      when indexes.size > 1
         emit status_text( "Can't do multiple selection filters yet" )
-        self.filtered = false
-      end
       
-      if indexes[0].entity.new_record?
+      when indexes.first.entity.new_record?
         emit status_text( "Can't filter on a new row" )
-        self.filtered = false
-        return
+        
       else
-        model.reload_data( :conditions => { indexes[0].field_name => indexes[0].field_value } )
-        self.filtered = true
+        self.filtered = FilterCommand.new( self, indexes, :conditions => { indexes.first.field_name => indexes.first.field_value } )
+        # try to end up on the same entity, even after the filter
+        restore_entity do
+          emit filter_status( filtered.doit )
+        end
+        # update status bar
+        emit status_text( filtered.status_message )
       end
-    else
-      # unfilter
-      model.reload_data( :conditions => {} )
-      self.filtered = false
+      filtered?
+  end
+  
+  # Move to the row for the given entity and the given column.
+  # If column is a symbol,
+  # field_column will be called to find the integer index.
+  def select_entity( entity, column = nil )
+    # sanity check that the entity can actually be found
+    Kernel.raise "entity is nil" if entity.nil?
+    unless entity.class == model.entity_class
+      Kernel.raise "entity #{entity.class.name} does not match class #{model.entity_class.name}"
     end
     
     # find the row for the saved entity
     found_row = override_cursor( Qt::BusyCursor ) do
-      model.collection.index_for_entity( save_entity )
+      model.collection.index_for_entity( entity )
     end
     
     # create a new index and move to it
     unless found_row.nil?
-      self.current_index = model.create_index( found_row, save_index.column )
-      if self.filtered?
-        emit status_text( "Filtered on #{current_index.field.label} = #{current_index.gui_value}" )
-      else
-        emit status_text( nil )
-      end
+      column = model.field_column( column ) if column.is_a? Symbol
+      selection_model.clear
+      self.current_index = model.create_index( found_row, column || 0 )
     end
   end
   
@@ -743,17 +812,63 @@ class TableView < Qt::TableView
   def search( search_criteria )
     indexes = model.search( current_index, search_criteria )
     if indexes.size > 0
-      emit status_text( "Found #{search_criteria.search_text} at row #{indexes[0].row}" )
+      emit status_text( "Found #{search_criteria.search_text} at row #{indexes.first.row}" )
       selection_model.clear
-      self.current_index = indexes[0]
+      self.current_index = indexes.first
     else
       emit status_text( "No match found for #{search_criteria.search_text}" )
     end
   end
 
-  def itemDelegateForColumn( column )
-    puts "itemDelegateForColumn #{column}"
-    super
+  # find the TableView instance for the given entity_view
+  # or entity_model. Return nil if no match found.
+  # TODO doesn't really belong here because TableView will not always
+  # be in a TabWidget context.
+  def find_table_view( entity_model_or_view )
+    parent.children.find do |x|
+      if x.is_a? TableView
+        x.model.entity_view.class == entity_model_or_view || x.model.entity_class == entity_model_or_view
+      end
+    end
+  end
+  
+  # execute the block with the TableView instance
+  # currently handling the entity_model_or_view.
+  # Don't execute the block if nothing is found.
+  # TODO doesn't really belong here because TableView will not always
+  # be in a TabWidget context.
+  def with_table_view( entity_model_or_view, &block )
+    tv = find_table_view( entity_model_or_view )
+    yield( tv ) unless tv.nil?
+  end
+  
+  # make this window visible if it's in a TabWidget
+  # TODO doesn't really belong here because TableView will not always
+  # be in a TabWidget context.
+  def raise
+    # the tab's parent is a StackedWiget, and its parent is TabWidget
+    tab_widget = parent.parent
+    tab_widget.current_widget = self if tab_widget.class == Qt::TabWidget
+  end
+  
+protected
+
+  # return either the set of indexes with all invalid indexes
+  # remove, or the current selection.
+  def indexes_or_current( indexes )
+    retval =
+    if indexes.empty?
+      [ current_index ]
+    else
+      indexes
+    end
+    
+    # strip out bad indexes, so other things don't have to check
+    # can't use select because copying indexes causes an abort
+    #~ retval.select{|x| x != nil && x.valid?}
+    retval.reject!{|x| x.nil? || !x.valid?}
+    # retval needed here because reject! returns nil if nothing was rejected
+    retval
   end
   
 end