clevic 0.11.1 → 0.12.0

data/lib/clevic/extensions.rb

@@ -39,7 +39,7 @@ module Qt
 
   PasteRole = UserRole + 1
   
-  class ItemDelegate
+  class AbstractItemDelegate
     # overridden in EntryDelegate subclasses
     def full_edit
     end

data/lib/clevic/field.rb

@@ -108,17 +108,35 @@ class Field
   # - A symbol is treated as a method to be call on an entity
   property :tooltip
   
-  # The set of allowed values for restricted fields. If it's a hash, the
-  # keys will be stored in the db, and the values displayed in the UI.
+  # An Enumerable of allowed values for restricted fields. If each yields
+  # two values (like it does for a Hash), the
+  # first will be stored in the db, and the second displayed in the UI.
+  # If it's a proc, it must return an Enumerable as above.
   property :set
   
+  # When this is true, only the values in the combo may be entered.
+  # Otherwise the text-entry part of the combo can be used to enter
+  # non-listed values. Default is true if a set is explicitly specified.
+  # Otherwise depends on the field type.
+  property :restricted
+  
   # Only for the distinct field type. The values will be sorted either with the
   # most used values first (:frequency => true) or in alphabetical order (:description => true).
   property :frequency, :description
   
-  # Not implemented. Default value for this field for new records. Not sure how to populate it though.
+  # Default value for this field for new records.
+  # Can be a Proc or a value. A value will just be
+  # set, a proc will be executed with the entity as a parameter.
   property :default
   
+  # the property used for finding the field, ie by TableModel#field_column
+  # defaults to the attribute.
+  property :id
+  
+  # called when the data in this field changes. Either a proc( clevic_view, table_view, model_index ) or a symbol
+  # for a method( view, model_index ) on the Clevic::View object. Both will take 
+  property :notify_data_changed
+  
   # properties for ActiveRecord options
   # There are actually from ActiveRecord::Base.VALID_FIND_OPTIONS, but it's protected
   # each element becomes a property.
@@ -175,6 +193,8 @@ EOF
     
     # instance variables
     @attribute = attribute
+    # default to attribute
+    @id = attribute
     @entity_class = entity_class
     @visible = true
     
@@ -239,7 +259,7 @@ EOF
     else
       @is_date_time ||=
       if display.nil?
-        [:time, :date, :datetime].include?( meta.type )
+        [:time, :date, :datetime, :timestamp].include?( meta.type )
       else
         # it's a virtual field, so we need to use the value
         value.is_a?( Date ) || value.is_a?( Time )
@@ -374,7 +394,7 @@ EOF
   
   # Called by Clevic::TableModel to get the tooltip value
   def tooltip_for( entity )
-    cache_value_for( :background, entity )
+    cache_value_for( :tooltip, entity )
   end
 
   # TODO Doesn't do anything useful yet.
@@ -403,6 +423,36 @@ EOF
     cache_value_for( :background, entity ) {|x| string_or_color(x)}
   end
   
+  def set_default_for( entity )
+    begin
+      entity[attribute] = 
+      case default
+        when String
+          default
+        when Proc
+          default.call( entity )
+      end
+    rescue Exception => e
+      puts e.message
+      puts e.backtrace
+    end
+  end
+  
+  def set_for( entity )
+    case set
+      when Proc
+        # the Proc should return an enumerable
+        set.call( entity )
+        
+      when Symbol
+        entity.send( set )
+        
+      else
+        # assume its an Enumerable
+        set
+    end
+  end
+  
 protected
 
   # call the conversion_block with the value, or just return the

data/lib/clevic/filter_command.rb

