qtruby4 1.4.9-mswin32 → 2.1.0.b-mswin32

data/Rakefile

@@ -0,0 +1,5 @@
+task :default do
+	puts "Copy needed files..."
+	require 'fileutils'
+	FileUtils.cp_r( Dir['bin/*'], "../../../../../../bin", :verbose => true )
+end

data/lib/Qt/active_item_model.rb

@@ -0,0 +1,234 @@
+=begin
+This Qt::AbstractItemModel based model allows an ActiveRecord or ActiveResource
+data set be used for viewing in a Qt::TreeView. 
+
+Example usage:
+
+app = Qt::Application.new(ARGV)
+agencies = TravelAgency.find(:all)
+model = ActiveItemModel.new(agencies)
+tree = Qt::TreeView.new
+tree.model = model
+tree.show
+app.exec
+
+Written by Richard Dale and Silvio Fonseca
+
+=end
+
+require 'Qt'
+
+#require "active_record"
+#require "active_support"
+#require "active_resource"
+
+require 'date'
+
+class TreeItem
+    attr_reader :childItems, :resource, :itemData
+
+    def initialize(item, keys, parent = nil, prefix="")
+        @keys = keys
+        @parentItem = parent
+        @childItems = []
+        @resource = item
+        if @resource.respond_to? :attributes
+            @resource.attributes.inject(@itemData = {}) do |data, a|
+                if a[1].respond_to? :attributes
+                    TreeItem.new(a[1], @keys, self, prefix + a[0] + ".")
+                else
+                    data[prefix + a[0]] = a[1]
+                end
+                data
+            end
+        else
+            @itemData = item
+        end
+
+        if @parentItem
+            @parentItem.appendChild(self)
+        end
+    end
+    
+    def appendChild(item)
+        @childItems.push(item)
+    end
+    
+    def child(row)
+        return @childItems[row]
+    end
+    
+    def childCount
+        return @childItems.length
+    end
+    
+    def columnCount
+        return @itemData.length
+    end
+    
+    def data(column)
+        return Qt::Variant.new(@itemData[@keys[column]])
+    end
+    
+    def parent
+        return @parentItem
+    end
+    
+    def row
+        if !@parentItem.nil?
+            return @parentItem.childItems.index(self)
+        end
+    
+        return 0
+    end
+end
+
+class ActiveItemModel < Qt::AbstractItemModel    
+    def initialize(collection, columns=nil)
+        super()
+        @collection = collection
+        @keys = build_keys([], @collection.first.attributes)
+        @keys.inject(@labels = {}) do |labels, k| 
+            labels[k] = k.humanize.gsub(/\./, ' ')
+            labels 
+        end
+
+        @rootItem = TreeItem.new(@labels, @keys)
+        @collection.each do |row|
+            TreeItem.new(row, @keys, @rootItem)
+        end
+    end
+
+    def build_keys(keys, attrs, prefix="")
+        attrs.inject(keys) do |cols, a|
+            if a[1].respond_to? :attributes
+                build_keys(cols, a[1].attributes, prefix + a[0] + ".")
+            else
+                cols << prefix + a[0]
+            end
+        end
+    end
+
+    def [](row)
+        row = row.row if row.is_a?Qt::ModelIndex
+        @collection[row]
+    end
+
+    def column(name)
+        @keys.index name
+    end
+    
+    def columnCount(parent)
+        if parent.valid?
+            return parent.internalPointer.columnCount
+        else
+            return @rootItem.columnCount
+        end
+    end
+    
+    def data(index, role)
+        if !index.valid?
+            return Qt::Variant.new
+        end
+    
+        if role != Qt::DisplayRole
+            return Qt::Variant.new
+        end
+    
+        item = index.internalPointer
+        return item.data(index.column)
+    end
+
+    def setData(index, variant, role=Qt::EditRole)
+        if index.valid? and role == Qt::EditRole
+            raise "invalid column #{index.column}" if (index.column < 0 ||
+                index.column >= @keys.size)
+
+            att = @keys[index.column]
+            item = index.internalPointer
+
+            if ! item.itemData.has_key? att
+                return false
+            end
+
+            value = variant.value
+
+            if value.class.name == "Qt::Date"
+                value = Date.new(value.year, value.month, value.day)
+            elsif value.class.name == "Qt::Time"
+                value = Time.new(value.hour, value.min, value.sec)
+            end
+
+            att.gsub!(/.*\.(.*)/, '\1')
+            # Don't allow the primary key to be changed
+            if att == 'id'
+                return false
+            end
+
+            eval("item.resource.attributes['%s'] = value" % att)
+            item.resource.save
+            emit dataChanged(index, index)
+            return true
+        else
+            return false
+        end
+    end
+    
+    def flags(index)
+        if !index.valid?
+            return Qt::ItemIsEnabled
+        end
+    
+        return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable
+    end
+    
+    def headerData(section, orientation, role)
+        if orientation == Qt::Horizontal && role == Qt::DisplayRole
+            return Qt::Variant.new(@labels[@keys[section]])
+        end
+    
+        return Qt::Variant.new
+    end
+    
+    def index(row, column, parent)
+        if !parent.valid?
+            parentItem = @rootItem
+        else
+            parentItem = parent.internalPointer
+        end
+    
+        @childItem = parentItem.child(row)
+        if ! @childItem.nil?
+            return createIndex(row, column, @childItem)
+        else
+            return Qt::ModelIndex.new
+        end
+    end
+    
+    def parent(index)
+        if !index.valid?
+            return Qt::ModelIndex.new
+        end
+    
+        childItem = index.internalPointer
+        parentItem = childItem.parent
+    
+        if parentItem == @rootItem
+            return Qt::ModelIndex.new
+        end
+    
+        return createIndex(parentItem.row, 0, parentItem)
+    end
+    
+    def rowCount(parent)
+        if !parent.valid?
+            parentItem = @rootItem
+        else
+            parentItem = parent.internalPointer
+        end
+    
+        return parentItem.childCount
+    end
+end
+
+# kate: indent-width 4;

data/lib/Qt/active_table_model.rb

@@ -0,0 +1,122 @@
+=begin
+This table model allows an ActiveRecord or ActiveResource to be used as a
+basis for a Qt::AbstractTableModel for viewing in a Qt::TableView. Example
+usage:
+
+app = Qt::Application.new(ARGV)
+agencies = TravelAgency.find(:all, :conditions => [:name => 'Another Agency'])
+model = ActiveTableModel.new(agencies)
+table = Qt::TableView.new
+table.model = model
+table.show
+app.exec
+
+Written by Richard Dale and Silvio Fonseca
+
+=end
+
+require 'Qt'
+require 'date'
+
+class ActiveTableModel < Qt::AbstractTableModel
+    def initialize(collection, columns=nil)
+        super()
+        @collection = collection
+        if columns
+            if columns.kind_of? Hash
+                @keys=columns.keys
+                @labels=columns.values
+            else
+                @keys=columns
+            end
+        else
+            @keys = build_keys([], @collection.first.attributes)
+        end
+        @labels||=@keys.collect { |k| k.humanize.gsub(/\./, ' ') }
+    end
+
+    def build_keys(keys, attrs, prefix="")
+        attrs.inject(keys) do |cols, a|
+            if a[1].respond_to? :attributes
+                build_keys(cols, a[1].attributes, prefix + a[0] + ".")
+            else
+                cols << prefix + a[0]
+            end
+        end
+    end
+
+    def rowCount(parent)
+        @collection.size
+    end
+
+    def columnCount(parent)
+        @keys.size
+    end
+
+
+    def [](row)
+        row = row.row if row.is_a?Qt::ModelIndex
+        @collection[row]
+    end
+
+    def column(name)
+        @keys.index name
+    end
+
+    def data(index, role=Qt::DisplayRole)
+        invalid = Qt::Variant.new
+        return invalid unless role == Qt::DisplayRole or role == Qt::EditRole
+        item = @collection[index.row]
+        return invalid if item.nil?
+        raise "invalid column #{index.column}" if (index.column < 0 ||
+            index.column >= @keys.size)
+        value = eval("item.attributes['%s']" % @keys[index.column].gsub(/\./, "'].attributes['"))
+        return Qt::Variant.new(value)
+    end
+
+    def headerData(section, orientation, role=Qt::DisplayRole)
+        invalid = Qt::Variant.new
+        return invalid unless role == Qt::DisplayRole
+        v = case orientation
+        when Qt::Horizontal
+            @labels[section]
+        else
+            section
+        end
+        return Qt::Variant.new(v)
+    end
+
+    def flags(index)
+        return Qt::ItemIsEditable | super(index)
+    end
+
+    def setData(index, variant, role=Qt::EditRole)
+        if index.valid? and role == Qt::EditRole
+            att = @keys[index.column]
+            # Don't allow the primary key to be changed
+            if att == 'id'
+                return false
+            end
+
+            item = @collection[index.row]
+            raise "invalid column #{index.column}" if (index.column < 0 ||
+                index.column >= @keys.size)
+            value = variant.value
+
+            if value.class.name == "Qt::Date"
+                value = Date.new(value.year, value.month, value.day)
+            elsif value.class.name == "Qt::Time"
+                value = Time.new(value.hour, value.min, value.sec)
+            end
+
+            eval("item['%s'] = value" % att.gsub(/\./, "']['"))
+            item.save
+            emit dataChanged(index, index)
+            return true
+        else
+            return false
+        end
+    end
+end
+
+# kate: indent-width 4;

