clevic 0.12.0 → 0.13.0.b1

data/lib/clevic/table_searcher.rb

@@ -1,165 +1,162 @@
-require 'clevic/sql_dialects.rb'
-
 module Clevic
 
-# TODO possibly use AR scopes for this?
+=begin
+Search for a record in the collection given a set of criteria. One of the
+criteria will be a starting record, and the search method should return
+the matching record next after this.
+=end
 class TableSearcher
-  attr_reader :entity_class, :order_attributes, :search_criteria, :field
+  attr_reader :dataset, :search_criteria, :field
   
-  # entity_class is a descendant of ActiveRecord::Base
-  # order_attributes is a collection of OrderAttribute objects
-  # - field is an instance of Clevic::Field
-  # - search_criteria responds to from_start?, direction, whole_words? and search_text
-  def initialize( entity_class, order_attributes, search_criteria, field )
-    raise "there must be at least one order_attribute" if order_attributes.nil? or order_attributes.empty?
+  # dataset is a Sequel::Dataset, which has an associated Sequel::Model
+  # field is an instance of Clevic::Field
+  # search_criteria responds to from_start?, direction, whole_words? and search_text
+  def initialize( dataset, search_criteria, field )
     raise "field must be specified" if field.nil?
     raise "unknown order #{search_criteria.direction}" unless [:forwards, :backwards].include?( search_criteria.direction )
-    @entity_class = entity_class
-    @order_attributes = order_attributes
+    raise "dataset has no model" unless dataset.respond_to?( :model )
+    
+    # set default dataset ordering if it's not there
+    @dataset =
+    if dataset.opts[:order].nil?
+      dataset.order( dataset.model.primary_key )
+    else
+      dataset
+    end
+    
     @search_criteria = search_criteria
     @field = field
   end
   
   # start_entity is the entity to start from, ie any record found after it will qualify
+  # return the first entity found that matches the criteria
   def search( start_entity = nil )
-    search_field_name = 
-    if field.is_association?
+    search_dataset( start_entity ).first
+  end
+
+protected
+  # return a Sequel expression for the name of the field to use as a comparison
+  def search_field_expression
+    if field.association?
       # for related tables
       unless [String,Symbol].include?( field.display.class )
-        raise( "search field #{field.inspect} cannot have a complex display" ) 
+        raise( "search field #{field.inspect} cannot search lambda display" ) 
       end
       
+      raise "display not specified for #{field}" if field.display.nil?
+      
       # TODO this will only work with a path value with no dots
       # otherwise the SQL gets complicated with joins etc
-      field.display
+      field.related_class \
+        .filter( field.related_class.primary_key.qualify( field.related_class.table_name ) => field.meta.key.qualify( field.entity_class.table_name ) ) \
+        .select( field.display.to_sym )
     else
       # for this table
-      entity_class.connection.quote_column_name( field.attribute.to_s )
+      field.attribute.to_sym
     end
-    
-    # do the conditions for the search value
-    @conditions = search_clause( search_field_name )
+  end
+  
+  # return an expression, or an array or expressions for representing search_criteria.search_text and whole_words?
+  def search_text_expression
+    if search_criteria.whole_words?
+      [
+        "% #{search_criteria.search_text} %",
+        "#{search_criteria.search_text} %",
+        "% #{search_criteria.search_text}",
+        search_criteria.search_text
+      ]
+    else
+      "%#{search_criteria.search_text}%"
+    end
+  end
+  
+  # Add the relevant conditions to use start_entity as the
+  # entity where the search starts, ie the first one after it is found
+  # start_entity is a model instance
+  def find_from( dataset, start_entity )
+    expression = build_recursive_comparison( start_entity )
+    # need expression => true because most databases can't evaluate a
+    # pure boolean expression - they need something to compare it to.
+    dataset.filter( expression => true )
+  end
+  
+  # return a dataset based on @dataset which filters on search_criteria
+  def search_dataset( start_entity )
+    likes = Array[*search_text_expression].map{|ste| Sequel::SQL::StringExpression.like(search_field_expression, ste, {:case_insensitive=>true})}
+    rv = @dataset.filter( Sequel::SQL::BooleanExpression.new(:OR, *likes ) )
     
     # if we're not searching from the start, we need
     # to find the next match. Which is complicated from an SQL point of view.
     unless search_criteria.from_start?
       raise "start_entity cannot be nil when from_start is false" if start_entity.nil?
       # build up the ordering conditions
