clevic 0.12.0 → 0.13.0.b1

data/lib/clevic/qt/delegates.rb

@@ -0,0 +1 @@
+

data/lib/clevic/qt/distinct_delegate.rb

@@ -0,0 +1,35 @@
+require 'clevic/qt/combo_delegate.rb'
+
+module Clevic
+
+# Provide a list of all values in this field,
+# and allow new values to be entered.
+# :frequency can be set as an option. Boolean. If it's true
+# the options are sorted in order of most frequently used first.
+class DistinctDelegate < ComboDelegate
+  
+  def needs_combo?
+    # works except when there is a '' in the column
+    entity_class.adaptor.count( attribute.to_s, find_options ) > 0
+  end
+  
+  def populate_current( editor, model_index )
+    # already done in the SQL query in populate, so don't even check
+  end
+  
+  def populate( editor, model_index )
+    # we only use the first column, so use the second
+    # column to sort by, since SQL requires the order by clause
+    # to be in the select list where distinct is involved
+    entity_class.adaptor.attribute_list( attribute, model_index.attribute_value, field.description, field.frequency, find_options ) do |row|
+      value = row[attribute]
+      editor.add_item( value, value.to_variant )
+    end
+  end
+  
+  def translate_from_editor_text( editor, text )
+    text
+  end
+end
+
+end

data/lib/clevic/qt/extensions.rb

@@ -0,0 +1,52 @@
+require 'set'
+
+require 'qtext/flags.rb'
+require 'clevic/table_index.rb'
+
+# convenience methods
+module Qt
+  PasteRole = UserRole + 1 unless defined?( PasteRole )
+  
+  class AbstractItemDelegate
+    # overridden in EntryDelegate subclasses
+    def full_edit
+    end
+  end
+  
+  # This provides a bunch of methods to get easy access to the entity
+  # and it's values directly from the index without having to keep
+  # asking the model and jumping through other unncessary hoops
+  class ModelIndex
+    include Clevic::TableIndex
+  end
+  
+  class ItemSelectionModel
+    # return an array of integer indexes for currently selected rows
+    def row_indexes
+      selected_indexes.inject(Set.new) do |set,index|
+        set << index.row
+      end.to_a
+    end
+
+    # return a collection of selection ranges
+    # in Qt this means an ItemSelection instance
+    def ranges
+      selection
+    end
+    
+    def single_cell?
+      ranges.size == 1 && ranges.first.single_cell?
+    end
+  end
+  
+  # implement accepted? and rejected? for TableView#confirm_dialog and friends
+  class MessageBox
+    def accepted?
+      [ Qt::Dialog::Accepted, Qt::MessageBox::Yes, Qt::MessageBox::Ok ].include?( result )
+    end
+
+    def rejected?
+      [ Qt::Dialog::Rejected, Qt::MessageBox::No, Qt::MessageBox::Cancel ].include?( result )
+    end
+  end
+end

data/lib/clevic/qt/field.rb

@@ -0,0 +1,18 @@
+module Clevic
+
+class Field
+  # Convert something that responds to to_s into a Qt::Color,
+  # or just return the argument if it's already a Qt::Color
+  def string_or_color( s_or_c )
+    case s_or_c
+    when NilClass
+      nil
+    when Qt::Color
+      s_or_c
+    else
+      Qt::Color.new( s_or_c.to_s )
+    end
+  end
+end
+
+end

data/lib/clevic/{item_delegate.rb → qt/item_delegate.rb}

@@ -13,8 +13,10 @@ module Clevic
 class ItemDelegate < Qt::ItemDelegate
   attr_reader :field
   
-  def initialize( parent, field )
-    super( parent )
+  def initialize( field )
+    raise "field is nil" if field.nil?
+    # pass nil as Qt object's parent. Will set parent later.
+    super( nil )
     @field = field
   end
   
@@ -40,8 +42,10 @@ class ItemDelegate < Qt::ItemDelegate
   end
 
   # This catches the event that begins the edit process.
-  #~ def editorEvent ( event, model, style_option_view_item, model_index )
-  #~ end
+  def editorEvent ( event, model, style_option_view_item, model_index )
+    parent.before_edit_index = model_index
+    super
+  end
 
   # This is called when one of the EditTriggers is pressed. So
   # it's only good for opening a generic keystroke editor, not

data/lib/clevic/qt/relational_delegate.rb

