clevic 0.7.0 → 0.8.0

data/lib/clevic/record.rb

@@ -1,9 +1,40 @@
+require 'active_record.rb'
+require 'active_record/dirty.rb'
+
+module Clevic
+
+  module Default
+    module ClassMethods
+      def define_ui_block; nil; end
+
+      def post_default_ui_block
+        @post_default_ui_block
+      end
+      
+      def post_default_ui( &block )
+        @post_default_ui_block = block
+      end
+    end
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  end
+
+end
+
+module ActiveRecord
+  class Base
+    include Clevic::Default
+  end
+end
+
 module Clevic
 
   # The base class for all Clevic model and UI definitions.
   # minimal definition is like this
   #   class User < Clevic::Record; end
-  # This will automatically keep track of the order
+  # Record automatically keeps track of the order
   # in which models are defined, so that tabs can
   # be constructed in that order.
   class Record < ActiveRecord::Base
@@ -11,6 +42,13 @@ module Clevic
     self.abstract_class = true
     @@subclass_order = []
     
+    def self.define_ui_block
+      @define_ui_block
+    end
+    
+    # keep track of the order in which subclasses are
+    # defined, so that can be used as the default ordering
+    # of the views.
     def self.inherited( subclass )
       @@subclass_order << subclass
       super
@@ -19,10 +57,15 @@ module Clevic
     def self.models
       @@subclass_order
     end
-
+    
     def self.models=( array )
       @@subclass_order = array
     end
+    
+    # use this to define UI blocks using the ModelBuilder DSL
+    def self.define_ui( &block )
+      @define_ui_block = block
+    end
   end
   
 end

data/lib/clevic/table_model.rb

@@ -13,8 +13,6 @@ module Clevic
 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
@@ -30,8 +28,22 @@ Initial idea by Richard Dale and Silvio Fonseca.
 class TableModel < Qt::AbstractTableModel
   include QtFlags
   
-  attr_accessor :collection, :dots, :attributes, :attribute_paths, :labels
+  # the CacheTable of Clevic::Record or ActiveRecord::Base objects
+  attr_reader :collection
+  
+  # the actual class for the collection objects
+  attr_accessor :model_class
+  
+  # the collection of Clevic::Field objects
+  attr_reader :fields
+  
+  attr_accessor :read_only
+  def read_only?; read_only; end
 
+  # should this model create a new empty record by default?
+  attr_accessor :auto_new
+  def auto_new?; auto_new; end
+  
   signals(
     # index where error occurred, value, message
     'data_error(QModelIndex,QVariant,QString)',
@@ -39,10 +51,44 @@ class TableModel < Qt::AbstractTableModel
     'dataChanged(const QModelIndex&,const QModelIndex&)'
   )
   
-  def initialize( builder )
-    super()
+  def initialize( parent = nil )
+    super
+    @metadatas = []
+  end
+  
+  def fields=( arr )
+    @fields = arr
+    
+    #reset these
     @metadatas = []
-    @builder = builder
+    @dots = nil
+    @labels = nil
+    @attributes = nil
+    @attribute_paths = nil
+  end
+  
+  def dots
+    @dots ||= fields.map {|x| x.column }
+  end
+  
+  def labels
+    @labels ||= fields.map {|x| x.label }
+  end
+  
+  def attributes
+    @attributes ||= fields.map {|x| x.attribute }
+  end
+  
+  def attribute_paths
+    @attribute_paths ||= fields.map {|x| x.attribute_path }
+  end
+  
+  def collection=( arr )
+    @collection = arr
+    # fill in an empty record for data entry
+    if collection.size == 0 && auto_new?
+      collection << model_class.new
+    end
   end
   
   def sort( col, order )
@@ -54,6 +100,7 @@ class TableModel < Qt::AbstractTableModel
     super
   end
   
+  # this is called for read-only tables.
   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.
@@ -64,22 +111,19 @@ class TableModel < Qt::AbstractTableModel
     #~ 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
+    #~ 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
+  #~ 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
   
   # cache metadata (ActiveRecord#column_for_attribute) because it's not going
   # to change over the lifetime of the table
@@ -161,7 +205,11 @@ class TableModel < Qt::AbstractTableModel
     if model_index.metadata.type == :boolean
       retval = item_boolean_flags
     end
-    retval |= qt_item_is_editable.to_i unless model_index.field.read_only?
+    
+    # read-only
+    unless model_index.field.read_only? || model_index.entity.readonly? || read_only?
+      retval |= qt_item_is_editable.to_i 
+    end
     retval
   end
   