-      find_from!( start_entity )
+      rv = find_from( rv, start_entity )
     end
     
-    # otherwise ActiveRecord thinks that the % in the string
-    # is for interpolations instead of treating it a the like wildcard
-    conditions_value =
-    if !@params.nil? and @params.size > 0
-      [ @conditions, @params ]
-    else
-      @conditions
-    end
+    # reverse order by direction if necessary
+    rv = rv.reverse if search_criteria.direction == :backwards
     
-    # find the first match
-    entity_class.find(
-      :first,
-      :conditions => conditions_value,
-      :order => order,
-      :joins => ( field.meta.name if field.is_association? )
-    )
-  end
-
-protected
-  include SqlDialects
-  
-  def quote_column( field_name )
-    entity_class.connection.quote_column_name( field_name )
-  end
-  
-  def quote( value )
-    entity_class.connection.quote( value )
+    # return dataset
+    rv
   end
   
   # recursively create a case statement to do the comparison
   # because and ... and ... and filters on *each* one rather than
   # consecutively.
-  # operator is either '<' or '>'
-  def build_recursive_comparison( operator, index = 0 )
+  def build_recursive_comparison( start_entity, index = 0 )
     # end recursion
-    return sql_boolean( false ) if index == order_attributes.size
+    return false if index == order_attributes.size
     
-    # fetch the current attribute
-    attribute = order_attributes[index]
+    # fetch the current order attribute and direction
+    attribute, direction = order_attributes[index]
+    value = start_entity.send( attribute )
     
-    # build case statement, including recusion
-    st = <<-EOF
-case
-  when #{entity_class.table_name}.#{quote_column attribute} #{operator} :#{attribute} then #{sql_boolean true}
-  when #{entity_class.table_name}.#{quote_column attribute} = :#{attribute} then #{build_recursive_comparison( operator, index+1 )}
-  else #{sql_boolean false}
-end
-EOF
-    # indent
-    st.gsub!( /^/, '  ' * index )
+    # build case statement using Sequel expressions, including recursion
+    # pseudo-SQL is
+    # case
+    #   when attribute < value then true
+    #   when attribute = value then #{build_recursive_comparison( operator, index+1 )}
+    #   else false
+    # end
+    
+    {
+      # if values are unequal, comparison levels end here
+      attribute.identifier.send( comparator(direction), value ) => true,
+      # if the values are equal, move on to the next level of comparison
+      { attribute => value } => build_recursive_comparison( start_entity, index+1 )
+    }.case( false ) # the else (default) clause, ie we don't want to see these records
   end
   
-  # Add the relevant conditions to use start_entity as the
-  # entity where the search starts, ie the first one after it is found
-  # start_entity is an AR model instance
-  # sets @params and @conditions
-  def find_from!( start_entity )
-    operator =
+  # return either > or < depending on both search_criteria.direction
+  # and local_direction
+  def comparator( local_direction = 1 )
+    comparator_direction =
     case search_criteria.direction
-      when :forwards; '>'
-      when :backwards; '<'
-    end
-    
-    # build the sql comparison where clause fragment
-    comparison_sql = build_recursive_comparison( operator )
-    
-    # only Postgres seems to understand real booleans
-    # everything else needs the big case statement to be compared
-    # to something
-    unless entity_class.connection.adapter_name == 'PostgreSQL'
-      comparison_sql += " = #{sql_boolean true}"
-    end
-    
-    # build parameter values
-    @params ||= {}
-    order_attributes.each {|x| @params[x.to_sym] = start_entity.send( x.attribute )}
+      when :forwards; 1
+      when :backwards; -1
+    end * local_direction
     
-    @conditions += " and " + comparison_sql
+    # 1 indexes >, -1 indexes <
+    ['','>','<'][comparator_direction]
   end
   