data/lib/{qt → Qt}/qtruby4.rb

@@ -3,16 +3,16 @@
                           qtruby.rb  -  description
                              -------------------
     begin                : Fri Jul 4 2003
-    copyright            : (C) 2003-2005 by Richard Dale
-    email                : Richard_Dale@tipitina.demon.co.uk
+    copyright            : (C) 2003-2008 by Richard Dale
+    email                : richard.j.dale@gmail.com
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or 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.                                   *
+ *   it under the terms of the GNU Lesser General Public License as        *
+ *   published by the Free Software Foundation; either version 2 of the    *
+ *   License, or (at your option) any later version.                       *
  *                                                                         *
  ***************************************************************************/
 =end
@@ -42,29 +42,50 @@ module Qt
 	def Qt.debug_level
 		@@debug_level
 	end
-		
+	
+	module Internal
+		#
+		# From the enum MethodFlags in qt-copy/src/tools/moc/generator.cpp
+		#
+		AccessPrivate = 0x00
+		AccessProtected = 0x01
+		AccessPublic = 0x02
+		MethodMethod = 0x00
+		MethodSignal = 0x04
+		MethodSlot = 0x08
+		MethodCompatibility = 0x10
+		MethodCloned = 0x20
+		MethodScriptable = 0x40
+	end
+	
 	class Base
 		def self.signals(*signal_list)
 			meta = Qt::Meta[self.name] || Qt::MetaInfo.new(self)
-			meta.add_signals(signal_list)
+			meta.add_signals(signal_list, Internal::MethodSignal | Internal::AccessProtected)
 			meta.changed = true
 		end
 	
 		def self.slots(*slot_list)
 			meta = Qt::Meta[self.name] || Qt::MetaInfo.new(self)
-			meta.add_slots(slot_list)
+			meta.add_slots(slot_list, Internal::MethodSlot | Internal::AccessPublic)
+			meta.changed = true
+		end
+
+		def self.private_slots(*slot_list)
+			meta = Qt::Meta[self.name] || Qt::MetaInfo.new(self)
+			meta.add_slots(slot_list, Internal::MethodSlot | Internal::AccessPrivate)
 			meta.changed = true
 		end
 
 		def self.q_signal(signal)
 			meta = Qt::Meta[self.name] || Qt::MetaInfo.new(self)
-			meta.add_signals([signal])
+			meta.add_signals([signal], Internal::MethodSignal | Internal::AccessProtected)
 			meta.changed = true
 		end
 
 		def self.q_slot(slot)
 			meta = Qt::Meta[self.name] || Qt::MetaInfo.new(self)
-			meta.add_slots([slot])
+			meta.add_slots([slot], Internal::MethodSlot | Internal::AccessPublic)
 			meta.changed = true
 		end
 
@@ -151,6 +172,7 @@ module Qt
 #		Object has a '==' operator instance method, so pretend it
 #		don't exist by calling method_missing() explicitely
 		def ==(a)
+			return false if a.nil?
 			begin
 				Qt::method_missing(:==, self, a)
 			rescue
@@ -158,6 +180,33 @@ module Qt
 			end
 		end
 
+		def self.ancestors
+			klass = self
+			classid = nil
+			loop do
+				classid = Qt::Internal::find_pclassid(klass.name)
+				break if classid.index
+      
+				klass = klass.superclass
+				if klass.nil?
+					return super
+				end
+			end
+
+			klasses = super
+			klasses.delete(Qt::Base)
+			klasses.delete(self)
+			ids = []
+			Qt::Internal::getAllParents(classid, ids)
+			return [self] + ids.map {|id| Qt::Internal.find_class(Qt::Internal.classid2name(id))} + klasses
+		end
+
+		# Change the behaviors of is_a? and kind_of? (alias of is_a?) to use above self.ancestors method
+		# Note: this definition also affects Object#===
+		def is_a?(mod)
+			super || self.class.ancestors.include?(mod)
+		end
+		alias :kind_of? :is_a?
 
 		def methods(regular=true)
 			if !regular
@@ -194,6 +243,177 @@ module Qt
 			return meths.uniq
 		end
 	end # Qt::Base
+	
+	# Provides a mutable numeric class for passing to methods with
+	# C++ 'int*' or 'int&' arg types
+	class Integer
+		attr_accessor :value
+		def initialize(n=0) @value = n end
+		
+		def +(n) 
+			return Integer.new(@value + n.to_i) 
+		end
+		def -(n) 
+			return Integer.new(@value - n.to_i)
+		end
+		def *(n) 
+			return Integer.new(@value * n.to_i)
+		end
+		def /(n) 
+			return Integer.new(@value / n.to_i)
+		end
+		def %(n) 
+			return Integer.new(@value % n.to_i)
+		end
+		def **(n) 
+			return Integer.new(@value ** n.to_i)
+		end
+		
+		def |(n) 
+			return Integer.new(@value | n.to_i)
+		end
+		def &(n) 
+			return Integer.new(@value & n.to_i)
+		end
+		def ^(n) 
+			return Integer.new(@value ^ n.to_i)
+		end
+		def <<(n) 
+			return Integer.new(@value << n.to_i)
+		end
+		def >>(n) 
+			return Integer.new(@value >> n.to_i)
+		end
+		def >(n) 
+			return @value > n.to_i
+		end
+		def >=(n) 
+			return @value >= n.to_i
+		end
+		def <(n) 
+			return @value < n.to_i
+		end
+		def <=(n) 
+			return @value <= n.to_i
+		end
+		
+		def <=>(n)
+			if @value < n.to_i
+				return -1
+			elsif @value > n.to_i
+				return 1
+			else
+				return 0
+			end
+		end
+		
+		def to_f() return @value.to_f end
+		def to_i() return @value.to_i end
+		def to_s() return @value.to_s end
+		
+		def coerce(n)
+			[n, @value]
+		end
+	end
+	
+	# If a C++ enum was converted to an ordinary ruby Integer, the
+	# name of the type is lost. The enum type name is needed for overloaded
+	# method resolution when two methods differ only by an enum type.
+	class Enum
+		attr_accessor :type, :value
+		def initialize(n, enum_type)
+			@value = n 
+			@type = enum_type
+		end
+		
+		def +(n) 
+			return @value + n.to_i
+		end
+		def -(n) 
+			return @value - n.to_i
+		end
+		def *(n) 
+			return @value * n.to_i
+		end
+		def /(n) 
+			return @value / n.to_i
+		end
+		def %(n) 
+			return @value % n.to_i
+		end
+		def **(n) 
+			return @value ** n.to_i
+		end
+		
+		def |(n) 
+			return Enum.new(@value | n.to_i, @type)
+		end
+		def &(n) 
+			return Enum.new(@value & n.to_i, @type)
+		end
+		def ^(n) 
+			return Enum.new(@value ^ n.to_i, @type)
+		end
+		def ~() 
+			return ~ @value
+		end
+		def <(n) 
+			return @value < n.to_i
+		end
+		def <=(n) 
+			return @value <= n.to_i
+		end
+		def >(n) 
+			return @value > n.to_i
+		end
+		def >=(n) 
+			return @value >= n.to_i
+		end
+		def <<(n) 
+			return Enum.new(@value << n.to_i, @type)
+		end
+		def >>(n) 
+			return Enum.new(@value >> n.to_i, @type)
+		end
+		
+		def ==(n) return @value == n.to_i end
+		def to_i() return @value end
+
+		def to_f() return @value.to_f end
+		def to_s() return @value.to_s end
+		
+		def coerce(n)
+			[n, @value]
+		end
+		
+		def inspect
+			to_s
+		end
+
+		def pretty_print(pp)
+			pp.text "#<%s:0x%8.8x @type=%s, @value=%d>" % [self.class.name, object_id, type, value]
+		end
+	end
+	
+	# Provides a mutable boolean class for passing to methods with
+	# C++ 'bool*' or 'bool&' arg types
+	class Boolean
+		attr_accessor :value
+		def initialize(b=false) @value = b end
+		def nil? 
+			return !@value 
+		end
+	end
+
+	class AbstractSlider < Qt::Base
+		def range=(arg)
+			if arg.kind_of? Range
+				return super(arg.begin, arg.exclude_end?  ? arg.end - 1 : arg.end)
+			else
+				return super(arg)
+			end
+		end
+	end
 
 	class AbstractSocket < Qt::Base
 		def abort(*args)