@@ -179,7 +227,7 @@ class TableModel < Qt::AbstractTableModel
       when qt_display_role
         case orientation
           when Qt::Horizontal
-            @labels[section]
+            labels[section]
           when Qt::Vertical
             # don't force a fetch from the db
             if collection.cached_at?( section )
@@ -200,8 +248,27 @@ class TableModel < Qt::AbstractTableModel
         nil
         
       when qt_tooltip_role
-        if orientation == Qt::Horizontal
-          @builder.fields[section].tooltip
+        case orientation
+          when Qt::Horizontal
+            fields[section].tooltip
+            
+          when Qt::Vertical
+            case
+              when !collection[section].errors.empty?
+                'Invalid data'
+              when collection[section].changed?
+                'Unsaved changes'
+            end
+        end
+        
+      when qt_background_role
+        if orientation == Qt::Vertical
+          case
+            when !collection[section].errors.empty?
+              Qt::Color.new( 'orange' )
+            when collection[section].changed?
+              Qt::Color.new( 'yellow' )
+          end
         end
         
       else
@@ -240,22 +307,36 @@ class TableModel < Qt::AbstractTableModel
           
         when qt_text_alignment_role
           index.field.alignment
-
+        
         # these are just here to make debug output quieter
         when qt_size_hint_role;
-        when qt_background_role;
+        
+        # show field with a red background if there's an error
+        when qt_background_role
+          Qt::Color.new( 'red' ) if index.has_errors?
+          
         when qt_font_role;
         when qt_foreground_role
-          Qt::Color.new( 'dimgray' ) if index.field.read_only?
+          if index.field.read_only? || index.entity.readonly? || read_only?
+            Qt::Color.new( 'dimgray' )
+          end
+          
         when qt_decoration_role;
         
-        # provide a tooltip when an empty relational field is encountered
         when qt_tooltip_role
-          if index.metadata.type == :association
-            index.field.delegate.if_empty_message
-          end
-          
-          'Read-only' if index.field.read_only?
+          case
+            # show ActiveRecord validation errors
+            when index.has_errors?
+              index.errors.join("\n")
+              
+            # provide a tooltip when an empty relational field is encountered
+            when index.metadata.type == :association
+              index.field.delegate.if_empty_message
+            
+            # read-only field
+            when index.field.read_only?
+              'Read-only'
+          end    
         else
           puts "data index: #{index}, role: #{const_as_string(role)}" if $options[:debug]
           nil
@@ -264,7 +345,7 @@ class TableModel < Qt::AbstractTableModel
       # return a variant
       retval.to_variant
     rescue Exception => e
-      puts e.backtrace.join( "\n" )
+      puts e.backtrace
       puts "#{index.inspect} #{value.inspect} #{index.entity.inspect} #{e.message}"
       nil.to_variant
     end
@@ -276,7 +357,7 @@ class TableModel < Qt::AbstractTableModel
       case role
       when qt_edit_role
         # Don't allow the primary key to be changed
-        return false if index.attribute == :id
+        return false if index.attribute == model_class.primary_key.to_sym
         
         if ( index.column < 0 || index.column >= dots.size )
           raise "invalid column #{index.column}" 
@@ -338,7 +419,7 @@ class TableModel < Qt::AbstractTableModel
         
       when qt_checkstate_role
         if index.metadata.type == :boolean
-          index.entity.toggle!( index.attribute )
+          index.entity.toggle( index.attribute )
           true
         else
           false
@@ -379,6 +460,7 @@ class TableModel < Qt::AbstractTableModel
   end
   
   # return a set of indexes that match the search criteria
+  # TODO this implementation is very un-ruby.
   def search( start_index, search_criteria )
     # get the search value parameter, in SQL format
     search_value =
@@ -388,17 +470,32 @@ class TableModel < Qt::AbstractTableModel
       "%#{search_criteria.search_text}%"
     end
 
-    # build up the conditions
+    # build up the ordering conditions
     bits = collection.build_sql_find( start_index.entity, search_criteria.direction )
-    conditions = "#{model_class.connection.quote_column_name( start_index.field_name )} #{like_operator} :search_value"
+    
+    # do the conditions for the search value
+    conditions =
+    if start_index.field.is_association?
+      # for related tables
+      # TODO this will only work with a path value with no dots
+      "#{start_index.field.path} #{like_operator} :search_value"
+    else
+      # for this table
+      "#{model_class.connection.quote_column_name( start_index.field_name )} #{like_operator} :search_value"
+    end
+    
+    # add ordering conditions
     conditions += ( " and " + bits[:sql] ) unless search_criteria.from_start?