-  # get the search value parameter, in SQL format
-  def search_clause( field_name )
-    if search_criteria.whole_words?
-      <<-EOF
-      (
-        #{field_name} #{like_operator} #{quote "% #{search_criteria.search_text} %"}
-        or
-        #{field_name} #{like_operator} #{quote "#{search_criteria.search_text} %"}
-        or
-        #{field_name} #{like_operator} #{quote "% #{search_criteria.search_text}"}
-      )
-      EOF
-    else
-      "#{field_name} #{like_operator} #{quote "%#{search_criteria.search_text}%"}"
-    end
-  end
-  
-  def ascending_order
-    order_attributes.map{|x| x.to_sql}.join(',')
-  end
-  
-  def descending_order
-    order_attributes.map{|x| x.to_reverse_sql}.join(',')
-  end
-  
-  def order
-    case search_criteria.direction
-      when :forwards; ascending_order
-      when :backwards; descending_order
+  # returns a collection of [ attribute, (1|-1) ]
+  # where 1 is forward/asc (>) and -1 is backward/desc (<)
+  def order_attributes
+    if @order_attributes.nil?
+      @order_attributes =
+      @dataset.opts[:order].map do |order_expr|
+        case order_expr
+          when Symbol; [ order_expr, 1 ]
+          when Sequel::SQL::OrderedExpression; [ order_expr.expression, order_expr.descending ? -1 : 1 ]
+          else
+            raise "unknown order_expr: #{order_expr.inspect}"
+        end
+      end
     end
+    @order_attributes
   end
-  
 end
 
 end
+

data/lib/clevic/table_view.rb

@@ -1,47 +1,36 @@
-require 'rubygems'
-require 'Qt4'
 require 'fastercsv'
-require 'qtext/action_builder.rb'
+require 'stringio'
 
 require 'clevic/model_builder.rb'
 require 'clevic/filter_command.rb'
 
 module Clevic
 
-# The view class
-class TableView < Qt::TableView
+# Various methods common to view classes
+class TableView
   include ActionBuilder
   
   # the current filter command
-  # TODO better in QAbstractSortFilter?
   attr_accessor :filtered
   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)'
-  
+  # Called from the gui-framework adapter code in this class
   # arg is:
   # - an instance of Clevic::View
   # - an instance of TableModel
-  def initialize( arg, parent = nil, &block )
-    # need the empty block here, otherwise Qt bindings grab &block
-    super( parent ) {}
-    
+  def framework_init( arg, &block )
     # the model/entity_class/builder
     case 
-      when arg.kind_of?( TableModel )
+      when arg.is_a?( TableModel )
         self.model = arg
         init_actions( arg.entity_view )
       
-      else
-        # arg is a subclass of Clevic::View
+      when arg.is_a?( Clevic::View )
         model_builder = arg.define_ui
         model_builder.exec_ui_block( &block )
         
         # make sure the TableView has a fully-populated TableModel
-        # self.model is necessary to invoke the Qt layer
+        # self.model is necessary to invoke the GUI layer
         self.model = model_builder.build( self )
         self.object_name = arg.widget_name
         
@@ -49,31 +38,18 @@ class TableView < Qt::TableView
         connect_view_signals( arg )
         
         init_actions( arg )
-    end
       
-    # see closeEditor
-    @next_index = nil
-    
-    # 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
-    
-    self.context_menu_policy = Qt::ActionsContextMenu
+      else
+        raise "Don't know what to do with #{arg.inspect}"
+    end
   end
   
+  attr_accessor :object_name
+  
   def title
     @title ||= model.entity_view.title
   end
   
-  def connect_view_signals( entity_view )
-    model.connect SIGNAL( 'dataChanged ( const QModelIndex &, const QModelIndex & )' ) do |top_left, bottom_right|
-      entity_view.notify_data_changed( self, top_left, bottom_right )
-    end
-  end
-  
   # find the row index for the given field id (symbol)
   def field_column( field )
     raise "use model.field_column( field )"
@@ -90,32 +66,36 @@ class TableView < Qt::TableView
   # block for :insane. Will also catch exceptions thrown in actions to make
   # core application more robust to model & view errors.
   def action_triggered( &block )
-    begin
-      catch :insane do
-        yield
-      end
+    catch :insane do
+      yield
+    end
+    
     rescue Exception => e
-      puts e.message
+      puts
+      puts "#{model.entity_view.class.name}: #{e.message}"
       puts e.backtrace
-    end
   end
   