@@ -234,6 +454,14 @@ module Qt
 	end
 
 	class Application < Qt::Base
+		def initialize(*args)
+			if args.length == 1 && args[0].kind_of?(Array)
+				super(args.length + 1, [$0] + args[0])
+			else
+				super(*args)
+			end
+            $qApp = self
+		end 
 		# Delete the underlying C++ instance after exec returns
 		# Otherwise, rb_gc_call_finalizer_at_exit() can delete
 		# stuff that Qt::Application still needs for its cleanup.
@@ -261,6 +489,14 @@ module Qt
 	end
 	
 	class ByteArray < Qt::Base
+		def initialize(*args)
+			if args.size == 1 && args[0].kind_of?(String)
+				super(args[0], args[0].size)
+			else
+				super
+			end
+		end
+
 		def to_s
 			return constData()
 		end
@@ -345,12 +581,28 @@ module Qt
 	end
 
 	class CoreApplication < Qt::Base
+		def initialize(*args)
+			if args.length == 1 && args[0].kind_of?(Array)
+				super(args.length + 1, [$0] + args[0])
+			else
+				super(*args)
+			end
+            $qApp = self
+		end 
+
+		# Delete the underlying C++ instance after exec returns
+		# Otherwise, rb_gc_call_finalizer_at_exit() can delete
+		# stuff that Qt::Application still needs for its cleanup.
 		def exec
 			method_missing(:exec)
 			self.dispose
 			Qt::Internal.application_terminated = true
 		end
 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+
 		def exit(*args)
 			method_missing(:exit, *args)
 		end
@@ -375,7 +627,6 @@ module Qt
 	end
 	
 	class Date < Qt::Base
-
 		def initialize(*args)
 			if args.size == 1 && args[0].class.name == "Date"
 				return super(args[0].year, args[0].month, args[0].day)
@@ -393,6 +644,10 @@ module Qt
 			str = to_s
 			pp.text str.sub(/>$/, " %s>" % toString)
 		end
+
+		def to_date
+			::Date.new! to_julian_day
+		end
 	end
 	
 	class DateTime < Qt::Base
@@ -400,11 +655,26 @@ module Qt
 			if args.size == 1 && args[0].class.name == "DateTime"
 				return super(	Qt::Date.new(args[0].year, args[0].month, args[0].day), 
 								Qt::Time.new(args[0].hour, args[0].min, args[0].sec) )
+			elsif args.size == 1 && args[0].class.name == "Time"
+				result = super(	Qt::Date.new(args[0].year, args[0].month, args[0].day), 
+								Qt::Time.new(args[0].hour, args[0].min, args[0].sec, args[0].usec / 1000) )
+				result.timeSpec = (args[0].utc? ? Qt::UTC : Qt::LocalTime)
+				return result
 			else
 				return super(*args)
 			end
 		end
 
+		def to_time
+			if timeSpec == Qt::UTC
+				return ::Time.utc(	date.year, date.month, date.day,
+									time.hour, time.minute, time.second, time.msec * 1000 )
+			else
+				return ::Time.local(	date.year, date.month, date.day,
+										time.hour, time.minute, time.second, time.msec * 1000 )
+			end
+		end
+
 		def inspect
 			str = super
 			str.sub(/>$/, " %s>" % toString)
@@ -416,6 +686,18 @@ module Qt
 		end
 	end
 
+	class DBusArgument < Qt::Base
+		def inspect
+			str = super
+			str.sub(/>$/, " currentSignature='%s', atEnd=%s>" % [currentSignature, atEnd])
+		end
+		
+		def pretty_print(pp)
+			str = to_s
+			pp.text str.sub(/>$/, " currentSignature='%s, atEnd=%s'>" % [currentSignature, atEnd])
+		end
+	end
+
 	class DBusConnection < Qt::Base
 		def send(*args)
 			method_missing(:send, *args)
@@ -459,10 +741,13 @@ module Qt
 	end
 
 	class DBusInterface < Qt::Base 
-
 		def call(method_name, *args)
 			if args.length == 0
 				return super(method_name)
+			elsif method_name.is_a? Qt::Enum
+				opt = args.shift
+				qdbusArgs = args.collect {|arg| qVariantFromValue(arg)}
+				return super(method_name, opt, *qdbusArgs)
 			else
 				# If the method is Qt::DBusInterface.call(), create an Array 
 				# 'dbusArgs' of Qt::Variants from '*args'
@@ -494,7 +779,13 @@ module Qt
 		def value
 			if type() == Qt::DBusMessage::ReplyMessage
 				reply = arguments()
-				return reply.length > 0 ? reply[0].value : nil
+				if reply.length == 0
+					return nil
+				elsif reply.length == 1
+					return reply[0].value
+				else
+					return reply.collect {|v| v.value}
+				end
 			else
 				return nil
 			end
@@ -546,18 +837,52 @@ module Qt
 		end
 	end
 
+	class Dial < Qt::Base
+		def range=(arg)
+			if arg.kind_of? Range
+				return super(arg.begin, arg.exclude_end?  ? arg.end - 1 : arg.end)
+			else
+				return super(arg)
+			end
+		end
+	end
+
 	class Dialog < Qt::Base
 		def exec(*args)
 			method_missing(:exec, *args)
 		end
 	end
 
+	class Dir < Qt::Base
+		Time = Qt::Enum.new(1, "QDir::SortFlag")
+	end
+
 	class DomAttr < Qt::Base
 		def name(*args)
 			method_missing(:name, *args)
 		end
 	end
 
+	class DoubleSpinBox < Qt::Base
+		def range=(arg)
+			if arg.kind_of? Range
+				return super(arg.begin, arg.exclude_end?  ? arg.end - 1 : arg.end)
+			else
+				return super(arg)
+			end
+		end
+	end
+
+	class DoubleValidator < Qt::Base
+		def range=(arg)
+			if arg.kind_of? Range
+				return super(arg.begin, arg.exclude_end?  ? arg.end - 1 : arg.end)
+			else
+				return super(arg)
+			end
+		end
+	end
+
 	class DomDocumentType < Qt::Base
 		def name(*args)
 			method_missing(:name, *args)
@@ -618,6 +943,8 @@ module Qt
 	end
 
 	class FileIconProvider < Qt::Base
+		File = Qt::Enum.new(6, "QFileIconProvider::IconType")
+
 		def type(*args)
 			method_missing(:type, *args)
 		end
@@ -643,6 +970,10 @@ module Qt
 		end
 	end
 