+    
     params = { :search_value => search_value }
     params.merge!( bits[:params] ) unless search_criteria.from_start?
+    
     # find the first match
     entity = model_class.find(
       :first,
       :conditions => [ conditions, params ],
-      :order => search_criteria.direction == :forwards ? collection.order : collection.reverse_order
+      :order => search_criteria.direction == :forwards ? collection.order : collection.reverse_order,
+      :joins => ( start_index.field.meta.name if start_index.field.is_association? )
     )
     
     # return matched indexes
@@ -411,7 +508,7 @@ class TableModel < Qt::AbstractTableModel
   end
   
   def field_for_index( model_index )
-    @builder.fields[model_index.column]
+    fields[model_index.column]
   end
   
 end

data/lib/clevic/table_view.rb

@@ -2,25 +2,47 @@ require 'rubygems'
 require 'Qt4'
 require 'fastercsv'
 require 'clevic/model_builder.rb'
+require 'qtext/action_builder.rb'
 
 module Clevic
 
 # The view class, implementing neat shortcuts and other pleasantness
 class TableView < Qt::TableView
-  attr_reader :model_class, :builder
+  include ActionBuilder
+  
+  attr_reader :model_class
   # whether the model is currently filtered
   # TODO better in QAbstractSortFilter?
   attr_accessor :filtered
+  def filtered?; self.filtered; end
   
-  # this is emitted when this object was to display something in the status bar
-  signals 'status_text(QString)'
+  # status_text is emitted when this object was to display something in the status bar
+  # filter_status is emitted when the filtering changes. Param is true for filtered, false for not filtered.
+  signals 'status_text(QString)', 'filter_status(bool)'
   
-  def initialize( model_class, parent, *args )
-    super( parent )
-    
-    # the AR entity class
-    @model_class = model_class
+  # model_builder_record is:
+  # - a subclass of Clevic::Record or ActiveRecord::Base
+  # - an instance of ModelBuilder
+  # - an instance of TableModel
+  def initialize( model_builder_record, parent, &block )
+    # need the empty block here, otherwise Qt bindings grab &block
+    super( parent ) {}
     
+    # the model/model_class/builder
+    case 
+      when model_builder_record.kind_of?( TableModel )
+        self.model = model_builder_record
+      
+      when model_builder_record.ancestors.include?( ActiveRecord::Base )
+        with_record( model_builder_record, &block )
+      
+      when model_builder_record.kind_of?( Clevic::ModelBuilder )
+        with_builder( model_builder_record, &block )
+        
+      else
+        raise "Don't know what to do with #{model_builder_record}"
+    end
+      
     # see closeEditor
     @index_override = false
     
@@ -34,21 +56,278 @@ class TableView < Qt::TableView
     
     # turn off "Object#type deprecated" messages
     $VERBOSE = nil