+  
+  # called from framework_init
   def init_actions( entity_view )
     # add model actions, if they're defined
     list( :model ) do |ab|
       entity_view.define_actions( self, ab )
-      separator
+      separator unless collect_actions.empty?
     end
     
     # 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
+      #~ new_action :action_cut, 'Cu&t', :shortcut => 'Ctrl-X'
+      action :action_save, '&Save', :shortcut => 'Ctrl+S', :method => :save_current_rows
+      #~ action :action_cut, 'Cu&t', :shortcut => 'Ctrl+X', :method => :cut_current_selection
+      action :action_copy, '&Copy', :shortcut => 'Ctrl+C', :method => :copy_current_selection
+      action :action_paste, '&Paste', :shortcut => 'Ctrl+V', :method => :paste
+      action :action_delete, '&Delete', :shortcut => 'Del', :method => :delete_selection
       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, 'D&itto', :shortcut => 'Ctrl+\'', :method => :ditto, :tool_tip => 'Copy same field from previous record'
+      action :action_ditto_right, 'Ditto Ri&ght', :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
@@ -133,95 +113,47 @@ class TableView < Qt::TableView
     
     separator
     
-    # list of actions called search
+    # list of actions for 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_find, '&Find', :shortcut => 'Ctrl+F', :method => :find
+      action :action_find_next, 'Find &Next', :shortcut => 'Ctrl+G', :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 clipboard
+    # Clipboard will be a framework-specific class
+    @clipboard = Clipboard.new
+  end
+
+  # copy current selection to clipboard as CSV
+  # TODO add text/csv, text/tab-separated-values, text/html as well as text/plain
   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|
-          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
-    end
-    Qt::Application::clipboard.text = text
+    clipboard.text = current_selection_csv
   end
   
-  def paste
-    sanity_check_read_only
-    
-    # remove trailing "\n" if there is one
-    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.first
-    selected_index = selection_model.selected_indexes.first
-    
-    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
-        model.setData( selected_index, nil.to_variant )
-      else
-        paste_to_index( selected_index, arr )
-      end
-    else
-      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
+  # return the current selection as csv
+  def current_selection_csv
+    buffer = StringIO.new
+    selected_rows.each do |row|
+      buffer << row.map {|index| index.edit_value }.to_csv
     end
+    buffer.string
   end
   
   def sanity_check_ditto
     if current_index.row == 0
-      emit status_text( 'No previous record to copy.' )
+      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.' )
+      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.' )
+      emit_status_text( 'Can\'t copy into read-only record.' )
     else
       sanity_check_read_only_table
       return
@@ -231,7 +163,7 @@ class TableView < Qt::TableView
   
   def sanity_check_read_only_table
     if model.read_only?
-      emit status_text( 'Can\'t modify a read-only table.' )
+      emit_status_text( 'Can\'t modify a read-only table.' )
       throw :insane
     end
   end
@@ -251,7 +183,7 @@ class TableView < Qt::TableView
   # their fields don't have the same attribute_type.
   def sanity_check_types( from, to )
     unless from.field.attribute_type == to.field.attribute_type
-      emit status_text( 'Incompatible data' )
+      emit_status_text( 'Incompatible data' )
       throw :insane
     end
   end
@@ -260,7 +192,7 @@ class TableView < Qt::TableView
     sanity_check_ditto
     sanity_check_read_only
     if current_index.column >= model.column_count - 1
-      emit status_text( 'No column to the right' )
+      emit_status_text( 'No column to the right' )
     else
       one_up_right = current_index.choppy {|i| i.row -= 1; i.column += 1 }
       sanity_check_types( one_up_right, current_index )
@@ -273,7 +205,7 @@ class TableView < Qt::TableView
     sanity_check_ditto
     sanity_check_read_only
     unless current_index.column > 0
-      emit status_text( 'No column to the left' )
+      emit_status_text( 'No column to the left' )
     else
       one_up_left = current_index.choppy { |i| i.row -= 1; i.column -= 1 }
       sanity_check_types( one_up_left, current_index )
@@ -289,72 +221,85 @@ class TableView < Qt::TableView
   end
   
   def open_editor
+    # tell the table to edit here
     edit( current_index )