+	class FontDatabase < Qt::Base
+		Symbol = Qt::Enum.new(30, "QFontDatabase::WritingSystem")
+	end
+
 	class Ftp < Qt::Base
 		def abort(*args)
 			method_missing(:abort, *args)
@@ -691,19 +1022,23 @@ module Qt
 		end
 	end
 
-	class GraphicsItemGroup < Qt::Base 
+	class GraphicsItemGroup < Qt::Base
+		Type = 10
+
 		def type(*args)
 			method_missing(:type, *args)
 		end
 	end
 
-	class GraphicsLineItem < Qt::Base 
+	class GraphicsLineItem < Qt::Base
+		Type = 6
 		def type(*args)
 			method_missing(:type, *args)
 		end
 	end
 
 	class GraphicsPathItem < Qt::Base 
+		Type = 2
 		def type(*args)
 			method_missing(:type, *args)
 		end
@@ -715,13 +1050,22 @@ module Qt
 		end
 	end
 
-	class GraphicsPolygonItem < Qt::Base 
+	class GraphicsPolygonItem < Qt::Base
+		Type = 5
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class GraphicsProxyWidget < Qt::Base
+		Type = 12
 		def type(*args)
 			method_missing(:type, *args)
 		end
 	end
 
 	class GraphicsRectItem < Qt::Base 
+		Type = 3
 		def type(*args)
 			method_missing(:type, *args)
 		end
@@ -758,12 +1102,28 @@ module Qt
 	end
 
 	class GraphicsSimpleTextItem < Qt::Base 
+		Type = 9
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class GraphicsSvgItem < Qt::Base 
+		Type = 13
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class GraphicsTextItem < Qt::Base
+		Type = 8
 		def type(*args)
 			method_missing(:type, *args)
 		end
 	end
 
-	class GraphicsTextItem < Qt::Base 
+	class GraphicsWidget < Qt::Base
+		Type = 11
 		def type(*args)
 			method_missing(:type, *args)
 		end
@@ -863,7 +1223,26 @@ module Qt
 		end
 	end
 
+	class IntValidator < Qt::Base
+		def range=(arg)
+			if arg.kind_of? Range
+				return super(arg.begin, arg.exclude_end?  ? arg.end - 1 : arg.end)
+			else
+				return super(arg)
+			end
+		end
+	end
+
 	class ItemSelection < Qt::Base
+		include Enumerable
+
+		def each
+			for i in 0...count
+				yield at(i)
+			end
+			return self
+		end
+
 		def select(*args)
 			method_missing(:select, *args)
 		end
@@ -879,6 +1258,12 @@ module Qt
 		end
 	end
 	
+	class KeyEvent < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
 	class KeySequence < Qt::Base
 		def initialize(*args)
 			if args.length == 1 && args[0].kind_of?(Qt::Enum) && args[0].type == "Qt::Key"
@@ -886,6 +1271,16 @@ module Qt
 			end
 			return super(*args)
 		end
+
+		def inspect
+			str = super
+			str.sub(/>$/, " %s>" % toString)
+		end
+		
+		def pretty_print(pp)
+			str = to_s
+			pp.text str.sub(/>$/, " %s>" % toString)
+		end
 	end
 
 	class LCDNumber < Qt::Base
@@ -902,7 +1297,7 @@ module Qt
 
 	class ListWidgetItem < Qt::Base
 		def clone(*args)
-			method_missing(:clone, *args)
+			Qt::ListWidgetItem.new(self)
 		end
 
 		def type(*args)
@@ -911,12 +1306,12 @@ module Qt
 
 		def inspect
 			str = super
-			str.sub(/>$/, " text=%s>" % text)
+			str.sub(/>$/, " text='%s'>" % text)
 		end
 		
 		def pretty_print(pp)
 			str = to_s
-			pp.text str.sub(/>$/, " text=%s>" % text)
+			pp.text str.sub(/>$/, " text='%s'>" % text)
 		end
 	end
 
@@ -973,7 +1368,8 @@ module Qt
 	class MetaMethod < Qt::Base
 		# Oops, name clash with the Signal module so hard code
 		# this value rather than get it from the Smoke runtime
-		Signal = 1
+		Method = Qt::Enum.new(0, "QMetaMethod::MethodType")
+		Signal = Qt::Enum.new(1, "QMetaMethod::MethodType")
 	end
 
 	class MetaObject < Qt::Base
@@ -1101,6 +1497,8 @@ module Qt
 	end
 
 	class MetaType < Qt::Base
+		Float = Qt::Enum.new(135, "QMetaType::Type")
+
 		def load(*args)
 			method_missing(:load, *args)
 		end
@@ -1176,24 +1574,46 @@ module Qt
 	class Point < Qt::Base
 		def inspect
 			str = super
-			str.sub(/>$/, " x=%d, y=%d>" % [x, y])
+			str.sub(/>$/, " x=%d, y=%d>" % [self.x, self.y])
 		end
 		
 		def pretty_print(pp)
 			str = to_s
-			pp.text str.sub(/>$/, "\n x=%d,\n y=%d>" % [x, y])
+			pp.text str.sub(/>$/, "\n x=%d,\n y=%d>" % [self.x, self.y])
 		end
 	end
 	
 	class PointF < Qt::Base
 		def inspect
 			str = super
-			str.sub(/>$/, " x=%f, y=%f>" % [x, y])
+			str.sub(/>$/, " x=%f, y=%f>" % [self.x, self.y])
 		end
 		
 		def pretty_print(pp)
 			str = to_s
-			pp.text str.sub(/>$/, "\n x=%f,\n y=%f>" % [x, y])
+			pp.text str.sub(/>$/, "\n x=%f,\n y=%f>" % [self.x, self.y])
+		end
+	end
+
+	class Polygon < Qt::Base
+		include Enumerable
+
+		def each
+			for i in 0...count
+				yield point(i)
+			end
+			return self
+		end
+	end
+
+	class PolygonF < Qt::Base
+		include Enumerable
+
+		def each
+			for i in 0...count
+				yield point(i)
+			end
+			return self
 		end
 	end
 
@@ -1203,6 +1623,30 @@ module Qt
 		end
 	end
 
+	class Process < Qt::Base
+		StandardError = Qt::Enum.new(1, "QProcess::ProcessChannel")
+	end
+
+	class ProgressBar < Qt::Base
+		def range=(arg)
+			if arg.kind_of? Range
+				return super(arg.begin, arg.exclude_end?  ? arg.end - 1 : arg.end)
+			else
+				return super(arg)
+			end
+		end
+	end
+
+	class ProgressDialog < Qt::Base
+		def range=(arg)
+			if arg.kind_of? Range
+				return super(arg.begin, arg.exclude_end?  ? arg.end - 1 : arg.end)
+			else
+				return super(arg)
+			end
+		end
+	end
+
 	class Printer < Qt::Base
 		def abort(*args)
 			method_missing(:abort, *args)
@@ -1282,24 +1726,24 @@ module Qt
 	class Rect < Qt::Base
 		def inspect
 			str = super
-			str.sub(/>$/, " left=%d, right=%d, top=%d, bottom=%d>" % [left, right, top, bottom])
+			str.sub(/>$/, " x=%d, y=%d, width=%d, height=%d>" % [self.x, self.y, width, height])
 		end
 		
 		def pretty_print(pp)
 			str = to_s
-			pp.text str.sub(/>$/, "\n left=%d,\n right=%d,\n top=%d,\n bottom=%d>" % [left, right, top, bottom])
+			pp.text str.sub(/>$/, "\n x=%d,\n y=%d,\n width=%d,\n height=%d>" % [self.x, self.y, width, height])
 		end
 	end
 	
 	class RectF < Qt::Base
 		def inspect
 			str = super
-			str.sub(/>$/, " left=%f, right=%f, top=%f, bottom=%f>" % [left, right, top, bottom])
+			str.sub(/>$/, " x=%f, y=%f, width=%f, height=%f>" % [self.x, self.y, width, height])
 		end
 		
 		def pretty_print(pp)
 			str = to_s
-			pp.text str.sub(/>$/, "\n left=%f,\n right=%f,\n top=%f,\n bottom=%f>" % [left, right, top, bottom])
+			pp.text str.sub(/>$/, "\n x=%f,\n y=%f,\n width=%f,\n height=%f>" % [self.x, self.y, width, height])
 		end
 	end
 
