ruber 0.0.1.1

data/lib/ruber/projects/ui/project_files_widget.rb

@@ -0,0 +1,117 @@
+=begin
+** Form generated from reading ui file 'project_files_widget.ui'
+**
+** Created: ven ott 29 17:39:04 2010
+**      by: Qt User Interface Compiler version 4.7.0
+**
+** WARNING! All changes made in this file will be lost when recompiling ui file!
+=end
+
+class Ui_ProjectFilesWidget
+    attr_reader :verticalLayout
+    attr_reader :groupBox
+    attr_reader :gridLayout
+    attr_reader :label
+    attr_reader :extensions
+    attr_reader :label_2
+    attr_reader :include_rules
+    attr_reader :groupBox_2
+    attr_reader :gridLayout_2
+    attr_reader :label_3
+    attr_reader :exclude_rules
+
+    def setupUi(projectFilesWidget)
+    if projectFilesWidget.objectName.nil?
+        projectFilesWidget.objectName = "projectFilesWidget"
+    end
+    projectFilesWidget.resize(518, 576)
+    @verticalLayout = Qt::VBoxLayout.new(projectFilesWidget)
+    @verticalLayout.objectName = "verticalLayout"
+    @groupBox = Qt::GroupBox.new(projectFilesWidget)
+    @groupBox.objectName = "groupBox"
+    @gridLayout = Qt::GridLayout.new(@groupBox)
+    @gridLayout.objectName = "gridLayout"
+    @label = Qt::Label.new(@groupBox)
+    @label.objectName = "label"
+
+    @gridLayout.addWidget(@label, 0, 0, 1, 1)
+
+    @extensions = KDE::LineEdit.new(@groupBox)
+    @extensions.objectName = "extensions"
+
+    @gridLayout.addWidget(@extensions, 0, 1, 1, 1)
+
+    @label_2 = Qt::Label.new(@groupBox)
+    @label_2.objectName = "label_2"
+    @sizePolicy = Qt::SizePolicy.new(Qt::SizePolicy::Preferred, Qt::SizePolicy::Fixed)
+    @sizePolicy.setHorizontalStretch(0)
+    @sizePolicy.setVerticalStretch(0)
+    @sizePolicy.heightForWidth = @label_2.sizePolicy.hasHeightForWidth
+    @label_2.sizePolicy = @sizePolicy
+
+    @gridLayout.addWidget(@label_2, 1, 0, 1, 1)
+
+    @include_rules = Ruber::ProjectFilesRuleChooser.new(@groupBox)
+    @include_rules.objectName = "include_rules"
+    @include_rules.minimumSize = Qt::Size.new(350, 200)
+    @include_rules.focusPolicy = Qt::StrongFocus
+
+    @gridLayout.addWidget(@include_rules, 2, 0, 1, 2)
+
+
+    @verticalLayout.addWidget(@groupBox)
+
+    @groupBox_2 = Qt::GroupBox.new(projectFilesWidget)
+    @groupBox_2.objectName = "groupBox_2"
+    @gridLayout_2 = Qt::GridLayout.new(@groupBox_2)
+    @gridLayout_2.objectName = "gridLayout_2"
+    @label_3 = Qt::Label.new(@groupBox_2)
+    @label_3.objectName = "label_3"
+    @sizePolicy.heightForWidth = @label_3.sizePolicy.hasHeightForWidth
+    @label_3.sizePolicy = @sizePolicy
+
+    @gridLayout_2.addWidget(@label_3, 0, 0, 1, 1)
+
+    @exclude_rules = Ruber::ProjectFilesRuleChooser.new(@groupBox_2)
+    @exclude_rules.objectName = "exclude_rules"
+    @exclude_rules.minimumSize = Qt::Size.new(350, 200)
+    @exclude_rules.focusPolicy = Qt::StrongFocus
+
+    @gridLayout_2.addWidget(@exclude_rules, 1, 0, 1, 1)
+
+
+    @verticalLayout.addWidget(@groupBox_2)
+
+    @label.buddy = @extensions
+    @label_2.buddy = @include_rules
+    @label_3.buddy = @include_rules
+
+    retranslateUi(projectFilesWidget)
+
+    Qt::MetaObject.connectSlotsByName(projectFilesWidget)
+    end # setupUi
+
+    def setup_ui(projectFilesWidget)
+        setupUi(projectFilesWidget)
+    end
+
+    def retranslateUi(projectFilesWidget)
+    projectFilesWidget.windowTitle = Qt::Application.translate("ProjectFilesWidget", "Form", nil, Qt::Application::UnicodeUTF8)
+    @groupBox.title = Qt::Application.translate("ProjectFilesWidget", "Files to include", nil, Qt::Application::UnicodeUTF8)
+    @label.text = Qt::Application.translate("ProjectFilesWidget", "Extensions", nil, Qt::Application::UnicodeUTF8)
+    @label_2.text = Qt::Application.translate("ProjectFilesWidget", "&Rules", nil, Qt::Application::UnicodeUTF8)
+    @groupBox_2.title = Qt::Application.translate("ProjectFilesWidget", "Files to exclude", nil, Qt::Application::UnicodeUTF8)
+    @label_3.text = Qt::Application.translate("ProjectFilesWidget", "&Rules", nil, Qt::Application::UnicodeUTF8)
+    end # retranslateUi
+
+    def retranslate_ui(projectFilesWidget)
+        retranslateUi(projectFilesWidget)
+    end
+
+end
+
+module Ui
+    class ProjectFilesWidget < Ui_ProjectFilesWidget
+    end
+end  # module Ui
+