-    delegate = item_delegate( current_index )
-    delegate.full_edit
+    
+    # tell the editing component to do full edit, eg if it's a combo
+    # box to open the list.
+    current_index.field.delegate.full_edit
   end
   
   # Add a new row and move to it, provided we're not in a read-only view.
   def new_row
     sanity_check_read_only_table
     model.add_new_item
-    new_row_index = model.index( model.row_count - 1, 0 )
-    currentChanged( new_row_index, current_index )
     selection_model.clear
-    self.current_index = new_row_index
+    self.current_index = model.create_index( model.row_count - 1, 0 )
   end
   
   # Delete the current selection. If it's a set of rows, just delete
   # them. If it's a rectangular selection, set the cells to nil.
   # TODO make sure all affected rows are saved.
   def delete_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
+    busy_cursor do
+      begin
+        sanity_check_read_only
+        
+        # TODO translate from ModelIndex objects to row indices
+        puts "#{__FILE__}:#{__LINE__}:implement vertical_header for delete_selection"
+        #~ rows = vertical_header.selection_model.selected_rows.map{|x| x.row}
+        rows = []
+        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
+      rescue
+        show_error $!.message
+      end
     end
   end
   
+  def search_dialog
+    @search_dialog ||= SearchDialog.new( nil )
+  end
+  
   # display a search dialog, and find the entered text
   def find
-    @search_dialog ||= SearchDialog.new
-    result = @search_dialog.exec( current_index.gui_value )
+    result = search_dialog.exec( current_index.display_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
+    busy_cursor do
+      case
+        when result.accepted?
+          search( search_dialog )
+        when result.rejected?
           puts "Don't search"
         else
-          puts "unknown dialog code #{result}"
+          puts "unknown dialog result #{result}"
       end
     end
   end
   
   def find_next
+    # yes, this must be an @ otherwise it lazy-creates
+    # and will never be nil
     if @search_dialog.nil?
-      emit status_text( 'No previous find' )
+      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
+      busy_cursor 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
+    busy_cursor do
       restore_entity do
         model.reload_data
       end
@@ -373,50 +318,7 @@ class TableView < Qt::TableView
   
   # 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
-  
-  # TODO is this even used?
-  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 )
+    auto_size_column( model.attributes.index( attribute ), sample )
   end
   
   # is current_index on the last row?
@@ -428,37 +330,7 @@ class TableView < Qt::TableView
   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 )
-    # 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
-    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}" )
-      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
@@ -467,48 +339,11 @@ class TableView < Qt::TableView
     end
   end
   
-  def moveCursor( cursor_action, modifiers )
-    # TODO use this as a preload indicator
-    super
-  end
-
   # copied from actionpack
   def pluralize(count, singular, plural = nil)
     "#{count || 0} " + ((count == 1 || count == '1') ? singular : (plural || singular.pluralize))
   end
 
-  # Paste a CSV array to the index, replacing whatever is at that index
-  # and whatever is at other indices matching the size of the pasted
-  # csv array. Create new rows if there aren't enough.
-  def paste_to_index( top_left_index, csv_arr )
-    csv_arr.each_with_index do |row,row_index|
-      # append row if we need one
-      model.add_new_item if top_left_index.row + row_index >= model.row_count
-      
-      row.each_with_index do |field, field_index|
-        unless top_left_index.column + field_index >= model.column_count
-          # do paste
-          cell_index = top_left_index.choppy {|i| i.row += row_index; i.column += field_index }
-          model.setData( cell_index, field.to_variant, Qt::PasteRole )
-        else
-          emit status_text( "#{pluralize( top_left_index.column + field_index, 'column' )} for pasting data is too large. Truncating." )
-        end
-      end
-      # save records to db
-      model.save( top_left_index.choppy {|i| i.row += row_index; i.column = 0 } )
-    end
-    
-    # make the gui refresh
-    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
-  
   # ask the question in a dialog. If the user says yes, execute the block
   def delete_multiple_cells?( question = 'Are you sure you want to delete multiple cells?', &block )
     sanity_check_read_only
@@ -516,15 +351,7 @@ class TableView < Qt::TableView
     # 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',
-        question,
-        Qt::MessageBox::Yes | Qt::MessageBox::No,
-        self
-      )
-      msg.exec == Qt::MessageBox::Yes
+      confirm_dialog( question, "Multiple Delete" ).accepted?
     else
       true
     end
