clevic 0.5.1

data/lib/clevic/table_model.rb

@@ -0,0 +1,431 @@
+require 'Qt4'
+require 'date'
+
+require 'qtext/flags.rb'
+require 'qtext/extensions.rb'
+
+require 'clevic/extensions.rb'
+require 'clevic/model_column'
+
+module Clevic
+
+=begin rdoc
+This table model allows an ActiveRecord or ActiveResource to be used as a
+basis for a Qt::AbstractTableModel for viewing in a Qt::TableView.
+
+Initial idea by Richard Dale and Silvio Fonseca.
+
+* labels are the headings in the table view
+
+* dots are the dotted attribute paths that specify how to get values from
+  the underlying ActiveRecord model
+
+* attribute_paths is a collection of attribute symbols. It comes from
+  dots, and is split on /\./
+
+* attributes are the first-level of the dots
+
+* collection is the set of ActiveRecord model objects (also called entities)
+=end
+class TableModel < Qt::AbstractTableModel
+  include QtFlags
+  
+  attr_accessor :collection, :dots, :attributes, :attribute_paths, :labels
+
+  signals(
+    # index where error occurred, value, message
+    'data_error(QModelIndex,QVariant,QString)',
+    # top_left, bottom_right
+    'dataChanged(const QModelIndex&,const QModelIndex&)'
+  )
+  
+  def initialize( builder )
+    super()
+    @metadatas = []
+    @builder = builder
+  end
+  
+  def hasChildren( *args )
+    puts 'hasChildren'
+    puts "args: #{args.inspect}"
+    super
+  end
+  
+  def sort( col, order )
+    puts 'sort'
+    puts "col: #{col.inspect}"
+    #~ Qt::AscendingOrder
+    #~ Qt::DescendingOrder
+    puts "order: #{order.inspect}"
+    super
+  end
+  
+  def match( start_index, role, search_value, hits, match_flags )
+    #~ Qt::MatchExactly	0	Performs QVariant-based matching.
+    #~ Qt::MatchFixedString	8	Performs string-based matching. String-based comparisons are case-insensitive unless the MatchCaseSensitive flag is also specified.
+    #~ Qt::MatchContains	1	The search term is contained in the item.
+    #~ Qt::MatchStartsWith	2	The search term matches the start of the item.
+    #~ Qt::MatchEndsWith	3	The search term matches the end of the item.
+    #~ Qt::MatchCaseSensitive	16	The search is case sensitive.
+    #~ Qt::MatchRegExp	4	Performs string-based matching using a regular expression as the search term.
+    #~ Qt::MatchWildcard	5	Performs string-based matching using a string with wildcards as the search term.
+    #~ Qt::MatchWrap	32	Perform a search that wraps around, so that when the search reaches the last item in the model, it begins again at the first item and continues until all items have been examined.
+    super
+  end
+  
+  def build_dots( dots, attrs, prefix="" )
+    attrs.inject( dots ) do |cols, a|
+      if a[1].respond_to? :attributes
+        build_keys(cols, a[1].attributes, prefix + a[0] + ".")
+      else
+        cols << prefix + a[0]
+      end
+    end
+  end
+  
+  def model_class
+    @builder.model_class
+  end
+  
+  # cache metadata (ActiveRecord#column_for_attribute) because it's not going
+  # to change over the lifetime of the table
+  # if the column is an attribute, create a ModelColumn
+  # TODO use ActiveRecord::Base.reflections instead
+  def metadata( column )
+    if @metadatas[column].nil?
+      meta = model_class.columns_hash[attributes[column].to_s]
+      if meta.nil?
+        meta = model_class.columns_hash[ "#{attributes[column]}_id" ]
+        if meta.nil?
+          return nil
+        else
+          @metadatas[column] = ModelColumn.new( attributes[column], :association, meta )
+        end
+      else
+        @metadatas[column] = meta
+      end
+    end
+    @metadatas[column]
+  end
+  
+  def add_new_item
+    # 1 new row
+    begin_insert_rows( Qt::ModelIndex.invalid, row_count, row_count )
+    collection << model_class.new
+    end_insert_rows
+  end
+  
+  # rows is a collection of integers specifying row indices to remove
+  # TODO call begin_remove and end_remove around the whole block
+  def remove_rows( rows )
+    # delete from the end to avoid holes affecting the indexing
+    rows.sort.reverse.each do |index|
+      # remove the item from the collection
+      begin_remove_rows( Qt::ModelIndex.invalid, index, index )
+      removed = collection.delete_at( index )
+      end_remove_rows
+      # destroy the db object, and its table row
+      removed.destroy
+    end
+  end
+  
+  # save the AR model at the given index, if it's dirty
+  def save( index )
+    item = collection[index.row]
+    return false if item.nil?
+    if item.changed?
+      if item.valid?
+        item.save
+      else
+        false
+      end
+    else
+      # AR model not changed
+      true
+    end
+  end
+  
+  def rowCount( parent = nil )
+    collection.size
+  end
+
+  def row_count
+    collection.size
+  end
+  
+  def columnCount( parent = nil )
+    dots.size
+  end
+  
+  def column_count
+    dots.size
+  end
+  
+  def flags( model_index )
+    # TODO don't return IsEditable if the model is read-only
+    retval = qt_item_is_editable | super( model_index )
+    if model_index.metadata.type == :boolean
+      retval = item_boolean_flags
+    end
+    retval
+  end
+  
+  def fetchMore( parent )
+    #~ puts "fetchMore"
+    #~ reload_data if canFetchMore( parent )
+  end
+  
+  def canFetchMore( parent )
+    false
+    #~ puts "canFetchMore"
+    #~ puts "self.collection.size: #{self.collection.size.inspect}"
+    #~ puts "self.collection.sql_count: #{self.collection.sql_count.inspect}"
+    # Here, test for self.collection.size - new_records != self.collection.sql_count
+    # maintaining new_records will be the tricky part
+    #~ result = self.collection.size != self.collection.sql_count
+    #~ puts "result: #{result.inspect}"
+    #~ result
+  end
+
+  def reload_data( options = {} )
+    # renew cache
+    self.collection = self.collection.renew( options )
+    # tell the UI we had a major data change
+    reset
+  end
+
+  # values for horizontal and vertical headers
+  def headerData( section, orientation, role )
+    value = 
+    case role
+      when qt_display_role
+        case orientation
+          when Qt::Horizontal
+            @labels[section]
+          when Qt::Vertical
+            # don't force a fetch from the db
+            if collection.cached_at?( section )
+              collection[section].id
+            else
+              section
+            end
+        end
+        
+      when qt_text_alignment_role
+        case orientation
+          when Qt::Vertical
+            Qt::AlignRight | Qt::AlignVCenter
+        end
+          
+      when Qt::SizeHintRole
+        # anything other than nil here makes the headers disappear.
+        nil
+        
+      when qt_tooltip_role
+        if orientation == Qt::Horizontal
+          @builder.fields[section].tooltip
+        end
+        
+      else
+        #~ puts "headerData section: #{section}, role: #{const_as_string(role)}" if $options[:debug]
+        nil
+    end
+    
+    return value.to_variant
+  end
+  
+  # Provide data to UI.
+  def data( index, role = qt_display_role )
+    #~ puts "data for index: #{index.inspect} and role: #{const_as_string role}"
+    begin
+      retval =
+      case role
+        when qt_display_role, qt_edit_role
+          # boolean values generally don't have text next to them in this context
+          # check explicitly to avoid fetching the entity from
+          # the model's collection when we don't need to
+          unless index.metadata.type == :boolean
+            begin
+              value = index.gui_value
+              unless value.nil?
+                field = @builder.fields[index.column]
+                field.do_format( value )
+              end
+            rescue Exception => e
+              puts e.backtrace
+            end
+          end
+          
+        when qt_checkstate_role
+          if index.metadata.type == :boolean
+            index.gui_value ? qt_checked : qt_unchecked
+          end
+          
+        when qt_text_alignment_role
+          @builder.fields[index.column].alignment
+
+        # these are just here to make debug output quieter
+        when qt_size_hint_role;
+        when qt_background_role;
+        when qt_font_role;
+        when qt_foreground_role;
+        when qt_decoration_role;
+        
+        # provide a tooltip when an empty relational field is encountered
+        when qt_tooltip_role
+          if index.metadata.type == :association
+            @builder.fields[index.column].delegate.if_empty_message
+          end
+          
+        else
+          puts "data index: #{index}, role: #{const_as_string(role)}" if $options[:debug]
+          nil
+      end
+      
+      # return a variant
+      retval.to_variant
+    rescue Exception => e
+      puts e.backtrace.join( "\n" )
+      puts "#{index.inspect} #{value.inspect} #{index.entity.inspect} #{e.message}"
+      nil.to_variant
+    end
+  end
+
+  # data sent from UI
+  def setData( index, variant, role = qt_edit_role )
+    if index.valid?
+      case role
+      when qt_edit_role
+        # Don't allow the primary key to be changed
+        return false if index.attribute == :id
+        
+        if ( index.column < 0 || index.column >= dots.size )
+          raise "invalid column #{index.column}" 
+        end
+        
+        type = index.metadata.type
+        value = variant.value
+        
+        # translate the value from the ui to something that
+        # the AR model will understand
+        begin
+          index.gui_value =
+          case
+            when value.class.name == 'Qt::Date'
+              Date.new( value.year, value.month, value.day )
+              
+            when value.class.name == 'Qt::Time'
+              Time.new( value.hour, value.min, value.sec )
+              
+            # allow flexibility in entering dates. For example
+            # 16jun, 16-jun, 16 jun, 16 jun 2007 would be accepted here
+            # TODO need to be cleverer about which year to use
+            # for when you're entering 16dec and you're in the next
+            # year
+            when type == :date && value =~ %r{^(\d{1,2})[ /-]?(\w{3})$}
+              Date.parse( "#$1 #$2 #{Time.now.year.to_s}" )
+            
+            # if a digit only is entered, fetch month and year from
+            # previous row
+            when type == :date && value =~ %r{^(\d{1,2})$}
+              previous_entity = collection[index.row - 1]
+              # year,month,day
+              Date.new( previous_entity.date.year, previous_entity.date.month, $1.to_i )
+            
+            # this one is mostly to fix date strings that have come
+            # out of the db and been formatted
+            when type == :date && value =~ %r{^(\d{2})[ /-](\w{3})[ /-](\d{2})$}
+              Date.parse( "#$1 #$2 20#$3" )
+            
+            # allow lots of flexibility in entering times
+            # 01:17, 0117, 117, 1 17, are all accepted
+            when type == :time && value =~ %r{^(\d{1,2}).?(\d{2})$}
+              Time.parse( "#$1:#$2" )
+              
+            else
+              value
+          end
+          
+          emit dataChanged( index, index )
+          # value conversion was successful
+          true
+        rescue Exception => e
+          puts e.backtrace.join( "\n" )
+          puts e.message
+          emit data_error( index, variant, e.message )
+          # value conversion was not successful
+          false
+        end
+        
+      when qt_checkstate_role
+        if index.metadata.type == :boolean
+          index.entity.toggle!( index.attribute )
+          true
+        else
+          false
+        end
+      
+      # user-defined role
+      # TODO this only works with single-dotted paths
+      when qt_paste_role
+        if index.metadata.type == :association
+          field = @builder.fields[index.column]
+          association_class = field.class_name.constantize
+          candidates = association_class.find( :all, :conditions => [ "#{field.attribute_path[1]} = ?", variant.value ] )
+          case candidates.size
+            when 0; puts "No match for #{variant.value}"
+            when 1; index.attribute_value = candidates[0]
+            else; puts "Too many for #{variant.value}"
+          end
+        else
+          index.attribute_value = variant.value
+        end
+        true
+        
+      else
+        puts "role: #{role.inspect}"
+        true
+        
+      end
+    else
+      false
+    end
+  end
+  
+  # return a set of indexes that match the search criteria
+  def search( start_index, search_criteria )
+    # get the search value parameter, in SQL format
+    search_value =
+    if search_criteria.whole_words?
+      "% #{search_criteria.search_text} %"
+    else
+      "%#{search_criteria.search_text}%"
+    end
+
+    # build up the conditions
+    bits = collection.build_sql_find( start_index.entity, search_criteria.direction )
+    conditions = "#{model_class.connection.quote_column_name( start_index.field_name )} ilike :search_value"
+    conditions += ( " and " + bits[:sql] ) unless search_criteria.from_start?
+    params = { :search_value => search_value }
+    params.merge!( bits[:params] ) unless search_criteria.from_start?
+    #~ puts "conditions: #{conditions.inspect}"
+    #~ puts "params: #{params.inspect}"
+    # find the first match
+    entity = model_class.find(
+      :first,
+      :conditions => [ conditions, params ],
+      :order => search_criteria.direction == :forwards ? collection.order : collection.reverse_order
+    )
+    
+    # return matched indexes
+    if entity != nil
+      found_row = collection.index_for_entity( entity )
+      [ create_index( found_row, start_index.column ) ]
+    else
+      []
+    end
+  end
+  
+end
+
+end #module