+    
+    init_actions
+    self.context_menu_policy = Qt::ActionsContextMenu
+  end
+  
+  def with_builder( model_builder, &block )
+    model_builder.instance_eval( &block ) unless block.nil?
+    
+    # make sure the TableView has a fully-populated TableModel
+    self.model = model_builder.build( self )
+    
+    # connect data_changed signals for the model_class to respond
+    connect_model_class_signals( model_class )
+  end
+  
+  def with_record( model_class, &block )
+    builder = ModelBuilder.new( model_class )
+    with_builder( builder, &block )
+  end
+  
+  def connect_model_class_signals( model_class )
+    # this is only here because model_class.data_changed needs the view.
+    # Should probably fix that.
+    if model_class.respond_to?( :data_changed )
+      model.connect SIGNAL( 'dataChanged ( const QModelIndex &, const QModelIndex & )' ) do |top_left, bottom_right|
+        model_class.data_changed( top_left, bottom_right, self )
+      end
+    end
+  end
+  
+  # return menu actions for the model, or an empty array if there aren't any
+  def model_actions
+    @model_actions ||= []
+  end
+  
+  # hook for the sanity_check_xxx methods
+  # called for the actions set up by ActionBuilder
+  # it just wraps the action block/method in a catch
+  # block for :insane
+  def action_triggered( &block )
+    catch :insane do
+      yield
+    end
+  end
+  
+  def init_actions
+    # add model actions, if they're defined
+    if model_class.respond_to?( :actions )
+      list( :model ) do |ab|
+        model_class.actions( self, ab )
+      end
+      separator
+    end
+    
+    # list of actions called edit
+    list( :edit ) do
+      #~ new_action :action_cut, 'Cu&t', :shortcut => Qt::KeySequence::Cut
+      action :action_copy, '&Copy', :shortcut => Qt::KeySequence::Copy, :method => :copy_current_selection
+      action :action_paste, '&Paste', :shortcut => Qt::KeySequence::Paste, :method => :paste
+      separator
+      action :action_ditto, '&Ditto', :shortcut => 'Ctrl+\'', :method => :ditto, :tool_tip => 'Copy same field from previous record'
+      action :action_ditto_right, 'Ditto R&ight', :shortcut => 'Ctrl+]', :method => :ditto_right, :tool_tip => 'Copy field one to right from previous record'
+      action :action_ditto_left, '&Ditto L&eft', :shortcut => 'Ctrl+[', :method => :ditto_left, :tool_tip => 'Copy field one to left from previous record'
+      action :action_insert_date, 'Insert Date', :shortcut => 'Ctrl+;', :method => :insert_current_date
+      action :action_open_editor, '&Open Editor', :shortcut => 'F4', :method => :open_editor
+      separator
+      action :action_row, 'New Ro&w', :shortcut => 'Ctrl+N', :method => :new_row
+      action :action_refresh, '&Refresh', :shortcut => 'Ctrl+R', :method => :refresh
+      action :action_delete_rows, 'Delete Rows', :shortcut => 'Ctrl+Delete', :method => :delete_rows
+      
+      if $options[:debug]
+        action :action_dump, 'D&ump', :shortcut => 'Ctrl+Shift+D' do
+          puts model.collection[current_index.row].inspect
+        end
+      end
+    end
+    
+    separator
+    
+    # list of actions called search
+    list( :search ) do
+      action :action_find, '&Find', :shortcut => Qt::KeySequence::Find, :method => :find
+      action :action_find_next, 'Find &Next', :shortcut => Qt::KeySequence::FindNext, :method => :find_next
+      action :action_filter, 'Fil&ter', :checkable => true, :shortcut => 'Ctrl+L', :method => :filter_by_current
+      action :action_highlight, '&Highlight', :visible => false, :shortcut => 'Ctrl+H'
+    end
   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 )
+  def copy_current_selection
+    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
-    self
+    Qt::Application::clipboard.text = text
+  end
+  
+  def paste
+    sanity_check_read_only
+    
+    # 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
+  end
+  
+  def sanity_check_ditto
+    if current_index.row == 0
+      emit status_text( 'No previous record to copy.' )
+      throw :insane
+    end
+  end
+  
+  def sanity_check_read_only
+    if current_index.field.read_only?
+      emit status_text( 'Can\'t copy into read-only field.' )
+    elsif current_index.entity.readonly?
+      emit status_text( 'Can\'t copy into read-only record.' )
+    else
+      sanity_check_read_only_table
+      return
+    end
+    throw :insane
+  end
+  
+  def sanity_check_read_only_table
+    if model.read_only?
+      emit status_text( 'Can\'t modify a read-only table.' )
+      throw :insane
+    end
+  end
+  
+  def ditto
+    sanity_check_ditto
+    sanity_check_read_only
+    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
+  
+  def ditto_right
+    sanity_check_ditto
+    sanity_check_read_only
+    unless current_index.column < model.column_count
+      emit status_text( 'No column to the right' )
+    else
+      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
+  end
+  
+  def ditto_left
+    sanity_check_ditto
+    sanity_check_read_only
+    unless current_index.column > 0
+      emit status_text( 'No column to the left' )
+    else
+      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
   end
+  
+  def insert_current_date
+    sanity_check_read_only
+    current_index.attribute_value = Time.now
+    emit model.dataChanged( current_index, current_index )
+  end
+  
+  def open_editor
+    edit( current_index )
+    delegate = item_delegate( current_index )
+    delegate.full_edit
+  end
+  
+  def new_row
+    sanity_check_read_only_table
+    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
+  end
+  
+  def deleted_selection
+    sanity_check_read_only
 