data/lib/ruber/projects/ui/project_files_widget.ui

@@ -0,0 +1,123 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>ProjectFilesWidget</class>
+ <widget class="QWidget" name="ProjectFilesWidget">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>518</width>
+    <height>576</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <widget class="QGroupBox" name="groupBox">
+     <property name="title">
+      <string>Files to include</string>
+     </property>
+     <layout class="QGridLayout" name="gridLayout">
+      <item row="0" column="0">
+       <widget class="QLabel" name="label">
+        <property name="text">
+         <string>Extensions</string>
+        </property>
+        <property name="buddy">
+         <cstring>extensions</cstring>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="1">
+       <widget class="KLineEdit" name="extensions"/>
+      </item>
+      <item row="1" column="0">
+       <widget class="QLabel" name="label_2">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="text">
+         <string>&amp;Rules</string>
+        </property>
+        <property name="buddy">
+         <cstring>include_rules</cstring>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="0" colspan="2">
+       <widget class="Ruber::ProjectFilesRuleChooser" name="include_rules" native="true">
+        <property name="minimumSize">
+         <size>
+          <width>350</width>
+          <height>200</height>
+         </size>
+        </property>
+        <property name="focusPolicy">
+         <enum>Qt::StrongFocus</enum>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item>
+    <widget class="QGroupBox" name="groupBox_2">
+     <property name="title">
+      <string>Files to exclude</string>
+     </property>
+     <layout class="QGridLayout" name="gridLayout_2">
+      <item row="0" column="0">
+       <widget class="QLabel" name="label_3">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="text">
+         <string>&amp;Rules</string>
+        </property>
+        <property name="buddy">
+         <cstring>include_rules</cstring>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="0">
+       <widget class="Ruber::ProjectFilesRuleChooser" name="exclude_rules" native="true">
+        <property name="minimumSize">
+         <size>
+          <width>350</width>
+          <height>200</height>
+         </size>
+        </property>
+        <property name="focusPolicy">
+         <enum>Qt::StrongFocus</enum>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>KLineEdit</class>
+   <extends>QLineEdit</extends>
+   <header>klineedit.h</header>
+  </customwidget>
+  <customwidget>
+   <class>Ruber::ProjectFilesRuleChooser</class>
+   <extends>QWidget</extends>
+   <header>ruber_projectfilesrulechooser.h</header>
+   <container>1</container>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>

data/lib/ruber/qt_sugar.rb