data/lib/clevic/table_view.rb

@@ -0,0 +1,479 @@
+require 'rubygems'
+require 'Qt4'
+require 'fastercsv'
+require 'clevic/model_builder.rb'
+
+module Clevic
+
+# The view class, implementing neat shortcuts and other pleasantness
+class TableView < Qt::TableView
+  attr_reader :model_class, :builder
+  # whether the model is currently filtered
+  # TODO better in QAbstractSortFilter?
+  attr_accessor :filtered
+  
+  # this is emitted when this object was to display something in the status bar
+  signals 'status_text(QString)'
+  
+  def initialize( model_class, parent, *args )
+    super( parent )
+    
+    # the AR entity class
+    @model_class = model_class
+    
+    # see closeEditor
+    @index_override = false
+    
+    # set some Qt things
+    self.horizontal_header.movable = false
+    # TODO might be useful to allow movable vertical rows,
+    # but need to change the shortcut ideas of next and previous rows
+    self.vertical_header.movable = false
+    self.sorting_enabled = false
+    @filtered = false
+    
+    # turn off "Object#type deprecated" messages
+    $VERBOSE = nil
+  end
+  
+  def create_model( &block )
+    raise "provide a block" unless block
+    @builder = Clevic::ModelBuilder.new( self )
+    @builder.instance_eval( &block )
+    @builder.build
+    model.connect SIGNAL( 'dataChanged ( const QModelIndex &, const QModelIndex & )' ) do |top_left, bottom_right|
+      if @model_class.respond_to?( :data_changed )
+        @model_class.data_changed( top_left, bottom_right, self )
+      end
+    end
+    self
+  end
+
+  # alternative access for auto_size_column
+  def auto_size_attribute( attribute, sample )
+    col = model.attributes.index( attribute )
+    self.set_column_width( col, column_size( col, sample ).width )
+  end
+  
+  # set the size of the column from the sample
+  def auto_size_column( col, sample )
+    self.set_column_width( col, column_size( col, sample ).width )
+  end
+
+  # set the size of the column from the string value of the data
+  # mostly copied from qheaderview.cpp:2301
+  def column_size( col, data )
+    opt = Qt::StyleOptionHeader.new
+    
+    # fetch font size
+    fnt = font
+    #~ fnt.bold = true
+    opt.fontMetrics = Qt::FontMetrics.new( fnt )
+    
+    # set data 
+    opt.text = data.to_s
+    
+    # icon size. Not needed
+    #~ variant = d->model->headerData(logicalIndex, d->orientation, Qt::DecorationRole);
+    #~ opt.icon = qvariant_cast<QIcon>(variant);
+    #~ if (opt.icon.isNull())
+        #~ opt.icon = qvariant_cast<QPixmap>(variant);
+    
+    size = Qt::Size.new( 100, 30 )
+    # final parameter could be header section
+    style.sizeFromContents( Qt::Style::CT_HeaderSection, opt, size );
+  end
+  
+  def relational_delegate( attribute, options )
+    col = model.attributes.index( attribute )
+    delegate = RelationalDelegate.new( self, model.columns[col], options )
+    set_item_delegate_for_column( col, delegate )
+  end
+  
+  def delegate( attribute, delegate_class, options = nil )
+    col = model.attributes.index( attribute )
+    delegate = delegate_class.new( self, attribute, options )
+    set_item_delegate_for_column( col, delegate )
+  end
+  
+  # is current_index on the last row?
+  def last_row?
+    current_index.row == model.row_count - 1
+  end
+  
+  # is current_index on the bottom_right cell?
+  def last_cell?
+    current_index.row == model.row_count - 1 && current_index.column == model.column_count - 1
+  end
+  
+  # make sure row size is correct
+  # show error messages for data
+  def setModel( model )
+    vertical_header.default_section_size = vertical_header.minimum_section_size
+    super
+    
+    model.connect( SIGNAL( 'data_error(QModelIndex, QVariant, QString)' ) ) do |index,variant,msg|
+      error_message = Qt::ErrorMessage.new( self )
+      error_message.show_message( "Incorrect value '#{variant.value}' entered for field [#{index.attribute.to_s}].\nMessage was: #{msg}" )
+      error_message.show
+    end
+  end
+  
+  # and override this because the Qt bindings don't call
+  # setModel otherwise
+  def model=( model )
+    setModel( model )
+    resize_columns
+  end
+  
+  # resize all fields based on heuristics rather
+  # than iterating through the entire data model
+  def resize_columns
+    @builder.fields.each_with_index do |field, index|
+      auto_size_column( index, field.sample )
+    end
+  end
+  
+  def moveCursor( cursor_action, modifiers )
+    # TODO use this as a preload indicator
+    super
+  end
+
+  # paste a CSV array to the index
+  # TODO make additional rows if we need them, or at least check for enough space
+  def paste_to_index( top_left_index, csv_arr )
+    csv_arr.each_with_index do |row,row_index|
+      row.each_with_index do |field, field_index|
+        cell_index = model.create_index( top_left_index.row + row_index, top_left_index.column + field_index )
+        model.setData( cell_index, field.to_variant, Qt::PasteRole )
+      end
+      # save records to db
+      model.save( model.create_index( top_left_index.row + row_index, 0 ) )
+    end
+    
+    # make the gui refresh
+    bottom_right_index = model.create_index( top_left_index.row + csv_arr.size - 1, top_left_index.column + csv_arr[0].size - 1 )
+    emit model.dataChanged( top_left_index, bottom_right_index )
+    emit model.headerDataChanged( Qt::Vertical, top_left_index.row, top_left_index.row + csv_arr.size )
+  end
+  
+  def delete_multiple_cells?
+    # go ahead with delete if there's only 1 cell, or the user says OK
+    delete_ok =
+    if selection_model.selected_indexes.size > 1
+      # confirmation message, until there are undos
+      msg = Qt::MessageBox.new(
+        Qt::MessageBox::Question,
+        'Multiple Delete',
+        'Are you sure you want to delete multiple cells?',
+        Qt::MessageBox::Yes | Qt::MessageBox::No,
+        self
+      )
+      msg.exec == Qt::MessageBox::Yes
+    else
+      true
+    end
+  end
+    
+  def delete_cells
+    cells_deleted = false
+    
+    # do delete
+    if delete_multiple_cells?
+      selection_model.selected_indexes.each do |index|
+        index.attribute_value = nil
+        cells_deleted = true
+      end
+    end
+    
+    # deletes were done, so emit dataChanged
+    if cells_deleted
+      # emit data changed for all ranges
+      selection_model.selection.each do |selection_range|
+        emit dataChanged( selection_range.top_left, selection_range.bottom_right )
+      end
+    end
+  end
+  
+  def keyPressEvent( event )
+    # for some reason, trying to call another method inside
+    # the begin .. rescue block throws a superclass method not
+    # found error. Weird.
+    begin
+      # call to model class for shortcuts
+      if model.model_class.respond_to?( :key_press_event )
+        begin
+          model_result = model.model_class.key_press_event( event, current_index, self )
+          return model_result if model_result != nil
+        rescue Exception => e
+          puts e.backtrace
+          error_message = Qt::ErrorMessage.new( self )
+          error_message.show_message( "Error in shortcut handler for #{model.model_class.name}: #{e.message}" )
+          error_message.show
+        end
+      end
+      
+      # now do all the usual shortcuts
+      case
+      # on the last row, and down is pressed
+      # add a new row
+      when event.down? && last_row?
+        model.add_new_item
+        
+      # on the right-bottom cell, and tab is pressed
+      # then add a new row
+      when event.tab? && last_cell?
+        model.add_new_item
+        
+      # delete the current row
+      when event.ctrl? && event.delete?
+        if delete_multiple_cells?
+          model.remove_rows( selection_model.selected_indexes.map{|index| index.row} )
+        end
+      
+      # copy the value from the row one above  
+      when event.ctrl? && event.apostrophe?
+        if current_index.row > 0
+          one_up_index = model.create_index( current_index.row - 1, current_index.column )
+          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 )
+          end
+        end
+        
+      # copy the value from the previous row, one cell right
+      when event.ctrl? && event.bracket_right?
+        if current_index.row > 0 && current_index.column < model.column_count
+          one_up_right_index = model.create_index( current_index.row - 1, current_index.column + 1 )
+          current_index.attribute_value = one_up_right_index.attribute_value
+          emit model.dataChanged( current_index, current_index )
+        end
+        
+      # copy the value from the previous row, one cell left
+      when event.ctrl? && event.bracket_left?
+        if current_index.row > 0 && current_index.column > 0
+          one_up_left_index = model.create_index( current_index.row - 1, current_index.column - 1 )
+          current_index.attribute_value = one_up_left_index.attribute_value
+          emit model.dataChanged( current_index, current_index )
+        end
+        
+      # insert today's date in the current field
+      when event.ctrl? && event.semicolon?
+        current_index.attribute_value = Time.now
+        emit model.dataChanged( current_index, current_index )
+        
+      # dump current record to stdout
+      when event.ctrl? && event.d?
+        puts model.collection[current_index.row].inspect
+        
+      # add new record and go to it
+      when event.ctrl? && ( event.n? || event.return? )
+        model.add_new_item
+        new_row_index = model.index( model.collection.size - 1, 0 )
+        currentChanged( new_row_index, current_index )
+        selection_model.clear
+        self.current_index = new_row_index
+      
+      # handle deletion of entire rows
+      when event.delete?
+        # translate from ModelIndex objects to row indices
+        rows = vertical_header.selection_model.selected_rows.map{|x| x.row}
+        unless rows.empty?
+          # header rows are selected, so delete them
+          model.remove_rows( rows ) 
+          # make sure no other handlers get this event
+          return true
+        else
+          # otherwise various cells are selected, so delete the cells
+          delete_cells
+          # nobody else handles this
+          return true
+        end
+        
+      # f4 should open editor immediately
+      when event.f4?
+        edit( current_index, Qt::AbstractItemView::AllEditTriggers, event )
+        delegate = item_delegate( current_index )
+        delegate.full_edit
+        
+      # copy currently selected data in csv format
+      when event.ctrl? && event.c?
+        text = String.new
+        selection_model.selection.each do |selection_range|
+          (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
+            end
+            text << row_ary.to_csv
+          end
+        end
+        Qt::Application::clipboard.text = text
+        return true
+        
+      when event.ctrl? && event.v?
+        # remove trailing "\n" if there is one
+        text = Qt::Application::clipboard.text.chomp
+        arr = FasterCSV.parse( text )
+        
+        return true if selection_model.selection.size != 1
+        
+        selection_range = selection_model.selection[0]
+        selected_index = selection_model.selected_indexes[0]
+        
+        if selection_range.single_cell?
+          # only one cell selected, so paste like a spreadsheet
+          if text.empty?
+            # just clear the current selection
+            model.setData( selected_index, nil.to_variant )
+          else
+            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 )
+        end
+        return true
+        
+      else
+        #~ puts event.inspect
+      end
+      super
+    rescue Exception => e
+      puts e.backtrace.join( "\n" )
+      puts e.message
+      error_message = Qt::ErrorMessage.new( self )
+      error_message.show_message( "Error in #{current_index.attribute.to_s}: \"#{e.message}\"" )
+      error_message.show
+    end
+  end
+  
+  # save the entity in the row of the given index
+  def save_row( index )
+    if index.valid?
+      saved = model.save( index )
+      if !saved
+        error_message = Qt::ErrorMessage.new( self )
+        msg = model.collection[index.row].errors.join("\n")
+        error_message.show_message( msg )
+        error_message.show
+      end
+    end
+  end
+  
+  # save record whenever its row is exited
+  def currentChanged( current_index, previous_index )
+    @index_override = false
+    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
+  def override_next_index( model_index )
+    set_current_index( model_index )
+    @index_override = true
+  end
+  
+  # call set_current_index with model_index unless override is true.
+  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
+  end
+    
+  # override to prevent tab pressed from editing next field
+  # also takes into account that override_next_index may have been called
+  def closeEditor( editor, end_edit_hint )
+    case end_edit_hint
+      when Qt::AbstractItemDelegate.EditNextItem
+        super( editor, Qt::AbstractItemDelegate.NoHint )
+        set_current_unless_override( model.create_index( current_index.row, current_index.column + 1 ) )
+        
+      when Qt::AbstractItemDelegate.EditPreviousItem
+        super( editor, Qt::AbstractItemDelegate.NoHint )
+        set_current_unless_override( model.create_index( current_index.row, current_index.column - 1 ) )
+        
+      else
+        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.
+  def filter_by_indexes( indexes )
+    save_entity = current_index.entity
+    save_index = current_index
+    
+    unless self.filtered
+      # filter by current selection
+      # TODO handle a multiple-selection
+      if indexes.empty?
+        self.filtered = false
+      elsif indexes.size > 1
+        puts "Can't do multiple selection filters yet"
+        self.filtered = false
+      end
+      
+      if indexes[0].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
+      end
+    else
+      # unfilter
+      model.reload_data( :conditions => {} )
+      self.filtered = false
+    end
+    
+    # find the row for the saved entity
+    found_row = override_cursor( Qt::BusyCursor ) do
+      model.collection.index_for_entity( save_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 )
+    end
+  end
+  
+  # search_criteria must respond to:
+  # * search_text
+  # * whole_words?
+  # * direction ( :forward, :backward )
+  # * from_start?
+  #
+  # TODO formalise this
+  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}" )
+      selection_model.clear
+      self.current_index = indexes[0]
+    else
+      emit status_text( "No match found for #{search_criteria.search_text}" )
+    end
+  end
+
+  def itemDelegateForColumn( column )
+    puts "itemDelegateForColumn #{column}"
+    super
+  end
+end
+
+end