@@ -1309,6 +1753,16 @@ module Qt
 		end
 	end
 
+	class ScrollBar < Qt::Base
+		def range=(arg)
+			if arg.kind_of? Range
+				return super(arg.begin, arg.exclude_end?  ? arg.end - 1 : arg.end)
+			else
+				return super(arg)
+			end
+		end
+	end
+
 	class Shortcut < Qt::Base
 		def id(*args)
 			method_missing(:id, *args)
@@ -1354,21 +1808,43 @@ module Qt
 	class SizePolicy < Qt::Base
 		def inspect
 			str = super
-			str.sub(/>$/, " horData=%d, verData=%d>" % [horData, verData])
+			str.sub(/>$/, " horizontalPolicy=%d, verticalPolicy=%d>" % [horizontalPolicy, verticalPolicy])
 		end
 		
 		def pretty_print(pp)
 			str = to_s
-			pp.text str.sub(/>$/, "\n horData=%d,\n verData=%d>" % [horData, verData])
+			pp.text str.sub(/>$/, "\n horizontalPolicy=%d,\n verticalPolicy=%d>" % [horizontalPolicy, verticalPolicy])
+		end
+	end
+
+	class Slider < Qt::Base
+		def range=(arg)
+			if arg.kind_of? Range
+				return super(arg.begin, arg.exclude_end?  ? arg.end - 1 : arg.end)
+			else
+				return super(arg)
+			end
 		end
 	end
 
 	class SocketNotifier < Qt::Base
+		Exception = Qt::Enum.new(2, "QSocketNotifier::Type")
+
 		def type(*args)
 			method_missing(:type, *args)
 		end
 	end
 
+	class SpinBox < Qt::Base
+		def range=(arg)
+			if arg.kind_of? Range
+				return super(arg.begin, arg.exclude_end?  ? arg.end - 1 : arg.end)
+			else
+				return super(arg)
+			end
+		end
+	end
+
 	class SqlDatabase < Qt::Base
 		def exec(*args)
 			method_missing(:exec, *args)
@@ -1420,9 +1896,23 @@ module Qt
 	end
 
 	class StandardItem < Qt::Base 
+		def inspect
+			str = super
+			str.sub(/>$/, " text='%s'>" % [text])
+		end
+		
+		def pretty_print(pp)
+			str = to_s
+			pp.text str.sub(/>$/, "\n text='%s'>" % [text])
+		end
+
 		def type(*args)
 			method_missing(:type, *args)
 		end
+
+		def clone
+			Qt::StandardItem.new(self)
+		end
 	end
 
 	class StandardItemModel < Qt::Base 
@@ -1457,7 +1947,7 @@ module Qt
 
 	class TableWidgetItem < Qt::Base
 		def clone(*args)
-			method_missing(:clone, *args)
+			Qt::TableWidgetItem.new(self)
 		end
 
 		def type(*args)
@@ -1466,12 +1956,12 @@ module Qt
 
 		def inspect
 			str = super
-			str.sub(/>$/, " text=%s>" % text)
+			str.sub(/>$/, " text='%s'>" % text)
 		end
 		
 		def pretty_print(pp)
 			str = to_s
-			pp.text str.sub(/>$/, " text=%s>" % text)
+			pp.text str.sub(/>$/, " text='%s'>" % text)
 		end
 	end
 
@@ -1571,6 +2061,16 @@ module Qt
 		end
 	end
 	
+	class TimeLine < Qt::Base
+		def frameRange=(arg)
+			if arg.kind_of? Range
+				return super(arg.begin, arg.exclude_end?  ? arg.end - 1 : arg.end)
+			else
+				return super(arg)
+			end
+		end
+	end
+	
 	class ToolButton < Qt::Base 
 		def setShortcut(arg)
 			if arg.kind_of?(String)
@@ -1624,7 +2124,7 @@ module Qt
 			str.sub!(/>$/, "")
 			str << " parent=%s," % parent unless parent.nil?
 			for i in 0..(columnCount - 1)
-				str << " text%d=%s," % [i, self.text(i)]
+				str << " text%d='%s'," % [i, self.text(i)]
 			end
 			str.sub!(/,?$/, ">")
 		end
@@ -1634,14 +2134,14 @@ module Qt
 			str.sub!(/>$/, "")
 			str << " parent=%s," % parent unless parent.nil?
 			for i in 0..(columnCount - 1)
-				str << " text%d=%s," % [i, self.text(i)]
+				str << " text%d='%s'," % [i, self.text(i)]
 			end
 			str.sub!(/,?$/, ">")
 			pp.text str
 		end
 
 		def clone(*args)
-			method_missing(:clone, *args)
+			Qt::TreeWidgetItem.new(self)
 		end
 
 		def type(*args)
@@ -1663,17 +2163,33 @@ module Qt
 		end
 	end
 
+	class Url < Qt::Base
+		def inspect
+			str = super
+			str.sub(/>$/, " url=%s>" % toString)
+		end
+		
+		def pretty_print(pp)
+			str = to_s
+			pp.text str.sub(/>$/, " url=%s>" % toString)
+		end
+	end
+
 	class UrlInfo < Qt::Base
 		def name(*args)
 			method_missing(:name, *args)
 		end
 	end
 	
+	class Uuid < Qt::Base
+		Time = Qt::Enum.new(1, "QUuid::Version")
+	end
+
 	class Variant < Qt::Base
-		String = 10
-		Date = 14
-		Time = 15
-		DateTime = 16
+		String = Qt::Enum.new(10, "QVariant::Type")
+		Date = Qt::Enum.new(14, "QVariant::Type")
+		Time = Qt::Enum.new(15, "QVariant::Type")
+		DateTime = Qt::Enum.new(16, "QVariant::Type")
 
 		def initialize(*args)
 			if args.size == 1 && args[0].nil?
@@ -1685,6 +2201,8 @@ module Qt
 												Qt::Time.new(args[0].hour, args[0].min, args[0].sec) ) )
 			elsif args.size == 1 && args[0].class.name == "Time"
 				return super(Qt::Time.new(args[0]))
+			elsif args.size == 1 && args[0].class.name == "BigDecimal"
+				return super(args[0].to_f) # we have to make do with a float
 			else
 				return super(*args)
 			end
@@ -1708,6 +2226,8 @@ module Qt
 
 		def value
 			case type()
+			when Qt::Variant::Invalid
+				return nil
 			when Qt::Variant::Bitmap
 			when Qt::Variant::Bool
 				return toBool
@@ -1793,12 +2313,7 @@ module Qt
 				return toUrl
 			end
 
-            case typeName()
-            when "QDBusArgument"
-				return qVariantValue(Qt::DBusArgument, self)
-            when "QDBusVariant"
-				return qVariantValue(Qt::Variant, self)
-            end
+			return qVariantValue(nil, self)
 		end
 
 		def inspect
@@ -1864,168 +2379,6 @@ module Qt
 			method_missing(:type, *args)
 		end
 	end