+    # 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 ) 
+    else
+      # otherwise various cells are selected, so delete the cells
+      delete_cells
+    end
+  end
+  
+  # display a search dialog, and find the entered text
+  def find
+    @search_dialog ||= SearchDialog.new
+    result = @search_dialog.exec( current_index.gui_value )
+    
+    override_cursor( Qt::BusyCursor ) do
+      case result
+        when Qt::Dialog::Accepted
+          search_for = @search_dialog.search_text
+          search( @search_dialog )
+        when Qt::Dialog::Rejected
+          puts "Don't search"
+        else
+          puts "unknown dialog code #{result}"
+      end
+    end
+  end
+  
+  def find_next
+    if @search_dialog.nil?
+      emit status_text( 'No previous find' )
+    else
+      override_cursor( Qt::BusyCursor ) do
+        save_from_start = @search_dialog.from_start?
+        @search_dialog.from_start = false
+        search( @search_dialog )
+        @search_dialog.from_start = save_from_start
+      end
+    end
+  end
+  
+  # force a complete reload of the current tab's data
+  def refresh
+    override_cursor( Qt::BusyCursor ) do
+      model.reload_data
+    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 )
+  end
+  
   # alternative access for auto_size_column
   def auto_size_attribute( attribute, sample )
     col = model.attributes.index( attribute )
@@ -109,9 +388,20 @@ class TableView < Qt::TableView
   # make sure row size is correct
   # show error messages for data
   def setModel( model )
+    # must do this otherwise model gets garbage collected
+    @model = model
+    
+    # make sure we get nice spacing
     vertical_header.default_section_size = vertical_header.minimum_section_size
     super
     
+    # set delegates
+    self.item_delegate = Clevic::ItemDelegate.new( self )
+    model.fields.each_with_index do |field, index|
+      set_item_delegate_for_column( index, field.delegate )
+    end
+    
+    # data errors
     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}" )
@@ -129,7 +419,7 @@ class TableView < Qt::TableView
   # 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|
+    model.fields.each_with_index do |field, index|
       auto_size_column( index, field.sample )
     end
   end
@@ -158,6 +448,8 @@ class TableView < Qt::TableView
   end
   
   def delete_multiple_cells?
+    sanity_check_read_only
+    
     # go ahead with delete if there's only 1 cell, or the user says OK
     delete_ok =
     if selection_model.selected_indexes.size > 1
@@ -195,10 +487,14 @@ class TableView < Qt::TableView
     end
   end
   
+  def delete_rows
+    if delete_multiple_cells?
+      model.remove_rows( selection_model.selected_indexes.map{|index| index.row} )
+    end
+  end
+  
+  # handle certain key combinations that aren't shortcuts
   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 )
@@ -213,138 +509,30 @@ class TableView < Qt::TableView
         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
+      catch :insane do
+        case
+        # on the last row, and down is pressed
+        # add a new row
+        when event.down? && last_row?
+          new_row
           
-          # size is the same, so do the paste
-          paste_to_index( selected_index, arr )
+        # on the right-bottom cell, and tab is pressed
+        # then add a new row
+        when event.tab? && last_cell?
+          new_row
+          
+        # add new record and go to it
+        # TODO this is actually a shortcut
+        when event.ctrl? && event.return?
+          new_row
+          
+        else
+          #~ puts event.inspect
         end
-        return true
-        
-      else
-        #~ puts event.inspect
       end
       super
     rescue Exception => e
-      puts e.backtrace.join( "\n" )
+      puts e.backtrace
       puts e.message
       error_message = Qt::ErrorMessage.new( self )
       error_message.show_message( "Error in #{current_index.attribute.to_s}: \"#{e.message}\"" )
@@ -366,7 +554,7 @@ class TableView < Qt::TableView
       saved = model.save( index )
       if !saved
         error_message = Qt::ErrorMessage.new( self )
-        msg = model.collection[index.row].errors.join("\n")
+        msg = model.collection[index.row].errors.to_a.join("\n")
         error_message.show_message( msg )
         error_message.show
       end
@@ -420,7 +608,7 @@ class TableView < Qt::TableView
     
   def focusOutEvent( event )
     super
-    save_current_row
+    #~ save_current_row
   end
   
   # this is the only method that is called when an itemDelegate is open
@@ -455,6 +643,7 @@ class TableView < Qt::TableView
   # 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}" )
@@ -496,6 +685,11 @@ class TableView < Qt::TableView
     # 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_name} = #{current_index.gui_value}" )
+      else
+        emit status_text( nil )
+      end
     end
   end
   
@@ -521,6 +715,7 @@ class TableView < Qt::TableView
     puts "itemDelegateForColumn #{column}"
     super
   end
+  
 end
 
 end