@@ -0,0 +1,51 @@
+module Clevic
+  class FilterCommand
+    def initialize( table_view, filter_indexes, filter_conditions )
+      @table_view = table_view
+      @filter_conditions = filter_conditions
+      @filter_indexes = filter_indexes
+      
+      # Better make the status message now, before the indexes become invalid
+      @status_message =
+      begin
+        "Filtered on #{filter_indexes.first.field.label} = #{filter_indexes.first.gui_value}"
+      rescue
+        "Filtered"
+      end
+    end
+    
+    # Do the filtering. Return true if successful, false otherwise.
+    def doit
+      begin
+        # store current AR conditions
+        @stored_conditions = @table_view.model.cache_table.options
+        
+        # store auto_new
+        @auto_new = @table_view.model.auto_new
+        
+        # reload cache table with new conditions
+        @table_view.model.auto_new = false
+        @table_view.model.reload_data( @filter_conditions )
+      rescue Exception => e
+        puts
+        puts e.message
+        puts e.backtrace
+        false
+      end
+      true
+    end
+    
+    def undo
+      # restore auto_new
+      @table_view.model.auto_new = @auto_new
+      
+      # reload cache table with stored AR conditions
+      @table_view.model.reload_data( @stored_conditions )
+    end
+    
+    # return a message based on the conditions
+    def status_message
+      @status_message
+    end
+  end
+end

data/lib/clevic/model_builder.rb

@@ -1,7 +1,9 @@
 require 'activerecord'
+require 'facets/dictionary'
 
 require 'clevic/table_model.rb'
 require 'clevic/delegates.rb'
+require 'clevic/text_delegate.rb'
 require 'clevic/cache_table.rb'
 require 'clevic/field.rb'
 
@@ -273,11 +275,12 @@ class ModelBuilder
     @entity_view = entity_view
     @auto_new = true
     @read_only = false
-    @fields = []
+    @fields = Dictionary.new
     exec_ui_block( &block )
   end
   
   attr_accessor :entity_view
+  attr_accessor :find_options
   
   # execute a block containing method calls understood by Clevic::ModelBuilder
   # arg can be something that responds to define_ui_block,
@@ -301,13 +304,13 @@ class ModelBuilder
   # The collection of Clevic::Field instances where visible == true.
   # the visible may go away.
   def fields
-    @fields.reject{|x| !x.visible}
+    @fields.reject{|id,field| !field.visible}
   end
   
   # return the index of the named field in the collection of fields.
   def index( field_name_sym )
     retval = nil
-    fields.each_with_index{|x,i| retval = i if x.attribute == field_name_sym.to_sym }
+    fields.each_with_index{|id,field,i| retval = i if field.attribute == field_name_sym.to_sym }
     retval
   end
   
@@ -332,7 +335,15 @@ class ModelBuilder
   # an ordinary field, edited in place with a text box
   def plain( attribute, options = {}, &block )
     read_only_default!( attribute, options )
-    @fields << Clevic::Field.new( attribute.to_sym, entity_class, options, &block )
+    @fields[attribute] = Clevic::Field.new( attribute.to_sym, entity_class, options, &block )
+  end
+  
+  # an ordinary field like plain, except that a larger edit area can be used
+  def text( attribute, options = {}, &block )
+    read_only_default!( attribute, options )
+    field = Clevic::Field.new( attribute.to_sym, entity_class, options, &block )
+    field.delegate = TextDelegate.new( nil, field )
+    @fields[attribute] = field
   end
   
   # Returns a Clevic::Field with a DistinctDelegate, in other words
@@ -340,23 +351,27 @@ class ModelBuilder
   def distinct( attribute, options = {}, &block )
     field = Clevic::Field.new( attribute.to_sym, entity_class, options, &block )
     field.delegate = DistinctDelegate.new( nil, field )
-    @fields << field
+    @fields[attribute] = field
   end
-
-  # Returns a Clevic::Field with a RestrictedDelegate, 
-  # a combo box, but restricted to a specified set, from the :set option.
-  def restricted( attribute, options = {}, &block )
-    
+  
+  # a combo box with a set of supplied values
+  def combo( attribute, options = {}, &block )
     field = Clevic::Field.new( attribute.to_sym, entity_class, options, &block )
-    raise "field #{attribute} restricted must have a set" if field.set.nil?
     
-    # TODO this really belongs in a separate 'map' field
+    # TODO this really belongs in a separate 'map' field?
+    # or maybe put it in SetDelegate?
     if field.set.is_a? Hash
-      field.format = lambda{|x| field.set[x]}
+      field.format ||= lambda{|x| field.set[x]}
     end
     
-    field.delegate = RestrictedDelegate.new( nil, field )
-    @fields << field
+    field.delegate = SetDelegate.new( nil, field )
+    @fields[attribute] = field
+  end
+
+  # Returns a Clevic::Field with a restricted SetDelegate, 
+  def restricted( attribute, options = {}, &block )
+    options[:restricted] = true
+    combo( attribute, options, &block )
   end
 
   # for foreign keys. Edited with a combo box using values from the specified