-	
-	# Provides a mutable numeric class for passing to methods with
-	# C++ 'int*' or 'int&' arg types
-	class Integer
-		attr_accessor :value
-		def initialize(n=0) @value = n end
-		
-		def +(n) 
-			return Integer.new(@value + n.to_i) 
-		end
-		def -(n) 
-			return Integer.new(@value - n.to_i)
-		end
-		def *(n) 
-			return Integer.new(@value * n.to_i)
-		end
-		def /(n) 
-			return Integer.new(@value / n.to_i)
-		end
-		def %(n) 
-			return Integer.new(@value % n.to_i)
-		end
-		def **(n) 
-			return Integer.new(@value ** n.to_i)
-		end
-		
-		def |(n) 
-			return Integer.new(@value | n.to_i)
-		end
-		def &(n) 
-			return Integer.new(@value & n.to_i)
-		end
-		def ^(n) 
-			return Integer.new(@value ^ n.to_i)
-		end
-		def <<(n) 
-			return Integer.new(@value << n.to_i)
-		end
-		def >>(n) 
-			return Integer.new(@value >> n.to_i)
-		end
-		def >(n) 
-			return @value > n.to_i
-		end
-		def >=(n) 
-			return @value >= n.to_i
-		end
-		def <(n) 
-			return @value < n.to_i
-		end
-		def <=(n) 
-			return @value <= n.to_i
-		end
-		
-		def <=>(n)
-			if @value < n.to_i
-				return -1
-			elsif @value > n.to_i
-				return 1
-			else
-				return 0
-			end
-		end
-		
-		def to_f() return @value.to_f end
-		def to_i() return @value.to_i end
-		def to_s() return @value.to_s end
-		
-		def coerce(n)
-			[n, @value]
-		end
-	end
-	
-	# If a C++ enum was converted to an ordinary ruby Integer, the
-	# name of the type is lost. The enum type name is needed for overloaded
-	# method resolution when two methods differ only by an enum type.
-	class Enum
-		attr_accessor :type, :value
-		def initialize(n, type)
-			super() 
-			@value = n 
-			@type = type
-		end
-		
-		def +(n) 
-			return @value + n.to_i
-		end
-		def -(n) 
-			return @value - n.to_i
-		end
-		def *(n) 
-			return @value * n.to_i
-		end
-		def /(n) 
-			return @value / n.to_i
-		end
-		def %(n) 
-			return @value % n.to_i
-		end
-		def **(n) 
-			return @value ** n.to_i
-		end
-		
-		def |(n) 
-			return Enum.new(@value | n.to_i, @type)
-		end
-		def &(n) 
-			return Enum.new(@value & n.to_i, @type)
-		end
-		def ^(n) 
-			return Enum.new(@value ^ n.to_i, @type)
-		end
-		def ~() 
-			return ~ @value
-		end
-		def <(n) 
-			return @value < n.to_i
-		end
-		def <=(n) 
-			return @value <= n.to_i
-		end
-		def >(n) 
-			return @value > n.to_i
-		end
-		def >=(n) 
-			return @value >= n.to_i
-		end
-		def <<(n) 
-			return Enum.new(@value << n.to_i, @type)
-		end
-		def >>(n) 
-			return Enum.new(@value >> n.to_i, @type)
-		end
-		
-		def ==(n) return @value == n.to_i end
-		def to_i() return @value end
-
-		def to_f() return @value.to_f end
-		def to_s() return @value.to_s end
-		
-		def coerce(n)
-			[n, @value]
-		end
-		
-		def inspect
-			to_s
-		end
-
-		def pretty_print(pp)
-			pp.text "#<%s:0x%8.8x @type=%s, @value=%d>" % [self.class.name, object_id, type, value]
-		end
-	end
-	
-	# Provides a mutable boolean class for passing to methods with
-	# C++ 'bool*' or 'bool&' arg types
-	class Boolean
-		attr_accessor :value
-		def initialize(b=false) @value = b end
-		def nil? 
-			return !@value 
-		end
-	end
 
 	class SignalBlockInvocation < Qt::Object
 		def initialize(parent, block, signature)
@@ -2033,7 +2386,11 @@ module Qt
 			if metaObject.indexOfSlot(signature) == -1
 				self.class.slots signature
 			end
+			# This makes a difference between being and not being able
+			# to run with GC.stress= true. Reason unclear.
+			gc_disabled= GC.disable
 			@block = block
+			GC.enable unless gc_disabled
 		end
 
 		def invoke(*args)
@@ -2055,40 +2412,90 @@ module Qt
 			@target.instance_exec(*args, &@block)
 		end
 	end
-	
+
+	class MethodInvocation < Qt::Object
+		def initialize(target, method, signature)
+			super(target)
+			if metaObject.indexOfSlot(signature) == -1
+				self.class.slots signature
+			end
+			@target = target
+			method = method.intern unless method.is_a?Symbol
+			@method = method
+		end
+
+		def invoke(*args)
+			@target.send @method, *args
+		end
+	end
+
 	module Internal
 		@@classes   = {}
 		@@cpp_names = {}
 		@@idclass   = []
 
+		@@normalize_procs = []
+
+		class ModuleIndex
+			attr_accessor :index
+
+			def smoke
+				if ! @smoke
+				    return 0
+				end
+				return @smoke
+			end
+			
+			def initialize(smoke, index)
+				@smoke = smoke
+				@index = index
+			end
+		end
+
+		def self.classes
+			return @@classes
+		end
+
+		def self.cpp_names
+			return @@cpp_names
+		end
+
+		def self.idclass
+			return @@idclass
+		end
+
+		def self.add_normalize_proc(func)
+			@@normalize_procs << func
+		end
+
 		def Internal.normalize_classname(classname)
-			if classname =~ /^Qext/
-				now = classname.sub(/^Qext(?=[A-Z])/,'Qext::')
-			elsif classname =~ /^Qwt/
-				now = classname.sub(/^Qwt(?=[A-Z])/,'Qwt::')
-			elsif classname =~ /^Q3/
-				now = classname.sub(/^Q3(?=[A-Z])/,'Qt3::')
+			@@normalize_procs.each do |func|
+				ret = func.call(classname)
+				if !ret.nil?
+					return ret
+				end
+			end
+			if classname =~ /^Q3/
+				ruby_classname = classname.sub(/^Q3(?=[A-Z])/,'Qt3::')
 			elsif classname =~ /^Q/
-				now = classname.sub(/^Q(?=[A-Z])/,'Qt::')
-			elsif classname =~ /^(KConfigSkeleton|KWin)::/
-				now = classname.sub(/^K?(?=[A-Z])/,'KDE::')
-			elsif classname !~ /::/
-				now = classname.sub(/^K?(?=[A-Z])/,'KDE::')
+				ruby_classname = classname.sub(/^Q(?=[A-Z])/,'Qt::')
 			else
-				now = classname
+				ruby_classname = classname
 			end
-#			puts "normalize_classname = was::#{classname}, now::#{now}"
-			now
+			ruby_classname
 		end
 
 		def Internal.init_class(c)
+			if c == "WebCore" || c == "std" || c == "QGlobalSpace"
+				return
+			end
 			classname = Qt::Internal::normalize_classname(c)
-			classId = Qt::Internal.idClass(c)
+			classId = Qt::Internal.findClass(c)
 			insert_pclassid(classname, classId)
-			@@idclass[classId] = classname
+			@@idclass[classId.index] = classname
 			@@cpp_names[classname] = c
-			klass = isQObject(classId) ? create_qobject_class(classname) \
-                                                   : create_qt_class(classname)
+			klass = isQObject(c) ? create_qobject_class(classname, Qt) \
+                                                   : create_qt_class(classname, Qt)
 			@@classes[classname] = klass unless klass.nil?
 		end
 
@@ -2098,47 +2505,52 @@ module Qt
 
 		def Internal.checkarg(argtype, typename)
 			puts "      #{typename} (#{argtype})" if debug_level >= DebugLevel::High
+			const_point = typename =~ /^const\s+/ ? -1 : 0
 			if argtype == 'i'
-				if typename =~ /^int&?$|^signed int&?$|^signed$|^qint32&?$|^quint32&?$/
-					return 2
-				elsif typename =~ /^(?:short|ushort|unsigned short int|uchar|uint|long|ulong|unsigned long int|unsigned|float|double|WId|Q_PID|^quint16&?$|^qint16&?$)$/
-					return 1
+				if typename =~ /^int&?$|^signed int&?$|^signed$|^qint32&?$/
+					return 6 + const_point
+				elsif typename =~ /^quint32&?$/
+					return 4 + const_point
+				elsif typename =~ /^(?:short|ushort|unsigned short int|unsigned short|uchar||unsigned char|uint|long|ulong|unsigned long int|unsigned|float|double|WId|Q_PID|^quint16&?$|^qint16&?$)$/
+					return 4 + const_point
 				elsif typename =~ /^(quint|qint|qulong|qlong|qreal)/
-					return 1
+					return 4 + const_point
 				else 
 					t = typename.sub(/^const\s+/, '')
 					t.sub!(/[&*]$/, '')
 					if isEnum(t)
-						return 0
+						return 2
 					end
 				end
 			elsif argtype == 'n'
 				if typename =~ /^double$|^qreal$/