@@ -547,12 +374,12 @@ class TableView < Qt::TableView
       # deletes were done, so call data_changed
       if cells_deleted
         # save affected rows
-        selection_model.row_indexes.each do |index|
-          index.entity.save
+        selection_model.row_indexes.each do |row_index|
+          save_row( model.create_index( row_index, 0 ) )
         end
         
         # emit data changed for all ranges
-        selection_model.selection.each do |selection_range|
+        selection_model.ranges.each do |selection_range|
           model.data_changed( selection_range )
         end
       end
@@ -560,13 +387,20 @@ class TableView < Qt::TableView
   end
   
   def delete_rows
-    delete_multiple_cells?( 'Are you sure you want to delete multiple rows?' ) do
-      model.remove_rows( selection_model.selected_indexes.map{|index| index.row} )
+    delete_multiple_cells?( "Are you sure you want to delete #{selection_model.row_indexes.size} rows?" ) do
+      begin
+        model.remove_rows( selection_model.row_indexes )
+      rescue
+        puts $!.message
+        puts $!.backtrace
+        show_error $!.message
+      end
     end
   end
   
   # handle certain key combinations that aren't shortcuts
-  def keyPressEvent( event )
+  # TODO what is returned from here?
+  def handle_key_press( event )
     begin
       # call to entity class for shortcuts
       begin
@@ -574,9 +408,7 @@ class TableView < Qt::TableView
         return view_result unless view_result.nil?
       rescue Exception => e
         puts e.backtrace
-        error_message = Qt::ErrorMessage.new( self )
-        error_message.show_message( "Error in shortcut handler for #{model.entity_view.name}: #{e.message}" )
-        error_message.show
+        show_error( "Error in shortcut handler for #{model.entity_view.name}: #{e.message}" )
       end
       
       # thrown by the sanity_check_xxx methods
@@ -597,29 +429,20 @@ class TableView < Qt::TableView
         when event.ctrl? && event.return?
           new_row
         
-        when event.delete?
-          if selection_model.selected_indexes.size > 1
-            delete_selection
-            return true
-          end
-        
         else
           #~ puts event.inspect
         end
       end
-      super
     rescue Exception => e
       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}\"" )
-      error_message.show
+      show_error( "handle_key_press #{__FILE__}:#{__LINE__} error in #{current_index.attribute.to_s}: \"#{e.message}\"" )
     end
   end
   
-  def save_current_row
-    if !current_index.nil? && current_index.valid?
-      save_row( current_index )
+  def save_current_rows
+    selection_model.row_indexes.each do |row_index|
+      save_row( model.create_index( row_index, 0 ) )
     end
   end
   
@@ -630,88 +453,28 @@ class TableView < Qt::TableView
     if !index.nil? && index.valid?
       saved = model.save( index )
       if !saved
-        error_message = Qt::ErrorMessage.new( self )
-        msg = model.collection[index.row].errors.to_a.join("\n")
-        error_message.show_message( msg )
-        error_message.show
+        # construct error message(s)
+        msg = index.entity.errors.map do |field, errors|
+          abbr_value = trim_middle( index.entity.send(field) )
+          "#{field} (#{abbr_value}) #{errors.join(',')}"
+        end.join( "\n" )
+        
+        show_error( "#{index.rc} #{msg}", "Validation Errors" )
       end
       saved
     end
   end
   
   # save record whenever its row is exited
+  # make this work with framework
   def currentChanged( current_index, previous_index )
-    @next_index = nil
-    if current_index.row != previous_index.row
+    if previous_index.valid? && current_index.row != previous_index.row
+      self.next_index = nil
       save_row( previous_index )
     end
     super
   end
   