@@ -0,0 +1,673 @@
+=begin 
+    Copyright (C) 2010 by Stefano Crocco   
+    stefano.crocco@alice.it   
+  
+    This program is free software; you can redistribute it andor modify  
+    it under the terms of the GNU General Public License as published by  
+    the Free Software Foundation; either version 2 of the License, or     
+    (at your option) any later version.                                   
+  
+    This program is distributed in the hope that it will be useful,       
+    but WITHOUT ANY WARRANTY; without even the implied warranty of        
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         
+    GNU General Public License for more details.                          
+  
+    You should have received a copy of the GNU General Public License     
+    along with this program; if not, write to the                         
+    Free Software Foundation, Inc.,                                       
+    59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             
+=end
+
+require 'yaml'
+
+module Qt
+  
+  NilObject = Object.new{self.object_name = 'nil object'}
+  
+  class Base
+    
+    def nil_object?
+      # if the object doesn't inherit from Qt::Object, meta_object will raise
+      # an exception
+      self.meta_object
+      self.equal? NilObject
+    end
+
+=begin rdoc
+  :call-seq:
+  obj.named_connect(sig, name){||...}
+    
+  It works as Qt::Base#connect, except for the fact that it associates a name
+  with the connection. This way, you can use <tt>Qt::base#named_disconnect</tt>
+  to disconnect the block from the signal.
+    
+  This is implemented by tracking the object internally created by Qt to manage
+  the connection and assigning it a name, so that it can then be found using 
+  <tt>find_child</tt>. 
+    
+  <b>Note:</b> this method assumes that only one object of class
+  <tt>Qt::SignalBlockInvocation</tt> is created by +connect+. If it isn't so, 
+  +RuntimeError+ will be raised.
+=end
+    def named_connect signal, name, &blk
+      old_children = find_children(Qt::SignalBlockInvocation)
+#       old_children = find_children(Qt::Object).select{|c| c.class == Qt::SignalBlockInvocation}
+      res = self.connect(signal, &blk)
+      return nil unless res
+#       new_children = find_children(Qt::Object).select{|c| c.class == Qt::SignalBlockInvocation} - old_children
+      new_children = find_children(Qt::SignalBlockInvocation) - old_children
+      unless new_children.size == 1
+        raise RuntimeError, "Wrong number of new children: #{new_children.size} instead of 1" 
+      end
+      new_children.first.object_name = name
+      true
+    end
+
+=begin rdoc
+  Breaks the connection with name _name_ (which should have been created using
+  <tt>named_connect</tt>)
+=end
+    def named_disconnect name
+      rec = find_child Qt::SignalBlockInvocation, name
+      disconnect self, nil, rec, nil
+    end
+    
+  end
+  
+  class Point
+    
+    yaml_as "tag:ruby.yaml.org,2002:Qt::Point"
+    
+    def self.yaml_new cls, tag, val
+      x, y= val['x'], val['y']
+      Qt::Point.new(x, y)
+    end
+    
+    def to_yaml opts = {}
+      YAML.quick_emit(self, opts) do |out|
+        out.map(taguri, to_yaml_style) do |map|
+          map.add 'x', self.x
+          map.add 'y', self.y
+        end
+      end
+    end
+    
+    def _dump _
+      "#{x};#{self.y}"
+    end
+    
+    def self._load str
+      x, y = str.split ';'
+      self.new x.to_i, y.to_i
+    end
+    
+  end
+  
+  class PointF
+    
+    yaml_as "tag:ruby.yaml.org,2002:Qt::PointF"
+    
+    def self.yaml_new cls, tag, val
+      x, y= val['x'], val['y']
+      Qt::PointF.new(x.to_f, y.to_f)
+    end
+    
+    def to_yaml opts = {}
+      YAML.quick_emit(self, opts) do |out|
+        out.map(taguri, to_yaml_style) do |map|
+          loc = Qt::Locale.c
+          loc.number_options = Qt::Locale::OmitGroupSeparator
+          map.add 'x', loc.to_string( self.x )
+          map.add 'y', loc.to_string( self.y )
+        end
+      end
+    end
+    
+    def _dump _
+      loc = Qt::Locale.c
+      loc.number_options = Qt::Locale::OmitGroupSeparator
+      sx = loc.to_string( self.x )
+      sy = loc.to_string( self.y )
+      "#{sx};#{sy}"
+    end
+    
+    def self._load str
+      x, y = str.split ';'
+      self.new x.to_f, y.to_f
+    end
+    
+  end
+  
+  class Size
+    
+    yaml_as "tag:ruby.yaml.org,2002:Qt::Size"
+    
+    def self.yaml_new cls, tag, val
+      width, height= val['width'], val['height']
+      Qt::Size.new(width, height)
+    end
+    
+    def to_yaml opts = {}
+      YAML.quick_emit(self, opts) do |out|
+        out.map(taguri, to_yaml_style) do |map|
+          map.add 'width', width
+          map.add 'height', height
+        end
+      end
+    end
+    
+    def _dump _
+      "#{width};#{height}"
+    end
+    
+    def self._load str
+      w, h = str.split ';'
+      self.new w.to_i, h.to_i
+    end
+    
+    
+  end
+  
+  class SizeF
+    
+    yaml_as "tag:ruby.yaml.org,2002:Qt::SizeF"
+    
+    def self.yaml_new cls, tag, val
+      width, height= val['width'], val['height']
+      Qt::SizeF.new(width.to_f, height.to_f)
+    end
+    
+    def to_yaml opts = {}
+      YAML.quick_emit(self, opts) do |out|
+        out.map(taguri, to_yaml_style) do |map|
+          loc = Qt::Locale.c
+          loc.number_options = Qt::Locale::OmitGroupSeparator
+          map.add 'width', loc.to_string(width)
+          map.add 'height', loc.to_string(height)
+        end
+      end
+    end
+    
+    def _dump _
+      loc = Qt::Locale.c
+      loc.number_options = Qt::Locale::OmitGroupSeparator
+      sw = loc.to_string width
+      sh = loc.to_string height
+      "#{sw};#{sh}"
+    end
+    
+    def self._load str
+      w, h = str.split ';'
+      self.new w.to_f, h.to_f
+    end
+    
+  end
+  
+  class Rect
+    
+    yaml_as "tag:ruby.yaml.org,2002:Qt::Rect"
+    
+    def self.yaml_new cls, tag, val
+      left, top, width, height= val['left'], val['top'], val['width'], 
+          val['height']
+      self.new(left, top, width, height)
+    end
+    
+    def to_yaml opts = {}
+      YAML.quick_emit(self, opts) do |out|
+        out.map(taguri, to_yaml_style) do |map|
+          map.add 'left', left
+          map.add 'top', top
+          map.add 'width', width
+          map.add 'height', height
+        end
+      end
+    end
+    
+    def _dump _
+      "#{left};#{top};#{width};#{height}"
+    end
+    
+    def self._load str
+      l, t, w, h = str.split ';'
+      self.new l.to_i, t.to_i, w.to_i, h.to_i
+    end
+    
+  end
+  
+  class RectF
+    
+    yaml_as "tag:ruby.yaml.org,2002:Qt::RectF"
+    
+    def self.yaml_new cls, tag, val
+      left, top, width, height= val['left'], val['top'], val['width'], 
+          val['height']
+      Qt::RectF.new(left.to_f, top.to_f, width.to_f, height.to_f)
+    end
+    
+    def to_yaml opts = {}
+      YAML.quick_emit(self, opts) do |out|
+        out.map(taguri, to_yaml_style) do |map|
+          loc = Qt::Locale.c
+          loc.number_options = Qt::Locale::OmitGroupSeparator
+          map.add 'left', loc.to_string(left)
+          map.add 'top', loc.to_string(top)
+          map.add 'width', loc.to_string(width)
+          map.add 'height', loc.to_string(height)
+        end
+      end
+    end
+    
+    def _dump _
+      loc = Qt::Locale.c
+      loc.number_options = Qt::Locale::OmitGroupSeparator
+      sl = loc.to_string left
+      st = loc.to_string top
+      sw = loc.to_string width
+      sh = loc.to_string height
+      "#{sl};#{st};#{sw};#{sh}"
+    end
+    
+    def self._load str
+      l, t, w, h = str.split ';'
+      self.new l.to_f, t.to_f, w.to_f, h.to_f
+    end
+    
+  end
+  
+  class Color
+    yaml_as "tag:ruby.yaml.org,2002:Qt::Color"
+    
+    def self.yaml_new cls, tag, val
+      r, g, b= val['red'], val['green'], val['blue']
+      Qt::Color.new(r, g, b)
+    end
+    
+    def to_yaml opts = {}
+      YAML.quick_emit(self, opts) do |out|
+        out.map(taguri, to_yaml_style) do |map|
+          map.add 'red', red
+          map.add 'green', green
+          map.add 'blue', blue
+        end
+      end
+    end
+    
+    def _dump _
+      "#{red};#{green};#{blue}"
+    end
+    
+    def self._load str
+      r, g, b = str.split ';'
+      self.new r.to_i, g.to_i, b.to_i
+    end
+    
+  end
+  
+  class Date
+    yaml_as "tag:ruby.yaml.org,2002:Qt::Date"
+    
+    def self.yaml_new cls, tag, val
+      y, m, d = val['year'], val['month'], val['day']
+      Qt::Date.new(y, m, d)
+    end
+    
+    def to_yaml opts = {}
+      YAML.quick_emit(self, opts) do |out|
+        out.map(taguri, to_yaml_style) do |map|
+          map.add 'year', year
+          map.add 'month', month
+          map.add 'day', day
+        end
+      end
+    end
+    
+    def _dump _
+      "#{year};#{month};#{day}"
+    end
+    
+    def self._load str
+      y, m, d = str.split ';'
+      self.new(y.to_i, m.to_i, d.to_i)
+    end
+    
+  end
+  
+  class DateTime
+    yaml_as "tag:ruby.yaml.org,2002:Qt::DateTime"
+    
+    def self.yaml_new cls, tag, val
+      date, time, spec = val['date'], val['time'], val['time_spec']
+      Qt::DateTime.new date, time, spec
+    end
+    
+    def to_yaml opts = {}
+      YAML.quick_emit(self, opts) do |out|
+        out.map(taguri, to_yaml_style) do |map|
+          map.add 'date', date
+          map.add 'time', time
+          map.add 'time_spec', time_spec
+        end
+      end
+    end
+    
+    def _dump _
+      Marshal.dump [date, time, time_spec]
+    end
+    
+    def self._load str
+      date, time, time_spec = Marshal.load str
+      self.new date, time, time_spec
+    end
+    
+  end
+  
+  class Font
+    yaml_as "tag:ruby.yaml.org,2002:Qt::Font"
+    
+    def self.yaml_new cls, tag, val
+      res = Qt::Font.new
+      res.from_string val
+      res
+    end
+    
+    def to_yaml opts = {}
+      YAML.quick_emit(self, opts) do |out|
+        out.scalar taguri, to_string, :plain
+      end
+    end
+    
+    def _dump _
+      to_string
+    end
+    
+    def self._load str
+      res = Qt::Font.new
+      res.from_string str
+      res
+    end
+    
+  end
+  
+  class Time
+    yaml_as "tag:ruby.yaml.org,2002:Qt::Time"
+    
+    def self.yaml_new cls, tag, val
+      if val['valid']
+        Qt::Time.new val['hours'], val['minutes'], val['seconds'], val['msec']
+      else Qt::Time.new
+      end
+    end
+    
+    def to_yaml opts = {}
+      YAML.quick_emit(self, opts) do |out|
+        out.map(taguri, to_yaml_style) do |map|
+          map.add 'valid', valid?
+          if valid?
+            map.add 'hours', hour
+            map.add 'minutes', minute
+            map.add 'seconds', second
+            map.add 'msec', msec
+          end
+        end
+      end
+    end
+    
+    def _dump _
+      if valid? then "#{hour};#{minute};#{second};#{msec}"
+      else ""
+      end
+    end
+    
+    def self._load str
+      if str.empty? then self.new
+      else
+        h, m, s, ms = str.split ';'
+        self.new h.to_i, m.to_i, s.to_i, ms.to_i
+      end
+    end
+    
+  end
+  
+  class Url
+    yaml_as "tag:ruby.yaml.org,2002:Qt::Url"
+    
+    def self.yaml_new cls, tag, val
+      Qt::Url.new val
+    end
+    
+    def to_yaml opts = {}
+      YAML.quick_emit(self, opts) do |out|
+        out.scalar taguri, to_string, :plain
+      end
+    end
+    
+    def _dump _
+      to_string
+    end
+    
+    def self._load str
+      self.new str
+    end
+    
+  end
+  
+  class StandardItemModel
+
+    include QtEnumerable
+
+=begin rdoc
+If given a block, calls it once for each top level item. This means that items
+in the same row but in different columns will each cause a separate block execution.
+
+If a block isn't given, returns an +Enumerator+ which does the same as above.
+=end
+    def each
+      if block_given?
+        rowCount.times do |i|
+          columnCount.times do |j| 
+            it = item(i,j)
+            yield it if it
+          end
+        end
+      else self.to_enum
+      end
+    end
+
+=begin rdoc
+If given a block, calls it once for each top level row, passing it an array containing
+the items in the row. If the number of columns varies from row to row, the arrays
+corresponding to the ones with less items will have *nil* instead of the missing
+items.
+
+If a block isn't given, returns an +Enumerator+ which does the same as above.
+=end
+    def each_row
+      if block_given?
+        rowCount.times do |r|
+          a = [] 
+          columnCount.times{|c| a << item(r, c)}
+          yield a
+        end
+      else self.to_enum(:each_row)
+      end
+    end
+
+  end
+
+  class SortFilterProxyModel
+    
+    include QtEnumerable
+
+=begin rdoc
+ Calls the block for each top-level item
+=end
+    def each
+      rowCount.times do |r|
+        columnCount.times{|c| yield index(r,c)}
+      end
+    end
+
+  end
+
+  class StandardItem
+
+    include QtEnumerable
+
+=begin rdoc
+ Iterates on all child items. If no block is given, returns an Enumerator
+
+ <b>Note: </b>this method iterates only on those items which are directly child
+ of +self+; it's not recursive.
+=end
+    def each
+      if block_given?
+        rowCount.times do |i|
+          columnCount.times do |j|
+            c = child i, j
+            yield c if c
+          end
+        end
+      else self.to_enum
+      end
+    end
+    
+=begin rdoc
+Passes an array containing the items in each of the children rows. Returns an
+Enumerator if called without a block
+=end
+    def each_row
+      if block_given?
+        rowCount.times do |i|
+          a = []
+          columnCount.times{|j| a << child( i,j)}
+          yield a
+        end
+      else to_enum
+      end
+    end
+
+    # Returns true if the check state is <tt>Qt::Checked</tt> or <tt>Qt::PartiallyChecked</tt>
+    def checked?
+      check_state != Qt::Unchecked
+    end
+
+# Returns *true* if the check_state is <tt>Qt::Checked</tt> and *false* otherwise
+    def fully_checked?
+      self.check_state == Qt::Checked
+    end
+
+=begin rdoc
+ Sets the check state to <tt>Qt::Unchecked</tt> if _value_ is +false+ or +nil+
+ and to <tt>Qt::Checked</tt> otherwise
+=end
+    def checked= value
+      self.check_state = (value ? Qt::Checked : Qt::Unchecked)
+    end
+
+  end
+
+  class Variant
+    
+    def to_sym
+      to_string.to_sym
+    end
+    
+=begin rdoc
+Redefinition of <tt>to_bool</tt> it's needed because otherwise the Object#to_bool
+method defined in <tt>facets/boolean</tt> is used, instead of calling method_missing.
+
+By explicitly define a <tt>to_bool</method> and having it call <tt>method_missing</tt>,
+the problem is solved
+=end
+    def to_bool
+      method_missing :to_bool
+    end
+    
+  end
+  
+  class MetaObject
+    
+    def each_signal
+      if block_given?
+        method_count.times do |i|
+          m = method i
+          yield m if m.method_type == Qt::MetaMethod::Signal
+        end
+      else self.enum_for(:each_signal)
+      end
+    end
+    
+    def each_slot
+      if block_given?
+        method_count.times do |i|
+          m = method i
+          yield m if m.method_type == Qt::MetaMethod::Slot
+        end
+      else self.enum_for(:each_slot)
+      end
+    end
+    
+    def each_method
+      if block_given?
+        method_count.times{|i| yield method i}
+      else self.enum_for(:each_method)
+      end
+    end
+    
+  end
+  
+  class Qt::StackedWidget
+   
+    include QtEnumerable
+    
+=begin rdoc
+Calls the block for each widget in the stack, or returns an enumerator if no block
+is given
+=end
+    def each
+      if block_given?
+        count.times{|i| yield widget(i)}
+      else to_enum
+      end
+    end
+    
+    def empty?
+      self.count == 0
+    end
+    
+  end
+  
+end
+
+=begin rdoc
+Qt::StandardItemModel-derived class which allow to set flags for all the items.
+To do so, simply set the global_flags attribute to the desired flags.
+=end
+class GlobalFlagStandardItemModel < Qt::StandardItemModel
+  
+=begin rdoc
+The flags which should be returned by every call to flags.
+=end
+  attr_accessor :global_flags
+  
+=begin rdoc
+Creates a new GlobalFlagStandardItemModel. The global_flags attribute for the new
+model will be set to nil. This means that the flags method will behave exactly as
+the Qt::StandardItemModel#flags method.
+=end
+  def initialize parent = nil
+    super
+    @global_flags = nil
+  end
+  
+=begin rdoc
+Returns the flags associated with the index _idx_. If returns the value contained
+in the global_flags attribute if it is not nil, otherwise it will call
+Qt::StandardItemModel#flags and return that value
+=end
+  def flags idx
+    @global_flags || super
+  end
+  
+end