@@ -372,7 +387,7 @@ class ModelBuilder
     # check after all possible options have been collected
     raise ":display must be specified" if field.display.nil?
     field.delegate = RelationalDelegate.new( nil, field )
-    @fields << field
+    @fields[attribute] = field
   end
 
   # mostly used in the new block to define the set of records
@@ -464,7 +479,7 @@ class ModelBuilder
   
   # return the named Clevic::Field object
   def field( attribute )
-    @fields.find {|x| x.attribute == attribute }
+    @fields.find {|id,field| field.attribute == attribute }
   end
   
   # This takes all the information collected
@@ -475,14 +490,16 @@ class ModelBuilder
     # using @model here because otherwise the view's
     # reference to this very same model is garbage collected.
     @model = Clevic::TableModel.new( table_view )
-    table_view.object_name = @object_name
+    @model.builder = self
     @model.entity_view = entity_view
-    @model.fields = @fields
+    @model.fields = @fields.values
     @model.read_only = @read_only
     @model.auto_new = auto_new?
     
+    # setup model
+    table_view.object_name = @object_name
     # set parent for all delegates
-    fields.each {|x| x.delegate.parent = table_view unless x.delegate.nil? }
+    fields.each {|id,field| field.delegate.parent = table_view unless field.delegate.nil? }
     
     # the data
     @model.collection = records
@@ -497,7 +514,7 @@ protected
   #--
   # TODO ActiveRecord-2.1 has smarter includes
   def add_include_options
-    fields.each do |field|
+    fields.each do |id,field|
       if field.delegate.class == RelationalDelegate
         @options[:include] ||= []
         @options[:include] << field.attribute
@@ -539,7 +556,7 @@ protected
   def set_records( arg )
     if arg.class == Hash
       # need to defer this until all fields are collected
-      @options = arg
+      @find_options = arg
     else
       @records = arg
     end
@@ -550,7 +567,7 @@ protected
   def get_records
     if @records.nil?
       #~ add_include_options
-      @records = CacheTable.new( entity_class, @options.merge( :auto_new => auto_new? ) )
+      @records = CacheTable.new( entity_class, @find_options )
     end
     @records
   end

data/lib/clevic/table_model.rb

@@ -19,6 +19,7 @@ class TableModel < Qt::AbstractTableModel
   
   # the CacheTable of Clevic::Record or ActiveRecord::Base objects
   attr_reader :collection
+  alias_method :cache_table, :collection
   
   # the collection of Clevic::Field objects
   attr_reader :fields
@@ -29,8 +30,10 @@ class TableModel < Qt::AbstractTableModel
   # should this model create a new empty record by default?
   attr_accessor :auto_new
   def auto_new?; auto_new; end
+  def auto_new?; auto_new; end
   
   attr_accessor :entity_view
+  attr_accessor :builder
   
   def entity_class
     entity_view.entity_class
@@ -55,6 +58,16 @@ class TableModel < Qt::AbstractTableModel
     @attributes = nil
   end
   
+  # field is a symbol or string referring to a column.
+  # returns the index of that field.
+  def field_column( field )
+    fields.each_with_index {|x,i| return i if x.id == field.to_sym }
+  end
+  
+  def field_for_index( model_index )
+    fields[model_index.column]
+  end
+  
   def labels
     @labels ||= fields.map {|x| x.label }
   end
@@ -116,10 +129,19 @@ class TableModel < Qt::AbstractTableModel
     @metadatas[column]
   end
   
+  # add a new item, and set defaults from the Clevic::View
   def add_new_item
-    # 1 new row
     begin_insert_rows( Qt::ModelIndex.invalid, row_count, row_count )
-    collection << entity_class.new
+    # set default values without triggering changed
+    entity = entity_class.new
+    fields.each do |f|
+      unless f.default.nil?
+        f.set_default_for( entity )
+      end
+    end
+    
+    collection << entity
+    
     end_insert_rows
   end
   
@@ -136,6 +158,9 @@ class TableModel < Qt::AbstractTableModel
       # destroy the db object, and its associated table row
       removed.destroy
     end