-  # 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 )
-    @next_index = model_index
-  end
-  
-  # 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 )
-    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 )
-    # can't call super here, for some reason. Qt binding says method not found.
-    # super
-    @hiding = true
-  end
-  
-  # work around situation where an ItemDelegate is open
-  # when the surrouding tab is changed, but the right events
-  # don't arrive.
-  def showEvent( event )
-    super
-    @hiding = false
-  end
-    
-  def focusOutEvent( event )
-    super
-    #~ save_current_row
-  end
-  
-  # this is the only method that is called when an itemDelegate is open
-  # and the tabs are changed.
-  # Work around situation where an ItemDelegate is open
-  # when the surrouding tab is changed, but the right events
-  # don't arrive.
-  def commitData( editor )
-    super
-    save_current_row if @hiding
-  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 )
-    puts "end_edit_hint: #{end_edit_hint.inspect}" if $options[:debug]
-    case end_edit_hint
-      when Qt::AbstractItemDelegate.EditNextItem
-        super( editor, Qt::AbstractItemDelegate.NoHint )
-        set_current_unless_override( current_index.choppy { |i| i.column += 1 } )
-        
-      when Qt::AbstractItemDelegate.EditPreviousItem
-        super( editor, Qt::AbstractItemDelegate.NoHint )
-        set_current_unless_override( current_index.choppy { |i| i.column -= 1 } )
-        
-      else
-        super
-    end
-  end
-  
   # toggle the filter, based on current selection.
   def filter_by_current( bool_filter )
     filter_by_indexes( selection_or_current )
@@ -742,7 +505,7 @@ class TableView < Qt::TableView
   end
 
   # Filter by the value in the current index.
-  # indexes is a collection of Qt::ModelIndex
+  # indexes is a collection of TableIndex instances
   def filter_by_indexes( indexes )
     case
       when filtered?
@@ -751,32 +514,32 @@ class TableView < Qt::TableView
           filtered.undo
           self.filtered = nil
           # update status bar
-          emit status_text( nil )
-          emit filter_status( false )
+          emit_status_text( nil )
+          emit_filter_status( false )
         end
         
       when indexes.empty?
-        emit status_text( "No field selected for filter" )
+        emit_status_text( "No field selected for filter" )
         
       when !indexes.first.field.filterable?
-        emit status_text( "Can't filter on #{indexes.first.field.label}" )
+        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" )
+        emit_status_text( "Can't do multiple selection filters yet" )
       
       when indexes.first.entity.new_record?
-        emit status_text( "Can't filter on a new row" )
+        emit_status_text( "Can't filter on a new row" )
         
       else
         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 )
+          emit_filter_status( filtered.doit )
         end
         # update status bar
-        emit status_text( filtered.status_message )
-      end
-      filtered?
+        emit_status_text( filtered.status_message )
+    end
+    filtered?
   end
   
   # Move to the row for the given entity and the given column.
@@ -784,13 +547,13 @@ class TableView < Qt::TableView
   # 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}"
+    raise "entity is nil" if entity.nil?
+    unless entity.is_a?( model.entity_class )
+      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
+    found_row = busy_cursor do
       model.collection.index_for_entity( entity )
     end
     
@@ -807,16 +570,14 @@ class TableView < Qt::TableView
   # * 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.first.row}" )
+      emit_status_text( "Found #{search_criteria.search_text} at row #{indexes.first.row}" )
       selection_model.clear
       self.current_index = indexes.first
     else
-      emit status_text( "No match found for #{search_criteria.search_text}" )
+      emit_status_text( "No match found for #{search_criteria.search_text}" )
     end
   end
 
@@ -825,11 +586,7 @@ class TableView < Qt::TableView
   # 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
+    raise "framework responsibility"
   end
   
   # execute the block with the TableView instance
@@ -838,21 +595,27 @@ class TableView < Qt::TableView
   # 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?
+    raise "framework responsibility"
   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
+  def raise_widget
+    raise "framework responsibility"
   end
   
-protected
+  # set next_index for certain operations. Is only activated when
+  # to_next_index is called.
+  attr_accessor :next_index
 
+protected
+  
+  # show a busy cursor, do the block, back to normal cursor
+  # return value of block
+  # TODO implement generic way of indicating framework responsibility
+  # :busy_cursor
+  
   # return either the set of indexes with all invalid indexes
   # remove, or the current selection.
   def indexes_or_current( indexes )
@@ -865,12 +628,21 @@ protected
     
     # 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?}
+    # ie 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
-  
+
+  # move to next_index, if it's set
+  def to_next_index
+    if next_index
+      self.current_index = next_index
+      self.next_index = nil
+    end
+  end
 end
 
+require 'clevic/table_view_paste.rb'
+
 end