@@ -0,0 +1,87 @@
+require 'clevic/qt/combo_delegate.rb'
+
+module Clevic
+
+# Edit a relation from an id and display a list of relevant entries.
+#
+# attribute is the method to call on the row entity to retrieve the related object.
+# 
+# The ids of the model objects are stored in the item data
+# and the item text is fetched from them using attribute_path.
+class RelationalDelegate < ComboDelegate
+  def initialize( field )
+    super
+    unless find_options[:conditions].nil?
+      find_options[:conditions].gsub!( /true/, field.related_class.adaptor.quoted_true )
+      find_options[:conditions].gsub!( /false/, field.related_class.adaptor.quoted_false )
+    end
+  end
+  
+  def needs_combo?
+    field.related_class.adaptor.count( :conditions => find_options[:conditions] ) > 0
+  end
+  
+  def empty_set_message
+    "There must be records in #{field.related_class.name.humanize} for this field to be editable."
+  end
+  
+  # add the current item, unless it's already in the combo data
+  def populate_current( editor, model_index )
+    # always add the current selection, if it isn't already there
+    # and it makes sense. This is to make sure that if the list
+    # is filtered, we always have the current value if the filter
+    # excludes it
+    unless model_index.nil?
+      item = model_index.attribute_value
+      if item
+        item_index = editor.find_data( item.id.to_variant )
+        if item_index == -1
+          add_to_list( editor, model_index, item )
+        end
+      end
+    end
+  end
+
+  def populate( editor, model_index )
+    # add set of all possible related entities
+    field.related_class.adaptor.find( :all, find_options ).each do |x|
+      add_to_list( editor, model_index, x )
+    end
+  end
+  
+  def add_to_list( editor, model_index, item )
+    editor.add_item( model_index.field.transform_attribute( item ), item.id.to_variant )
+  end
+  
+  # send data to the editor
+  def setEditorData( editor, model_index )
+    if is_combo?( editor )
+      unless model_index.attribute_value.nil?
+        editor.current_index = editor.find_data( model_index.attribute_value.id.to_variant )
+      end
+      editor.line_edit.select_all
+    end
+  end
+  
+  # don't allow new values
+  def restricted?
+    true
+  end
+  
+  # return an AR entity object
+  def translate_from_editor_text( editor, text )
+    item_index = editor.find_text( text )
+    
+    # fetch record id from editor item_data
+    item_data = editor.item_data( item_index )
+    if item_data.valid?
+      # get the entity it refers to, if there is one
+      # use find_by_id so that if it's not found, nil will
+      # be returned
+      field.related_class.adaptor.find( item_data.to_int )
+    end
+  end
+  
+end
+
+end

data/lib/clevic/{search_dialog.rb → qt/search_dialog.rb}

@@ -1,5 +1,5 @@
 require 'Qt4'
-require 'clevic/ui/search_dialog_ui.rb'
+require 'clevic/qt/ui/search_dialog_ui.rb'
 require 'qtext/flags.rb'
 
 module Clevic
@@ -59,16 +59,6 @@ module Clevic
         search_combo.add_item( search_combo.current_text )
       end
       
-      #~ Qt::MatchExactly	0	Performs QVariant-based matching.
-      #~ Qt::MatchFixedString	8	Performs string-based matching. String-based comparisons are case-insensitive unless the MatchCaseSensitive flag is also specified.
-      #~ Qt::MatchContains	1	The search term is contained in the item.
-      #~ Qt::MatchStartsWith	2	The search term matches the start of the item.
-      #~ Qt::MatchEndsWith	3	The search term matches the end of the item.
-      #~ Qt::MatchCaseSensitive	16	The search is case sensitive.
-      #~ Qt::MatchRegExp	4	Performs string-based matching using a regular expression as the search term.
-      #~ Qt::MatchWildcard	5	Performs string-based matching using a string with wildcards as the search term.
-      #~ Qt::MatchWrap	32	Perform a search that wraps around, so that when the search reaches the last item in the model, it begins again at the first item and continues until all items have been examined.
-      
       retval
     end
     

data/lib/clevic/qt/set_delegate.rb