-					return 2
+					return 6 + const_point
 				elsif typename =~ /^float$/
-					return 1
+					return 4 + const_point
 				elsif typename =~ /^int&?$/
-					return 0
+					return 2 + const_point
 				elsif typename =~ /^(?:short|ushort|uint|long|ulong|signed|unsigned|float|double)$/
-					return 0
+					return 2 + const_point
 				else 
 					t = typename.sub(/^const\s+/, '')
 					t.sub!(/[&*]$/, '')
 					if isEnum(t)
-						return 0
+						return 2 + const_point
 					end
 				end
 			elsif argtype == 'B'
 				if typename =~ /^(?:bool)[*&]?$/
-					return 0
+					return 2 + const_point
 				end
 			elsif argtype == 's'
 				if typename =~ /^(const )?((QChar)[*&]?)$/
-					return 1
-				elsif typename =~ /^(?:u?char\*|const u?char\*|(?:const )?(Q(C?)String)[*&]?)$/
-					qstring = !$1.nil?
-					c = ("C" == $2)
-					return c ? 2 : (qstring ? 3 : 0)
+					return 6 + const_point
+				elsif typename =~ /^(?:(u(nsigned )?)?char\*)$/
+					return 4 + const_point
+				elsif typename =~ /^(?:const (u(nsigned )?)?char\*)$/
+					return 2 + const_point
+				elsif typename =~ /^(?:(?:const )?(QString)[*&]?)$/
+					return 8 + const_point
 				end
 			elsif argtype == 'a'
 				# FIXME: shouldn't be hardcoded. Installed handlers should tell what ruby type they expect.
@@ -2152,41 +2564,41 @@ module Qt
 						    char\*\*
 						)
 					        )$/x
-					return 0
+					return 2 + const_point
 				end
 			elsif argtype == 'u'
 				# Give nil matched against string types a higher score than anything else
 				if typename =~ /^(?:u?char\*|const u?char\*|(?:const )?((Q(C?)String))[*&]?)$/
-					return 1
+					return 4 + const_point
 				# Numerics will give a runtime conversion error, so they fail the match
 				elsif typename =~ /^(?:short|ushort|uint|long|ulong|signed|unsigned|int)$/
 					return -99
 				else
-					return 0
+					return 2 + const_point
 				end
 			elsif argtype == 'U'
 				if typename =~ /QStringList/
-					return 1
+					return 4 + const_point
 				else
-					return 0
+					return 2 + const_point
 				end
 			else
 				t = typename.sub(/^const\s+/, '')
+				t.sub!(/(::)?Ptr$/, '')
 				t.sub!(/[&*]$/, '')
 				if argtype == t
-					return 1
+					return 4 + const_point
 				elsif classIsa(argtype, t)
-					return 0
+					return 2 + const_point
 				elsif isEnum(argtype) and 
 						(t =~ /int|qint32|uint|quint32|long|ulong/ or isEnum(t))
-					return 0
+					return 2 + const_point
 				end
 			end
 			return -99
 		end
 
 		def Internal.find_class(classname)
-			# puts @@classes.keys.sort.join "\n"
 			@@classes[classname]
 		end
 		
@@ -2195,7 +2607,7 @@ module Qt
 		# wrapped in a new ruby variable of type T_DATA
 		def Internal.try_initialize(instance, *args)
 			initializer = instance.method(:initialize)
-			catch "newqt" do
+			catch :newqt do
 				initializer.call(*args)
 			end
 		end
@@ -2205,7 +2617,7 @@ module Qt
 		# if no args were passed to the block. Or otherwise,
 		# run the block in the context of the arg.
 		def Internal.run_initializer_block(instance, block)
-			if block.arity == -1
+			if block.arity == -1 || block.arity == 0
 				instance.instance_eval(&block)
 			elsif block.arity == 1
 				block.call(instance)
@@ -2230,7 +2642,7 @@ module Qt
 			
 			if method == "new"
 				method = classname.dup 
-				method.gsub!(/^(QTextLayout|KParts|KIO|KNS|DOM|Kontact|Kate|KTextEditor|KConfigSkeleton::ItemEnum|KConfigSkeleton|KWin)::/,"")
+				method.gsub!(/^.*::/,"")
 			end
 			method = "operator" + method.sub("@","") if method !~ /[a-zA-Z]+/
 			# Change foobar= to setFoobar()					
@@ -2261,7 +2673,7 @@ module Qt
 			methodIds = []
 			methods.collect { |meth| methodIds.concat( findMethod(classname, meth) ) }
 			
-			if method =~ /_/ && methodIds.length == 0
+			if method =~ /._./ && methodIds.length == 0
 				# If the method name contains underscores, convert to camel case
 				# form and try again
 				method.gsub!(/(.)_(.)/) {$1 + $2.upcase}
@@ -2276,7 +2688,7 @@ module Qt
 				prototypes = dumpCandidates(methodIds).split("\n")
 				line_len = (prototypes.collect { |p| p.length }).max
 				prototypes.zip(methodIds) { 
-					|prototype,id| puts "#{prototype.ljust line_len}  (#{id})" 
+					|prototype,id| puts "#{prototype.ljust line_len}  (smoke: #{id.smoke} index: #{id.index})" 
 				}
 			end
 			
@@ -2285,11 +2697,11 @@ module Qt
 				best_match = -1
 				methodIds.each do
 					|id|
-					puts "matching => #{id}" if debug_level >= DebugLevel::High
+					puts "matching => smoke: #{id.smoke} index: #{id.index}" if debug_level >= DebugLevel::High
 					current_match = 0
 					(0...args.length).each do
 						|i|
-						current_match += checkarg( getVALUEtype(args[i]), getTypeNameOfArg(id, i) )
+						current_match += checkarg(get_value_type(args[i]), get_arg_type_name(id, i))
 					end
 					
 					# Note that if current_match > best_match, then chosen must be nil
@@ -2300,12 +2712,17 @@ module Qt
 					# If ambiguous matches occur the problem must be fixed be adjusting the relative
 					# ranking of the arg types involved in checkarg().
 					elsif current_match == best_match
-						chosen = nil
+						if !isConstMethod(id) and isConstMethod(chosen)
+							chosen = id
+						elsif isConstMethod(id) == isConstMethod(chosen)
+							puts "multiple methods matching, this is an error" if debug_level >= DebugLevel::Minimal
+							chosen = nil
+						end
 					end
-					puts "match => #{id} score: #{current_match}" if debug_level >= DebugLevel::High
+					puts "match => #{id.index} score: #{current_match}" if debug_level >= DebugLevel::High
 				end
 					
-				puts "Resolved to id: #{chosen}" if !chosen.nil? && debug_level >= DebugLevel::High
+				puts "Resolved to id: #{chosen.index}" if !chosen.nil? && debug_level >= DebugLevel::High
 			end
 
 			if debug_level >= DebugLevel::Minimal && chosen.nil? && method !~ /^operator/
@@ -2321,9 +2738,9 @@ module Qt
 				end
 				method_ids = hash.values_at(*constructor_names).flatten
 				puts dumpCandidates(method_ids)
+			else
+				puts "setCurrentMethod(smokeList index: #{chosen.smoke}, meth index: #{chosen.index})" if debug_level >= DebugLevel::High
 			end
-
-			puts "setCurrentMethod(#{chosen})" if debug_level >= DebugLevel::High
 			setCurrentMethod(chosen) if chosen
 			return nil
 		end
@@ -2333,7 +2750,7 @@ module Qt
 				if c == "Qt"
 					# Don't change Qt to Qt::t, just leave as is
 					@@cpp_names["Qt"] = c
-				elsif c != "QInternal"
+				elsif c != "QInternal" && !c.empty?
 					Qt::Internal::init_class(c)
 				end
 			end
@@ -2351,8 +2768,8 @@ module Qt
 			return num.value = val
 		end
 		
-		def Internal.create_qenum(num, type)
-			return Qt::Enum.new(num, type)
+		def Internal.create_qenum(num, enum_type)
+			return Qt::Enum.new(num, enum_type)
 		end
 		
 		def Internal.get_qenum_type(e)
