qtext 0.4.1 → 0.5.0

data/lib/qtext/action_builder.rb

@@ -0,0 +1,156 @@
+require 'Qt4'
+require 'qtext/extensions.rb'
+
+=begin rdoc
+This module can be used to make the construction of collections of actions
+more rubyish. Menus are generally made up of a collection of actions.
+
+Once included, it's intended to be called as follows, where self is a descendant of Qt::Widget:
+  build_actions do
+    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 => :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
+  end
+  
+You can also do something like this:
+
+  build_actions do |ab|
+    ab.list( :edit ) do
+      #~ new_action :action_cut, 'Cu&t', :shortcut => Qt::KeySequence::Cut
+      ab.action :action_copy, '&Copy', :shortcut => Qt::KeySequence::Copy, :method => :copy_current_selection
+    end
+  end
+
+If the including class defines a method called action_triggered( &block ),
+it can be used to wrap the code triggered by actions. That way, the
+including class
+can catch exceptions and things like that. If this method is not
+defined, it will be defined as an empty wrapper.
+=end
+module ActionBuilder
+  def build_actions( &block )
+    yield( self )
+  end
+  
+  def collect_actions
+    @collect_actions ||= []
+  end
+  
+  def collect_actions=( arr )
+    @collect_actions = arr
+  end
+  
+  # create a new separator
+  def separator
+    Qt::Action.construct( parent ) do |action|
+      action.separator = true
+      add_action action
+      collect_actions << action
+    end
+  end
+  
+  # create and return a list of actions. The actions are grouped together, but not
+  # as strongly as with Qt::ActionGroup
+  # a method called "#{group_name}_actions" will be added to self, which will return the
+  # set of Qt::Action instances created in the block
+  def list( group_name, &block )
+    unless respond_to?( "#{group_name.to_s}_actions" )
+      self.class.send( :define_method, "#{group_name.to_s}_actions" ) do
+        eval "@#{group_name.to_s}_actions"
+      end
+    end
+    self.collect_actions = []
+    yield( self )
+    # copy actions to the right instance variable
+    eval "@#{group_name.to_s}_actions = collect_actions"
+  end
+  
+  # Create an action and add_action
+  # block takes predence over options[:method], which is a method
+  # on self to be called.
+  # option keys can be any method in Qt::Action, ie :tool_tip, :shortcut, :status_tip etc
+  # a value for :shortcut is automatically passed to Qt::KeySequence.new
+  def action( name_or_action, text = nil, options = {}, &block )
+    if name_or_action.class == Qt::Action
+      add_action( name_or_action )
+    else
+      name = name_or_action
+      if options.has_key?( :method ) && !block.nil?
+        raise "you can't specify both :method and a block"
+      end
+      
+      Qt::Action.construct( parent ) do |action|
+        action.object_name = name.to_s
+        action.text = text
+        options.each do |k,v|
+          next if k == :method
+          if k == :shortcut
+            action.shortcut = Qt::KeySequence.new( v )
+          else
+            action.send( "#{k.to_s}=", v )
+          end
+        end
+        
+        # add action for Qt
+        add_action action
+        
+        # add actions for list. Yes, it's a side-effect. Is there a better way?
+        collect_actions << action
+        
+        action_method_or_block( action, options, &block )
+      end
+    end
+  end
+  
+  # if parent doesn't define this, add it so that 
+  # our action_method_or_block will work.
+  unless instance_methods.include?( :action_triggered )
+    def action_triggered( &someblock )
+      yield
+    end
+  end
+  
+  # set up the code to be executed when an action is triggered,
+  def action_method_or_block( qt_action, options, &block )
+    signal_name = "triggered(#{options.has_key?( :checkable ) ? 'bool' : ''})"
+    
+    # connect the action to some code
+    if options.has_key?( :method )
+      qt_action.connect SIGNAL( signal_name ) do |active|
+        action_triggered do
+          send_args = [ options[:method], options.has_key?( :checkable ) ? active : nil ].compact
+          send( *send_args )
+        end
+      end
+    else
+      unless block.nil?
+        action_triggered do
+          qt_action.connect SIGNAL( signal_name ) do |active|
+            yield( active )
+          end
+        end
+      end
+    end
+  end
+
+end

data/lib/qtext/extensions.rb

@@ -18,6 +18,9 @@ class Object
 end
 
 class Class
+  # TODO Qt bindings will accept a block for new, which
+  # makes this somewhat irrelevant. Unless it's really
+  # necessary to pass args in
   def construct_exec( *args, &block )
     raise "block is nil" if block.nil?
     inst = self.new( *args )
@@ -27,6 +30,7 @@ class Class
     inst
   end
 
+  # see self.construct
   def construct( *args, &block )
     raise "block is nil" if block.nil?
     inst = self.new( *args )

data/lib/qtext/version.rb

@@ -1,8 +1,8 @@
 module Qtext #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 4
-    TINY  = 1
+    MINOR = 5
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: qtext
 version: !ruby/object:Gem::Version 
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors: 
 - FIXME full name
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-07-23 00:00:00 +02:00
+date: 2008-08-21 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -34,6 +34,7 @@ extra_rdoc_files:
 files: 
 - README.txt
 - lib/qtext.rb
+- lib/qtext/action_builder.rb
 - lib/qtext/version.rb
 - lib/qtext/flags.rb
 - lib/qtext/extensions.rb