@@ -0,0 +1,44 @@
+require 'clevic/qt/combo_delegate.rb'
+
+module Clevic
+
+# A Combo box which allows a set of values. May or may not
+# be restricted to the set.
+class SetDelegate < ComboDelegate
+  # options must contain a :set => [ ... ] to specify the set of values.
+  def initialize( field )
+    raise "RestrictedDelegate must have a :set in options" if field.set.nil?
+    super
+  end
+  
+  def needs_combo?
+    true
+  end
+  
+  def restricted?
+    field.restricted || false
+  end
+  
+  def populate( editor, model_index )
+    field.set_for( model_index.entity ).each do |item|
+      if item.is_a?( Array )
+        # this is a hash-like set, so use key as db value
+        # and value as display value
+        editor.add_item( item.last, item.first.to_variant )
+      else
+        editor.add_item( item, item.to_variant )
+      end
+    end
+  end
+  
+  def createEditor( parent_widget, style_option_view_item, model_index )
+    editor = super
+    
+    # the set is provided, so never insert things
+    editor.insert_policy = Qt::ComboBox::NoInsert
+    editor
+  end
+    
+end
+
+end

data/lib/clevic/qt/table_model.rb

@@ -0,0 +1,331 @@
+require 'Qt4'
+require 'date'
+
+require 'andand'
+
+require 'qtext/flags.rb'
+require 'qtext/extensions.rb'
+
+require 'clevic/extensions.rb'
+require 'clevic/qt/extensions.rb'
+require 'clevic/model_column'
+
+module Clevic
+
+=begin rdoc
+An instance of Clevic::TableModel is constructed by Clevic::ModelBuilder from the
+UI definition in a Clevic::View, or from the default Clevic::View created by
+including the Clevic::Record module in a Sequel::Model subclass.
+=end
+class TableModel < Qt::AbstractTableModel
+  include QtFlags
+  
+  signals(
+    # index where error occurred, value, message
+    'data_error(QModelIndex,QVariant,QString)'
+  )
+  
+  def emit_data_error( index, data, string )
+    emit data_error( index, data.to_variant, string )
+  end
+  
+  def initialize( parent = nil )
+    super
+  end
+  
+  # add a new item, and set defaults from the Clevic::View
+  def add_new_item_start
+    begin_insert_rows( Qt::ModelIndex.invalid, row_count, row_count )
+  end
+  
+  def add_new_item_end
+    # notify listeners that the model has changed
+    end_insert_rows
+  end
+  
+  def remove_notify( rows, &block )
+    begin_remove_rows( Qt::ModelIndex.invalid, rows.first, rows.last )
+    # do the removal
+    yield
+    end_remove_rows
+  end
+  
+  # save the AR model at the given index, if it's dirty
+  def update_vertical_header( index )
+    raise "preferably use data_changed here, if possible"
+    emit headerDataChanged( Qt::Vertical, index.row, index.row )
+  end
+  
+  def rowCount( parent = nil )
+    collection.size
+  end
+
+  # Not looked up or aliased properly by Qt bindings
+  def row_count
+    collection.size
+  end
+  
+  def columnCount( parent = nil )
+    fields.size
+  end
+  
+  # Not looked up or aliased properly by Qt bindings
+  def column_count
+    fields.size
+  end
+  
+  def flags( model_index )
+    retval = super
+    
+    # sometimes this actually happens. 
+    # TODO probably a bug in the combo editor exit code
+    return retval if model_index.column >= columnCount
+    
+    # TODO don't return IsEditable if the model is read-only
+    if model_index.meta.type == :boolean
+      retval = item_boolean_flags
+    end
+    
+    unless model_index.field.read_only? || model_index.entity.andand.readonly? || read_only?
+      retval |= qt_item_is_editable.to_i 
+    end
+    retval
+  end
+  
+  # values for horizontal and vertical headers
+  def headerData( section, orientation, role )
+    value = 
+    case role
+      when qt_display_role
+        case orientation
+          when Qt::Horizontal
+            labels[section]
+          when Qt::Vertical
+            # don't force a fetch from the db
+            if collection.cached_at?( section )
+              collection[section].id
+            else
+              section
+            end
+        end
+        
+      when qt_text_alignment_role
+        case orientation
+          when Qt::Vertical
+            Qt::AlignRight | Qt::AlignVCenter
+        end
+          
+      when Qt::SizeHintRole
+        # anything other than nil here makes the headers disappear.
+        nil
+        
+      when qt_tooltip_role
+        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
+          item = collection[section]
+          case
+            when !item.errors.empty?
+              Qt::Color.new( 'orange' )
+            when item.changed?
+              Qt::Color.new( 'yellow' )
+          end
+        end
+        
+      else
+        #~ puts "headerData section: #{section}, role: #{const_as_string(role)}" if $options[:debug]
+        nil
+    end
+    
+    return value.to_variant
+  end
+  
+  # Provide data to UI.
+  def data( index, role = qt_display_role )
+    #~ puts "data for index: #{index.inspect}, field #{index.field.attribute.inspect} and role: #{const_as_string role}"
+    begin
+      case role
+        when qt_display_role
+          # boolean values generally don't have text next to them in this context
+          # check this explicitly to avoid fetching the entity from
+          # the model's collection (and maybe db) when we
+          # definitely don't need to
+          unless index.meta.type == :boolean
+            value = index.display_value
+          end
+          
+        when qt_edit_role
+          # see comment for qt_display_role
+          unless index.meta.type == :boolean
+            value = index.edit_value
+          end
+          
+        when qt_checkstate_role
+          if index.meta.type == :boolean
+            index.raw_value ? qt_checked : qt_unchecked
+          end
+          
+        when qt_text_alignment_role
+          case index.field.alignment
+            when :left; qt_alignleft
+            when :right; qt_alignright
+            when :centre; qt_aligncenter
+            when :justified; qt_alignjustified
+          end
+        
+        # just here to make debug output quieter
+        when qt_size_hint_role;
+        
+        # show field with a red background if there's an error
+        when qt_background_role
+          index.field.background_for( index.entity ) || Qt::Color.new( 'red' ) if index.has_errors?
+        
+        when qt_font_role;
+        
+        when qt_foreground_role
+          index.field.foreground_for( index.entity ) ||
+          if index.field.read_only? || index.entity.andand.readonly? || read_only?
+            Qt::Color.new( 'dimgray' )
+          end
+        
+        when qt_decoration_role;
+          index.field.decoration_for( index.entity )
+        
+        when qt_tooltip_role
+          index.tooltip
+        
+        else
+          puts "data index: #{index}, role: #{const_as_string(role)}" if $options[:debug]
+          nil
+      # return the variant
+      end.to_variant
+        
+    rescue Exception => e
+      # this can generate a lot of errors from view code, so don't emit data_error every one
+      puts "#{entity_view.class.name}.#{index.field.id}: #{index.inspect} for role: #{const_as_string role} #{value.inspect} #{index.entity.inspect}"
+      puts e.message
+      puts e.backtrace
+      nil.to_variant
+    end
+  end
+
+  # data sent from UI
+  # return true if conversion from variant was successful,
+  # or false if something went wrong.
+  def setData( index, variant, role = qt_edit_role )
+    if index.valid?
+      case role
+      when qt_edit_role
+        # Don't allow the primary key to be changed
+        return false if index.attribute == entity_class.primary_key.to_sym
+        
+        if ( index.column < 0 || index.column >= column_count )
+          raise "invalid column #{index.column}" 
+        end
+        
+        begin
+          index.attribute_value =
+          case
+            when value.class.name == 'Qt::Date'
+              Date.new( value.year, value.month, value.day )
+              
+            when value.class.name == 'Qt::Time'
+              Time.new( value.hour, value.min, value.sec )
+            
+            else
+              translate_to_db_object( index, variant.value )
+          end
+          
+          # value conversion was successful
+          data_changed( table_index )
+          true
+        rescue Exception => e
+          puts e.backtrace.join( "\n" )
+          puts e.message
+          emit data_error( index, variant, e.message )
+          # value conversion was not successful
+          false
+        end
+
+      when qt_checkstate_role
+        if index.meta.type == :boolean
+          index.entity.toggle( index.attribute )
+          true
+        else
+          false
+        end
+      
+      # user-defined role
+      # TODO this only works with single-dotted paths
+      when qt_paste_role
+        if index.meta.type == :association
+          field = index.field
+          candidates = field.related_class.find( :all, :conditions => [ "#{field.attribute_path[1]} = ?", variant.value ] )
+          case candidates.size
+            when 0; puts "No match for #{variant.value}"
+            when 1; index.attribute_value = candidates[0]
+            else; puts "Too many for #{variant.value}"
+          end
+        else
+          index.attribute_value = variant.value
+        end
+        true
+        
+      else
+        puts "role: #{role.inspect}"
+        true
+        
+      end
+    else
+      false
+    end
+  end
+  
+  # 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
+
+end #module