@@ -2369,50 +2786,12 @@ module Qt
 
 		def Internal.getAllParents(class_id, res)
 			getIsa(class_id).each do |s|
-				c = idClass(s)
+				c = findClass(s)
 				res << c
 				getAllParents(c, res)
 			end
 		end
 	
-		def Internal.signalInfo(qobject, signal_name)
-			signals = Meta[qobject.class.name].get_signals
-			signals.each_with_index do |signal, i|
-				if signal.name == signal_name
-					return [signal.reply_type, signal.full_name, i]
-				end
-			end
-		end
-	
-		def Internal.getMocArguments(reply_type, member)
-			argStr = member.sub(/.*\(/, '').sub(/\)$/, '')
-			args = argStr.scan(/([^,]*<[^>]+>)|([^,]+)/)
-			args.unshift reply_type
-			mocargs = allocateMocArguments(args.length)
-			args.each_with_index do |arg, i|
-				arg = arg.to_s
-				a = arg.sub(/^const\s+/, '')
-				a = (a =~ /^(bool|int|double|char\*|QString)&?$/) ? $1 : 'ptr'
-				valid = setMocType(mocargs, i, arg, a)
-			end
-			result = []
-			result << args.length << mocargs
-			result
-		end
-
-		#
-		# From the enum MethodFlags in qt-copy/src/tools/moc/generator.cpp
-		#
-		AccessPrivate = 0x00
-		AccessProtected = 0x01
-		AccessPublic = 0x02
-		MethodMethod = 0x00
-		MethodSignal = 0x04
-		MethodSlot = 0x08
-		MethodCompatibility = 0x10
-		MethodCloned = 0x20
-		MethodScriptable = 0x40
-	
 		# Keeps a hash of strings against their corresponding offsets
 		# within the qt_meta_stringdata sequence of null terminated
 		# strings. Returns a proc to get an offset given a string.
@@ -2465,7 +2844,7 @@ module Qt
 				if dbus
 					data.push MethodScriptable | MethodSignal | AccessPublic
 				else
-					data.push MethodSignal | AccessProtected	# flags, always protected for now
+					data.push entry.access	# flags, always protected for now
 				end
 			end
 
@@ -2477,7 +2856,7 @@ module Qt
 				if dbus
 					data.push MethodScriptable | MethodSlot | AccessPublic	# flags, always public for now
 				else
-					data.push MethodSlot | AccessPublic		# flags, always public for now
+					data.push entry.access		# flags, always public for now
 				end
 			end
 
@@ -2514,6 +2893,11 @@ module Qt
 			meta.metaobject
 		end
 
+		# Handles calls of the form:
+		#	connect(myobj, SIGNAL('mysig(int)'), mytarget) {|arg(s)| ...}
+		#	connect(myobj, SIGNAL('mysig(int)')) {|arg(s)| ...}
+		#	connect(myobj, SIGNAL(:mysig), mytarget) { ...}
+		#	connect(myobj, SIGNAL(:mysig)) { ...}
 		def Internal.connect(src, signal, target, block)
 			args = (signal =~ /\((.*)\)/) ? $1 : ""
 			signature = Qt::MetaObject.normalizedSignature("invoke(%s)" % args).to_s
@@ -2523,6 +2907,9 @@ module Qt
 										SLOT(signature) )
 		end
 
+		# Handles calls of the form:
+		#	connect(SIGNAL(:mysig)) { ...}
+		#	connect(SIGNAL('mysig(int)')) {|arg(s)| ...}
 		def Internal.signal_connect(src, signal, block)
 			args = (signal =~ /\((.*)\)/) ? $1 : ""
 			signature = Qt::MetaObject.normalizedSignature("invoke(%s)" % args).to_s
@@ -2531,6 +2918,27 @@ module Qt
 										Qt::SignalBlockInvocation.new(src, block, signature),
 										SLOT(signature) )
 		end
+
+		# Handles calls of the form:
+		#	connect(:mysig, mytarget, :mymethod))
+		#	connect(SIGNAL('mysignal(int)'), mytarget, :mymethod))
+		def Internal.method_connect(src, signal, target, method)
+			signal = SIGNAL(signal) if signal.is_a?Symbol
+			args = (signal =~ /\((.*)\)/) ? $1 : ""
+			signature = Qt::MetaObject.normalizedSignature("invoke(%s)" % args).to_s
+			return Qt::Object.connect(  src,
+										signal,
+										Qt::MethodInvocation.new(target, method, signature),
+										SLOT(signature) )
+		end
+
+		# Handles calls of the form:
+		#	Qt::Timer.singleShot(500, myobj) { ...}
+		def Internal.single_shot_timer_connect(interval, target, block)
+			return Qt::Timer.singleShot(	interval,
+											Qt::BlockInvocation.new(target, block, "invoke()"),
+											SLOT("invoke()") )
+		end
 	end # Qt::Internal
 
 	Meta = {}
@@ -2542,7 +2950,7 @@ module Qt
 	#  :full_name is 'foobar(QString,bool)'
 	#  :arg_types is 'QString,bool'
 	#  :reply_type is 'int'
-	QObjectMember = Struct.new :name, :full_name, :arg_types, :reply_type
+	QObjectMember = Struct.new :name, :full_name, :arg_types, :reply_type, :access
 
 	class MetaInfo
 		attr_accessor :classinfos, :dbus, :signals, :slots, :metaobject, :mocargs, :changed
@@ -2559,7 +2967,7 @@ module Qt
 			Internal.addMetaObjectMethods(klass)
 		end
 		
-		def add_signals(signal_list)
+		def add_signals(signal_list, access)
 			signal_names = []
 			signal_list.each do |signal|
 				if signal.kind_of? Symbol
@@ -2567,7 +2975,11 @@ module Qt
 				end
 				signal = Qt::MetaObject.normalizedSignature(signal).to_s
 				if signal =~ /^(([\w,<>:]*)\s+)?([^\s]*)\((.*)\)/
-					@signals.push QObjectMember.new($3, $3 + "(" + $4 + ")", $4, ($2 == 'void' || $2.nil?) ? "" : $2)
+					@signals.push QObjectMember.new(	$3, 
+					                                    $3 + "(" + $4 + ")", 
+					                                    $4, 
+					                                    ($2 == 'void' || $2.nil?) ? "" : $2,
+					                                    access )
 					signal_names << $3
 				else
 					qWarning( "#{@klass.name}: Invalid signal format: '#{signal}'" )
@@ -2590,14 +3002,18 @@ module Qt
 			return all_signals
 		end
 		
-		def add_slots(slot_list)
+		def add_slots(slot_list, access)
 			slot_list.each do |slot|
 				if slot.kind_of? Symbol
 					slot = slot.to_s + "()"
 				end
 				slot = Qt::MetaObject.normalizedSignature(slot).to_s
 				if slot =~ /^(([\w,<>:]*)\s+)?([^\s]*)\((.*)\)/
-					@slots.push QObjectMember.new($3, $3 + "(" + $4 + ")", $4, ($2 == 'void' || $2.nil?) ? "" : $2)
+					@slots.push QObjectMember.new(	$3, 
+					                                $3 + "(" + $4 + ")", 
+					                                $4, 
+					                                ($2 == 'void' || $2.nil?) ? "" : $2,
+					                                access )
 				else
 					qWarning( "#{@klass.name}: Invalid slot format: '#{slot}'" )
 				end
@@ -2660,7 +3076,7 @@ class Object
 	# matter for the intended use in invoking blocks as Qt slots.
 	def instance_exec(*arguments, &block)
 		block.bind(self)[*arguments]
-	end
+	end unless defined? instance_exec
 end
 
 class Proc 
@@ -2709,10 +3125,10 @@ class Module
 		end
 
 		klass = self
-		classid = 0
+		classid = Qt::Internal::ModuleIndex.new(0, 0)
 		loop do
 			classid = Qt::Internal::find_pclassid(klass.name)
-			break if classid > 0
+			break if classid.index
 			
 			klass = klass.superclass
 			if klass.nil?
@@ -2732,3 +3148,5 @@ class Module
 		return meths.uniq
 	end
 end
+
+# kate: space-indent false;