+    
+    # create a new row if auto_new is on
+    add_new_item if collection.empty? && auto_new?
   end
   
   # save the AR model at the given index, if it's dirty
@@ -144,7 +169,9 @@ class TableModel < Qt::AbstractTableModel
     return false if item.nil?
     if item.changed?
       if item.valid?
-        item.save
+        retval = item.save
+        emit headerDataChanged( Qt::Vertical, index.row, index.row )
+        retval
       else
         false
       end
@@ -190,8 +217,8 @@ class TableModel < Qt::AbstractTableModel
     retval
   end
   
-  def reload_data( options = {} )
-    # renew cache
+  def reload_data( options = nil )
+    # renew cache. All records will be dropped and reloaded.
     self.collection = self.collection.renew( options )
     # tell the UI we had a major data change
     reset
@@ -318,6 +345,7 @@ class TableModel < Qt::AbstractTableModel
               index.errors.join("\n")
               
             # provide a tooltip when an empty relational field is encountered
+            # TODO should be part of field definition
             when index.metadata.type == :association
               index.field.delegate.if_empty_message
             
@@ -360,6 +388,7 @@ class TableModel < Qt::AbstractTableModel
         
         type = index.metadata.type
         value = variant.value
+        #~ puts "#{type.inspect} is #{value}"
         
         # translate the value from the ui to something that
         # the AR model will understand
@@ -396,12 +425,28 @@ class TableModel < Qt::AbstractTableModel
             # 01:17, 0117, 117, 1 17, are all accepted
             when type == :time && value =~ %r{^(\d{1,2}).?(\d{2})$}
               Time.parse( "#$1:#$2" )
+            
+            # remove thousand separators, allow for space and comma
+            # instead of . as a decimal separator
+            when type == :decimal
+              # do various transforms
+              value = 
+              case
+                # accept a space or a comma instead of a . for floats
+                when value =~ /(.*?)(\d)[ ,](\d{2})$/
+                  "#$1#$2.#$3"
+                else
+                  value
+              end
               
+              # strip remaining commas
+              value.gsub( ',', '' )
+            
             else
               value
           end
           
-          emit dataChanged( index, index )
+          data_changed( index )
           # value conversion was successful
           true
         rescue Exception => e
@@ -460,8 +505,68 @@ class TableModel < Qt::AbstractTableModel
     end
   end
   
-  def field_for_index( model_index )
-    fields[model_index.column]
+  class DataChange
+    class ModelIndexProxy
+      attr_accessor :row
+      attr_accessor :column
+      
+      def initialize( other = nil )
+        unless other.nil?
+          @row = other.row
+          @column = other.column
+        end
+      end
+    end
+    
+    def top_left
+      @top_left ||= ModelIndexProxy.new
+    end
+    
+    def bottom_right
+      @bottom_right ||= ModelIndexProxy.new
+    end
+    
+    attr_writer :bottom_right
+    attr_writer :top_left
+    
+    attr_reader :index
+    def index=( other )
+      self.top_left = ModelIndexProxy.new( other )
+      self.bottom_right = ModelIndexProxy.new( other )
+    end
+  end
+
+  # A rubyish way of doing dataChanged
+  # - if args has one element, it's either a single ModelIndex
+  #   or something that understands top_left and bottom_right. These
+  #   will be turned into a ModelIndex by calling create_index
+  # - if args has two element, assume it's a two ModelIndex instances
+  # - otherwise create a new DataChange and pass it to the block.
+  def data_changed( *args, &block )
+    case args.size
+      when 1
+        arg = args.first
+        if ( arg.respond_to?( :top_left ) && arg.respond_to?( :bottom_right ) ) || arg.is_a?( Qt::ItemSelectionRange )
+          # object is a DataChange, or a SelectionRange
+          top_left_index = create_index( arg.top_left.row, arg.top_left.column )
+          bottom_right_index = create_index( arg.bottom_right.row, arg.bottom_right.column )
+          emit dataChanged( top_left_index, bottom_right_index )
+        else
+          # assume it's a ModelIndex
+          emit dataChanged( arg, arg )
+        end
+      
+      when 2
+        emit dataChanged( args.first, args.last )
+      
+      else
+        unless block.nil?
+          change = DataChange.new
+          block.call( change )
+          # recursive call
+          data_changed( change )
+        end
+    end
   end
   
 end