qtbindings 4.6.3.0-x86-mingw32

data/lib/Qt.rb

@@ -0,0 +1 @@
+require 'Qt4'

data/lib/Qt/qtruby4.rb

@@ -0,0 +1,3177 @@
+=begin
+/***************************************************************************
+                          qtruby.rb  -  description
+                             -------------------
+    begin                : Fri Jul 4 2003
+    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 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
+
+module Qt
+	module DebugLevel
+		Off, Minimal, High, Extensive = 0, 1, 2, 3
+	end
+
+	module QtDebugChannel 
+		QTDB_NONE = 0x00
+		QTDB_AMBIGUOUS = 0x01
+		QTDB_METHOD_MISSING = 0x02
+		QTDB_CALLS = 0x04
+		QTDB_GC = 0x08
+		QTDB_VIRTUAL = 0x10
+		QTDB_VERBOSE = 0x20
+		QTDB_ALL = QTDB_VERBOSE | QTDB_VIRTUAL | QTDB_GC | QTDB_CALLS | QTDB_METHOD_MISSING | QTDB_AMBIGUOUS
+	end
+
+	@@debug_level = DebugLevel::Off
+	def Qt.debug_level=(level)
+		@@debug_level = level
+		Internal::setDebug Qt::QtDebugChannel::QTDB_ALL if level >= DebugLevel::Extensive
+	end
+
+	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, 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, 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], 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], Internal::MethodSlot | Internal::AccessPublic)
+			meta.changed = true
+		end
+
+		def self.q_classinfo(key, value)
+			meta = Qt::Meta[self.name] || Qt::MetaInfo.new(self)
+			meta.add_classinfo(key, value)
+			meta.changed = true
+		end
+
+		def **(a)
+			return Qt::**(self, a)
+		end
+		def +(a)
+			return Qt::+(self, a)
+		end
+		def ~(a)
+			return Qt::~(self, a)
+		end
+		def -@()
+			return Qt::-(self)
+		end
+		def -(a)
+			return Qt::-(self, a)
+		end
+		def *(a)
+			return Qt::*(self, a)
+		end
+		def /(a)
+			return Qt::/(self, a)
+		end
+		def %(a)
+			return Qt::%(self, a)
+		end
+		def >>(a)
+			return Qt::>>(self, a)
+		end
+		def <<(a)
+			return Qt::<<(self, a)
+		end
+		def &(a)
+			return Qt::&(self, a)
+		end
+		def ^(a)
+			return Qt::^(self, a)
+		end
+		def |(a)
+			return Qt::|(self, a)
+		end
+
+#		Module has '<', '<=', '>' and '>=' operator instance methods, so pretend they
+#		don't exist by calling method_missing() explicitely
+		def <(a)
+			begin
+				Qt::method_missing(:<, self, a)
+			rescue
+				super(a)
+			end
+		end
+
+		def <=(a)
+			begin
+				Qt::method_missing(:<=, self, a)
+			rescue
+				super(a)
+			end
+		end
+
+		def >(a)
+			begin
+				Qt::method_missing(:>, self, a)
+			rescue
+				super(a)
+			end
+		end
+
+		def >=(a)
+			begin
+				Qt::method_missing(:>=, self, a)
+			rescue
+				super(a)
+			end
+		end
+
+#		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
+				super(a)
+			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
+				return singleton_methods
+			end
+	
+			qt_methods(super, 0x0)
+		end
+	
+		def protected_methods(all=true)
+			# From smoke.h, Smoke::mf_protected 0x80
+			qt_methods(super, 0x80)
+		end
+	
+		def public_methods(all=true)
+			methods
+		end
+	
+		def singleton_methods(all=true)
+			# From smoke.h, Smoke::mf_static 0x01
+			qt_methods(super, 0x01)
+		end
+	
+		private
+		def qt_methods(meths, flags)
+			ids = []
+			# These methods are all defined in Qt::Base, even if they aren't supported by a particular
+			# subclass, so remove them to avoid confusion
+			meths -= ["%", "&", "*", "**", "+", "-", "-@", "/", "<", "<<", "<=", ">", ">=", ">>", "|", "~", "^"]
+			classid = Qt::Internal::idInstance(self)
+			Qt::Internal::getAllParents(classid, ids)
+			ids << classid
+			ids.each { |c| Qt::Internal::findAllMethodNames(meths, c, flags) }
+			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)
+			method_missing(:abort, *args)
+		end
+	end
+
+	class AbstractTextDocumentLayout < Qt::Base
+		def format(*args)
+			method_missing(:format, *args)
+		end
+	end
+
+	class AccessibleEvent < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class ActionEvent < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class Action < Qt::Base 
+		def setShortcut(arg)
+			if arg.kind_of?(String)
+				return super(Qt::KeySequence.new(arg))
+			else
+				return super(arg)
+			end
+		end
+
+		def shortcut=(arg)
+			setShortcut(arg)
+		end
+	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.
+		def exec
+			method_missing(:exec)
+			self.dispose
+			Qt::Internal.application_terminated = true
+		end
+
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class Buffer < Qt::Base
+		def open(*args)
+			method_missing(:open, *args)
+		end
+	end
+
+	class ButtonGroup < Qt::Base
+		def id(*args)
+			method_missing(:id, *args)
+		end
+	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
+
+		def to_i
+			return toInt()
+		end
+
+		def to_f
+			return toDouble()
+		end
+
+		def chop(*args)
+			method_missing(:chop, *args)
+		end
+
+		def split(*args)
+			method_missing(:split, *args)
+		end
+	end
+	
+	class CheckBox < Qt::Base 
+		def setShortcut(arg)
+			if arg.kind_of?(String)
+				return super(Qt::KeySequence.new(arg))
+			else
+				return super(arg)
+			end
+		end
+
+		def shortcut=(arg)
+			setShortcut(arg)
+		end
+	end
+
+	class ChildEvent < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class CloseEvent < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+	
+	class Color < Qt::Base
+		def inspect
+			str = super
+			str.sub(/>$/, " %s>" % name)
+		end
+		
+		def pretty_print(pp)
+			str = to_s
+			pp.text str.sub(/>$/, " %s>" % name)
+		end
+
+		def name(*args)
+			method_missing(:name, *args)
+		end
+	end
+	
+	class Connection < Qt::Base
+		def inspect
+			str = super
+			str.sub(/>$/, " memberName=%s, memberType=%s, object=%s>" %
+				[memberName.inspect, memberType == 1 ? "SLOT" : "SIGNAL", object.inspect] )
+		end
+		
+		def pretty_print(pp)
+			str = to_s
+			pp.text str.sub(/>$/, "\n memberName=%s,\n memberType=%s,\n object=%s>" %
+				[memberName.inspect, memberType == 1 ? "SLOT" : "SIGNAL", object.inspect] )
+		end
+	end
+
+	class ContextMenuEvent < Qt::Base
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	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
+	end
+	
+	class Cursor < Qt::Base
+		def inspect
+			str = super
+			str.sub(/>$/, " shape=%d>" % shape)
+		end
+		
+		def pretty_print(pp)
+			str = to_s
+			pp.text str.sub(/>$/, " shape=%d>" % shape)
+		end
+	end
+
+	class CustomEvent < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	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)
+			else
+				return super(*args)
+			end
+		end
+
+		def inspect
+			str = super
+			str.sub(/>$/, " %s>" % toString)
+		end
+		
+		def pretty_print(pp)
+			str = to_s
+			pp.text str.sub(/>$/, " %s>" % toString)
+		end
+
+		def to_date
+			::Date.new! to_julian_day
+		end
+	end
+	
+	class DateTime < Qt::Base
+		def initialize(*args)
+			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)
+		end
+		
+		def pretty_print(pp)
+			str = to_s
+			pp.text str.sub(/>$/, " %s>" % toString)
+		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)
+		end
+	end
+
+	class DBusConnectionInterface < Qt::Base
+		def serviceOwner(name)
+    		return Qt::DBusReply.new(internalConstCall(Qt::DBus::AutoDetect, "GetNameOwner", [Qt::Variant.new(name)]))
+		end
+		
+		def service_owner(name)
+    		return serviceOwner(name)
+		end
+
+		def registeredServiceNames
+			return Qt::DBusReply.new(internalConstCall(Qt::DBus::AutoDetect, "ListNames"))
+		end
+
+		def registered_service_names
+			return registeredServiceNames
+		end
+
+		def isServiceRegistered(serviceName)
+    		return Qt::DBusReply.new(internalConstCall(Qt::DBus::AutoDetect, "NameHasOwner", [Qt::Variant.new(serviceName)]))
+		end
+
+		def is_service_registered(serviceName)
+    		return isServiceRegistered(serviceName)
+		end
+
+		def serviceRegistered?(serviceName)
+    		return isServiceRegistered(serviceName)
+		end
+
+		def service_registered?(serviceName)
+    		return isServiceRegistered(serviceName)
+		end
+
+		def servicePid(serviceName)
+    		return Qt::DBusReply.new(internalConstCall(Qt::DBus::AutoDetect, "GetConnectionUnixProcessID", [Qt::Variant.new(serviceName)]))
+		end
+
+		def service_pid(serviceName)
+    		return servicePid(serviceName)
+		end
+
+		def serviceUid(serviceName)
+    		return Qt::DBusReply.new(internalConstCall(Qt::DBus::AutoDetect, "GetConnectionUnixUser", [Qt::Variant.new(serviceName)]))
+		end
+
+		def service_uid(serviceName)
+    		return serviceUid(serviceName)
+		end
+
+		def startService(name)
+    		return call("StartServiceByName", Qt::Variant.new(name), Qt::Variant.new(0)).value
+		end
+
+		def start_service(name)
+    		startService(name)
+		end
+	end
+
+	class DBusError < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	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'
+				qdbusArgs = args.collect {|arg| qVariantFromValue(arg)}
+				return super(method_name, *qdbusArgs)
+			end
+		end
+
+		def method_missing(id, *args)
+			begin
+				# First look for a method in the Smoke runtime
+				# If not found, then throw an exception and try dbus.
+				super(id, *args)
+			rescue
+				if args.length == 0
+					return call(id.to_s).value
+				else
+					return call(id.to_s, *args).value
+				end
+			end
+		end
+	end
+
+	class DBusMessage < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+
+		def value
+			if type() == Qt::DBusMessage::ReplyMessage
+				reply = arguments()
+				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
+		end
+
+		def <<(a)
+			if a.kind_of?(Qt::Variant)
+				return super(a)
+			else
+				return super(qVariantFromValue(a))
+			end
+		end
+	end
+
+	class DBusReply
+		def initialize(reply)
+			@error = Qt::DBusError.new(reply)
+
+			if @error.valid?
+				@data = Qt::Variant.new
+				return
+			end
+
+			if reply.arguments.length >= 1
+				@data = reply.arguments[0]
+				return
+			end
+			
+			# error
+			@error = Qt::DBusError.new(	Qt::DBusError::InvalidSignature, 
+										"Unexpected reply signature" )
+			@data = Qt::Variant.new      # clear it
+		end
+
+		def isValid
+			return !@error.isValid
+		end
+
+		def valid?
+			return !@error.isValid
+		end
+
+		def value
+			return @data.value
+		end
+
+		def error
+			return @error
+		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)
+		end
+
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class DragEnterEvent < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class DragLeaveEvent < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class DropEvent < Qt::Base
+		def format(*args)
+			method_missing(:format, *args)
+		end
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class Event < Qt::Base
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class EventLoop < Qt::Base
+		def exec(*args)
+			method_missing(:exec, *args)
+		end
+
+		def exit(*args)
+			method_missing(:exit, *args)
+		end
+	end
+
+	class File < Qt::Base
+		def open(*args)
+			method_missing(:open, *args)
+		end
+	end
+
+	class FileOpenEvent < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class FileIconProvider < Qt::Base
+		File = Qt::Enum.new(6, "QFileIconProvider::IconType")
+
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class FocusEvent < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+	
+	class Font < Qt::Base
+		def inspect
+			str = super
+			str.sub(/>$/, " family=%s, pointSize=%d, weight=%d, italic=%s, bold=%s, underline=%s, strikeOut=%s>" % 
+			[family.inspect, pointSize, weight, italic, bold, underline, strikeOut])
+		end
+		
+		def pretty_print(pp)
+			str = to_s
+			pp.text str.sub(/>$/, "\n family=%s,\n pointSize=%d,\n weight=%d,\n italic=%s,\n bold=%s,\n underline=%s,\n strikeOut=%s>" % 
+			[family.inspect, pointSize, weight, italic, bold, underline, strikeOut])
+		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)
+		end
+	end
+
+	class GLContext < Qt::Base
+		def format(*args)
+			method_missing(:format, *args)
+		end
+	end
+
+	class GLPixelBuffer < Qt::Base
+		def format(*args)
+			method_missing(:format, *args)
+		end
+	end
+
+	class GLWidget < Qt::Base
+		def format(*args)
+			method_missing(:format, *args)
+		end
+	end
+
+	class GenericArgument < Qt::Base
+		def name(*args)
+			method_missing(:name, *args)
+		end
+	end
+
+	class Gradient < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class GraphicsEllipseItem < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class GraphicsItem < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class GraphicsItemGroup < Qt::Base
+		Type = 10
+
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	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
+	end
+
+	class GraphicsPixmapItem < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	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
+	end
+
+	class GraphicsSceneDragDropEvent < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class GraphicsSceneMouseEvent < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class GraphicsSceneContextMenuEvent < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class GraphicsSceneHoverEvent < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class GraphicsSceneHelpEvent < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class GraphicsSceneWheelEvent < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	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 GraphicsWidget < Qt::Base
+		Type = 11
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class HelpEvent < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class HideEvent < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class HoverEvent < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class Http < Qt::Base
+		def abort(*args)
+			method_missing(:abort, *args)
+		end
+	end
+
+	class HttpRequestHeader < Qt::Base
+		def method(*args)
+			if args.length == 1
+				super(*args)
+			else
+				method_missing(:method, *args)
+			end
+		end
+	end
+
+	class IconDragEvent < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class InputEvent < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class InputMethodEvent < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class IODevice < Qt::Base
+		def open(*args)
+			method_missing(:open, *args)
+		end
+	end
+
+	class Image < Qt::Base
+		def fromImage(image)
+			send("operator=".to_sym, image)
+		end
+
+		def format(*args)
+			method_missing(:format, *args)
+		end
+
+		def load(*args)
+			method_missing(:load, *args)
+		end
+	end
+
+	class ImageIOHandler < Qt::Base
+		def format(*args)
+			method_missing(:format, *args)
+		end
+
+		def name(*args)
+			method_missing(:name, *args)
+		end
+	end
+
+	class ImageReader < Qt::Base
+		def format(*args)
+			method_missing(:format, *args)
+		end
+	end
+
+	class ImageWriter < Qt::Base
+		def format(*args)
+			method_missing(:format, *args)
+		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
+
+		def split(*args)
+			method_missing(:split, *args)
+		end
+	end
+
+	class ItemSelectionModel < Qt::Base
+		def select(*args)
+			method_missing(:select, *args)
+		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"
+				return super(args[0].to_i)
+			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
+		def display(item)
+			method_missing(:display, item)
+		end
+	end
+
+	class Library < Qt::Base
+		def load(*args)
+			method_missing(:load, *args)
+		end
+	end
+
+	class ListWidgetItem < Qt::Base
+		def clone(*args)
+			Qt::ListWidgetItem.new(self)
+		end
+
+		def type(*args)
+			method_missing(:type, *args)
+		end
+
+		def inspect
+			str = super
+			str.sub(/>$/, " text='%s'>" % text)
+		end
+		
+		def pretty_print(pp)
+			str = to_s
+			pp.text str.sub(/>$/, " text='%s'>" % text)
+		end
+	end
+
+	class Locale < Qt::Base
+		def name(*args)
+			method_missing(:name, *args)
+		end
+
+		def system(*args)
+			method_missing(:system, *args)
+		end
+	end
+
+	class Menu < Qt::Base
+		def exec(*args)
+			method_missing(:exec, *args)
+		end
+	end
+
+	class MetaClassInfo < Qt::Base
+		def name(*args)
+			method_missing(:name, *args)
+		end
+	end
+
+	class MetaEnum < Qt::Base
+		def name(*args)
+			method_missing(:name, *args)
+		end
+
+		def keyValues()
+			res = []
+			for i in 0...keyCount()
+				if flag?
+					res.push "%s=0x%x" % [key(i), value(i)]
+				else
+					res.push "%s=%d" % [key(i), value(i)]
+				end
+			end
+			return res
+		end
+
+		def inspect
+			str = super
+			str.sub(/>$/, " scope=%s, name=%s, keyValues=Array (%d element(s))>" % [scope, name, keyValues.length])
+		end
+		
+		def pretty_print(pp)
+			str = to_s
+			pp.text str.sub(/>$/, " scope=%s, name=%s, keyValues=Array (%d element(s))>" % [scope, name, keyValues.length])
+		end
+	end
+
+	class MetaMethod < Qt::Base
+		# Oops, name clash with the Signal module so hard code
+		# this value rather than get it from the Smoke runtime
+		Method = Qt::Enum.new(0, "QMetaMethod::MethodType")
+		Signal = Qt::Enum.new(1, "QMetaMethod::MethodType")
+	end
+
+	class MetaObject < Qt::Base
+		def method(*args)
+            if args.length == 1 && args[0].kind_of?(Symbol)
+				super(*args)
+			else
+				method_missing(:method, *args)
+			end
+		end
+
+		# Add three methods, 'propertyNames()', 'slotNames()' and 'signalNames()'
+		# from Qt3, as they are very useful when debugging
+
+		def propertyNames(inherits = false)
+			res = []
+			if inherits
+				for p in 0...propertyCount() 
+					res.push property(p).name
+				end
+			else
+				for p in propertyOffset()...propertyCount()
+					res.push property(p).name
+				end
+			end
+			return res
+		end
+
+		def slotNames(inherits = false)
+			res = []
+			if inherits
+				for m in 0...methodCount()
+					if method(m).methodType == Qt::MetaMethod::Slot 
+						res.push "%s %s" % [method(m).typeName == "" ? "void" : method(m).typeName, 
+											method(m).signature]
+					end
+				end
+			else
+				for m in methodOffset()...methodCount()
+					if method(m).methodType == Qt::MetaMethod::Slot 
+						res.push "%s %s" % [method(m).typeName == "" ? "void" : method(m).typeName, 
+											method(m).signature]
+					end
+				end
+			end
+			return res
+		end
+
+		def signalNames(inherits = false)
+			res = []
+			if inherits
+				for m in 0...methodCount()
+					if method(m).methodType == Qt::MetaMethod::Signal 
+						res.push "%s %s" % [method(m).typeName == "" ? "void" : method(m).typeName, 
+											method(m).signature]
+					end
+				end
+			else
+				for m in methodOffset()...methodCount()
+					if method(m).methodType == Qt::MetaMethod::Signal 
+						res.push "%s %s" % [method(m).typeName == "" ? "void" : method(m).typeName, 
+											method(m).signature]
+					end
+				end
+			end
+			return res
+		end
+
+		def enumerators(inherits = false)
+			res = []
+			if inherits
+				for e in 0...enumeratorCount()
+					res.push enumerator(e)
+				end
+			else
+				for e in enumeratorOffset()...enumeratorCount()
+					res.push enumerator(e)
+				end
+			end
+			return res
+		end
+
+		def inspect
+			str = super
+			str.sub!(/>$/, "")
+			str << " className=%s," % className
+			str << " propertyNames=Array (%d element(s))," % propertyNames.length unless propertyNames.length == 0
+			str << " signalNames=Array (%d element(s))," % signalNames.length unless signalNames.length == 0
+			str << " slotNames=Array (%d element(s))," % slotNames.length unless slotNames.length == 0
+			str << " enumerators=Array (%d element(s))," % enumerators.length unless enumerators.length == 0
+			str << " superClass=%s," % superClass.inspect unless superClass == nil
+			str.chop!
+			str << ">"
+		end
+		
+		def pretty_print(pp)
+			str = to_s
+			str.sub!(/>$/, "")
+			str << "\n className=%s," % className
+			str << "\n propertyNames=Array (%d element(s))," % propertyNames.length unless propertyNames.length == 0
+			str << "\n signalNames=Array (%d element(s))," % signalNames.length unless signalNames.length == 0
+			str << "\n slotNames=Array (%d element(s))," % slotNames.length unless slotNames.length == 0
+			str << "\n enumerators=Array (%d element(s))," % enumerators.length unless enumerators.length == 0
+			str << "\n superClass=%s," % superClass.inspect unless superClass == nil
+			str << "\n methodCount=%d," % methodCount
+			str << "\n methodOffset=%d," % methodOffset
+			str << "\n propertyCount=%d," % propertyCount
+			str << "\n propertyOffset=%d," % propertyOffset
+			str << "\n enumeratorCount=%d," % enumeratorCount
+			str << "\n enumeratorOffset=%d," % enumeratorOffset
+			str.chop!
+			str << ">"
+			pp.text str
+		end
+	end
+
+	class MetaProperty < Qt::Base
+		def name(*args)
+			method_missing(:name, *args)
+		end
+
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class MetaType < Qt::Base
+		Float = Qt::Enum.new(135, "QMetaType::Type")
+
+		def load(*args)
+			method_missing(:load, *args)
+		end
+
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class MouseEvent < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class MoveEvent < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class Movie < Qt::Base
+		def format(*args)
+			method_missing(:format, *args)
+		end
+	end
+
+	class NetworkProxy < Qt::Base
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class Object < Qt::Base
+	end
+
+	class PageSetupDialog < Qt::Base
+		def exec(*args)
+			method_missing(:exec, *args)
+		end
+	end
+
+	class PaintEvent < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class Picture < Qt::Base
+		def load(*args)
+			method_missing(:load, *args)
+		end
+	end
+
+	class PictureIO < Qt::Base
+		def format(*args)
+			method_missing(:format, *args)
+		end
+	end
+
+	class Pixmap < Qt::Base
+		def load(*args)
+			method_missing(:load, *args)
+		end
+	end
+
+	class PluginLoader < Qt::Base
+		def load(*args)
+			method_missing(:load, *args)
+		end
+	end
+	
+	class Point < Qt::Base
+		def inspect
+			str = super
+			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>" % [self.x, self.y])
+		end
+	end
+	
+	class PointF < Qt::Base
+		def inspect
+			str = super
+			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>" % [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
+
+	class PrintDialog < Qt::Base
+		def exec(*args)
+			method_missing(:exec, *args)
+		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)
+		end
+	end
+	
+	class PushButton < Qt::Base 
+		def setShortcut(arg)
+			if arg.kind_of?(String)
+				return super(Qt::KeySequence.new(arg))
+			else
+				return super(arg)
+			end
+		end
+
+		def shortcut=(arg)
+			setShortcut(arg)
+		end
+	end
+
+	class Line < Qt::Base
+		def inspect
+			str = super
+			str.sub(/>$/, " x1=%d, y1=%d, x2=%d, y2=%d>" % [x1, y1, x2, y2])
+		end
+		
+		def pretty_print(pp)
+			str = to_s
+			pp.text str.sub(/>$/, "\n x1=%d,\n y1=%d,\n x2=%d,\n y2=%d>" % [x1, y1, x2, y2])
+		end
+	end
+	
+	class LineF < Qt::Base
+		def inspect
+			str = super
+			str.sub(/>$/, " x1=%f, y1=%f, x2=%f, y2=%f>" % [x1, y1, x2, y2])
+		end
+		
+		def pretty_print(pp)
+			str = to_s
+			pp.text str.sub(/>$/, "\n x1=%f,\n y1=%f,\n x2=%f,\n y2=%f>" % [x1, y1, x2, y2])
+		end
+	end
+	
+	class MetaType < Qt::Base
+		def self.type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class ModelIndex < Qt::Base
+		def inspect
+			str = super
+			str.sub(/>$/, " valid?=%s, row=%s, column=%s>" % [valid?, row, column])
+		end
+		
+		def pretty_print(pp)
+			str = to_s
+			pp.text str.sub(/>$/, "\n valid?=%s,\n row=%s,\n column=%s>" % [valid?, row, column])
+		end
+	end
+	
+	class RadioButton < Qt::Base 
+		def setShortcut(arg)
+			if arg.kind_of?(String)
+				return super(Qt::KeySequence.new(arg))
+			else
+				return super(arg)
+			end
+		end
+
+		def shortcut=(arg)
+			setShortcut(arg)
+		end
+	end
+
+	class Rect < Qt::Base
+		def inspect
+			str = super
+			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 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(/>$/, " 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 x=%f,\n y=%f,\n width=%f,\n height=%f>" % [self.x, self.y, width, height])
+		end
+	end
+
+	class ResizeEvent < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		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)
+		end
+	end
+
+	class ShortcutEvent < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class ShowEvent < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+	
+	class Size < Qt::Base
+		def inspect
+			str = super
+			str.sub(/>$/, " width=%d, height=%d>" % [width, height])
+		end
+		
+		def pretty_print(pp)
+			str = to_s
+			pp.text str.sub(/>$/, "\n width=%d,\n height=%d>" % [width, height])
+		end
+	end
+	
+	class SizeF < Qt::Base
+		def inspect
+			str = super
+			str.sub(/>$/, " width=%f, height=%f>" % [width, height])
+		end
+		
+		def pretty_print(pp)
+			str = to_s
+			pp.text str.sub(/>$/, "\n width=%f,\n height=%f>" % [width, height])
+		end
+	end
+	
+	class SizePolicy < Qt::Base
+		def inspect
+			str = super
+			str.sub(/>$/, " horizontalPolicy=%d, verticalPolicy=%d>" % [horizontalPolicy, verticalPolicy])
+		end
+		
+		def pretty_print(pp)
+			str = to_s
+			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)
+		end
+
+		def open(*args)
+			method_missing(:open, *args)
+		end
+	end
+
+	class SqlError < Qt::Base
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class SqlField < Qt::Base
+		def name(*args)
+			method_missing(:name, *args)
+		end
+
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class SqlIndex < Qt::Base
+		def name(*args)
+			method_missing(:name, *args)
+		end
+	end
+
+	class SqlQuery < Qt::Base
+		def exec(*args)
+			method_missing(:exec, *args)
+		end
+	end
+
+	class SqlResult < Qt::Base
+		def exec(*args)
+			method_missing(:exec, *args)
+		end
+	end
+
+	class SqlTableModel < Qt::Base
+		def select(*k)
+			method_missing(:select, *k)
+		end
+	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 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class StatusTipEvent < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class StyleHintReturn < Qt::Base
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class StyleOption < Qt::Base
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class SyntaxHighlighter < Qt::Base
+		def format(*args)
+			method_missing(:format, *args)
+		end
+	end
+
+	class TableWidgetItem < Qt::Base
+		def clone(*args)
+			Qt::TableWidgetItem.new(self)
+		end
+
+		def type(*args)
+			method_missing(:type, *args)
+		end
+
+		def inspect
+			str = super
+			str.sub(/>$/, " text='%s'>" % text)
+		end
+		
+		def pretty_print(pp)
+			str = to_s
+			pp.text str.sub(/>$/, " text='%s'>" % text)
+		end
+	end
+
+	class TemporaryFile < Qt::Base
+		def open(*args)
+			method_missing(:open, *args)
+		end
+	end
+	
+	class TextCursor < Qt::Base
+		def select(*k)
+			method_missing(:select, *k)
+		end
+	end
+
+	class TextDocument < Qt::Base
+		def clone(*args)
+			method_missing(:clone, *args)
+		end
+
+		def print(*args)
+			method_missing(:print, *args)
+		end
+	end
+
+	class TextFormat < Qt::Base
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class TextImageFormat < Qt::Base
+		def name(*args)
+			method_missing(:name, *args)
+		end
+	end
+
+	class TextInlineObject < Qt::Base
+		def format(*args)
+			method_missing(:format, *args)
+		end
+	end
+
+	class TextLength < Qt::Base
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class TextList < Qt::Base
+		def format(*args)
+			method_missing(:format, *args)
+		end
+	end
+
+	class TextObject < Qt::Base
+		def format(*args)
+			method_missing(:format, *args)
+		end
+	end
+
+	class TextTable < Qt::Base
+		def format(*args)
+			method_missing(:format, *args)
+		end
+	end
+
+	class TextTableCell < Qt::Base
+		def format(*args)
+			method_missing(:format, *args)
+		end
+	end
+	
+	class Time < Qt::Base
+		def initialize(*args)
+			if args.size == 1 && args[0].class.name == "Time"
+				return super(args[0].hour, args[0].min, args[0].sec)
+			else
+				return super(*args)
+			end
+		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 TimerEvent < Qt::Base 
+		def type(*args)
+			method_missing(:type, *args)
+		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)
+				return super(Qt::KeySequence.new(arg))
+			else
+				return super(arg)
+			end
+		end
+
+		def shortcut=(arg)
+			setShortcut(arg)
+		end
+	end
+
+	class Translator < Qt::Base
+		def load(*args)
+			method_missing(:load, *args)
+		end
+	end
+
+	class TreeWidget < Qt::Base
+		include Enumerable
+
+		def each
+			it = Qt::TreeWidgetItemIterator.new(self)
+			while it.current
+				yield it.current
+				it += 1
+			end
+		end
+	end
+
+	class TreeWidgetItem < Qt::Base
+		include Enumerable
+
+		def initialize(*args)
+			# There is not way to distinguish between the copy constructor
+			# QTreeWidgetItem (const QTreeWidgetItem & other) 
+			# and
+			# QTreeWidgetItem (QTreeWidgetItem * parent, const QStringList & strings, int type = Type)
+			# when the latter has a single argument. So force the second variant to be called
+			if args.length == 1 && args[0].kind_of?(Qt::TreeWidgetItem)
+				super(args[0], Qt::TreeWidgetItem::Type)
+			else
+				super(*args)
+			end
+		end
+
+		def inspect
+			str = super
+			str.sub!(/>$/, "")
+			str << " parent=%s," % parent unless parent.nil?
+			for i in 0..(columnCount - 1)
+				str << " text%d='%s'," % [i, self.text(i)]
+			end
+			str.sub!(/,?$/, ">")
+		end
+		
+		def pretty_print(pp)
+			str = to_s
+			str.sub!(/>$/, "")
+			str << " parent=%s," % parent unless parent.nil?
+			for i in 0..(columnCount - 1)
+				str << " text%d='%s'," % [i, self.text(i)]
+			end
+			str.sub!(/,?$/, ">")
+			pp.text str
+		end
+
+		def clone(*args)
+			Qt::TreeWidgetItem.new(self)
+		end
+
+		def type(*args)
+			method_missing(:type, *args)
+		end
+
+		def each
+			it = Qt::TreeWidgetItemIterator.new(self)
+			while it.current
+				yield it.current
+				it += 1
+			end
+		end
+	end
+
+	class TreeWidgetItemIterator < Qt::Base
+		def current
+			return send("operator*".to_sym)
+		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 = 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?
+				return super()
+			elsif args.size == 1 && args[0].class.name == "Date"
+				return super(Qt::Date.new(args[0]))
+			elsif args.size == 1 && args[0].class.name == "DateTime"
+				return super(Qt::DateTime.new(	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"
+				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
+		end
+
+		def to_a
+			return toStringList()
+		end
+
+		def to_f
+			return toDouble()
+		end
+
+		def to_i
+			return toInt()
+		end
+
+		def to_int
+			return toInt()
+		end
+
+		def value
+			case type()
+			when Qt::Variant::Invalid
+				return nil
+			when Qt::Variant::Bitmap
+			when Qt::Variant::Bool
+				return toBool
+			when Qt::Variant::Brush
+				return qVariantValue(Qt::Brush, self)
+			when Qt::Variant::ByteArray
+				return toByteArray
+			when Qt::Variant::Char
+				return qVariantValue(Qt::Char, self)
+			when Qt::Variant::Color
+				return qVariantValue(Qt::Color, self)
+			when Qt::Variant::Cursor
+				return qVariantValue(Qt::Cursor, self)
+			when Qt::Variant::Date
+				return toDate
+			when Qt::Variant::DateTime
+				return toDateTime
+			when Qt::Variant::Double
+				return toDouble
+			when Qt::Variant::Font
+				return qVariantValue(Qt::Font, self)
+			when Qt::Variant::Icon
+				return qVariantValue(Qt::Icon, self)
+			when Qt::Variant::Image
+				return qVariantValue(Qt::Image, self)
+			when Qt::Variant::Int
+				return toInt
+			when Qt::Variant::KeySequence
+				return qVariantValue(Qt::KeySequence, self)
+			when Qt::Variant::Line
+				return toLine
+			when Qt::Variant::LineF
+				return toLineF
+			when Qt::Variant::List
+				return toList
+			when Qt::Variant::Locale
+				return qVariantValue(Qt::Locale, self)
+			when Qt::Variant::LongLong
+				return toLongLong
+			when Qt::Variant::Map
+				return toMap
+			when Qt::Variant::Palette
+				return qVariantValue(Qt::Palette, self)
+			when Qt::Variant::Pen
+				return qVariantValue(Qt::Pen, self)
+			when Qt::Variant::Pixmap
+				return qVariantValue(Qt::Pixmap, self)
+			when Qt::Variant::Point
+				return toPoint
+			when Qt::Variant::PointF
+				return toPointF
+			when Qt::Variant::Polygon
+				return qVariantValue(Qt::Polygon, self)
+			when Qt::Variant::Rect
+				return toRect
+			when Qt::Variant::RectF
+				return toRectF
+			when Qt::Variant::RegExp
+				return toRegExp
+			when Qt::Variant::Region
+				return qVariantValue(Qt::Region, self)
+			when Qt::Variant::Size
+				return toSize
+			when Qt::Variant::SizeF
+				return toSizeF
+			when Qt::Variant::SizePolicy
+				return toSizePolicy
+			when Qt::Variant::String
+				return toString
+			when Qt::Variant::StringList
+				return toStringList
+			when Qt::Variant::TextFormat
+				return qVariantValue(Qt::TextFormat, self)
+			when Qt::Variant::TextLength
+				return qVariantValue(Qt::TextLength, self)
+			when Qt::Variant::Time
+				return toTime
+			when Qt::Variant::UInt
+				return toUInt
+			when Qt::Variant::ULongLong
+				return toULongLong
+			when Qt::Variant::Url
+				return toUrl
+			end
+
+			return qVariantValue(nil, self)
+		end
+
+		def inspect
+			str = super
+			str.sub(/>$/, " typeName=%s>" % typeName)
+		end
+		
+		def pretty_print(pp)
+			str = to_s
+			pp.text str.sub(/>$/, " typeName=%s>" % typeName)
+		end
+
+		def load(*args)
+			method_missing(:load, *args)
+		end
+
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class DBusVariant < Variant
+		def initialize(value)
+			if value.kind_of? Qt::Variant
+				super(value)
+			else 
+				super(Qt::Variant.new(value))
+			end
+		end
+
+		def setVariant(variant)
+		end
+
+		def variant=(variant)
+			setVariant(variant)
+		end
+
+		def variant()
+			return self
+		end
+	end
+
+	class WhatsThisClickedEvent < Qt::Base
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class Widget < Qt::Base
+		def raise(*args)
+			method_missing(:raise, *args)
+		end
+	end
+
+	class WindowStateChangeEvent < Qt::Base
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class XmlAttributes < Qt::Base
+		def type(*args)
+			method_missing(:type, *args)
+		end
+	end
+
+	class SignalBlockInvocation < Qt::Object
+		def initialize(parent, block, signature)
+			super(parent)
+			if metaObject.indexOfSlot(signature) == -1
+				self.class.slots signature
+			end
+			@block = block
+		end
+
+		def invoke(*args)
+			@block.call(*args)
+		end
+	end
+
+	class BlockInvocation < Qt::Object
+		def initialize(target, block, signature)
+			super(target)
+			if metaObject.indexOfSlot(signature) == -1
+				self.class.slots signature
+			end
+			@block = block
+		end
+
+		def invoke(*args)
+			@block.call(*args)
+		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)
+			@@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/
+				ruby_classname = classname.sub(/^Q(?=[A-Z])/,'Qt::')
+			else
+				ruby_classname = classname
+			end
+			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.findClass(c)
+			insert_pclassid(classname, classId)
+			@@idclass[classId.index] = classname
+			@@cpp_names[classname] = c
+			klass = isQObject(c) ? create_qobject_class(classname, Qt) \
+                                                   : create_qt_class(classname, Qt)
+			@@classes[classname] = klass unless klass.nil?
+		end
+
+		def Internal.debug_level
+			Qt.debug_level
+		end
+
+		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&?$/
+					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|HBITMAP__\*|HDC__\*|HFONT__\*|HICON__\*|HINSTANCE__\*|HPALETTE__\*|HRGN__\*|HWND__\*|Q_PID|^quint16&?$|^qint16&?$)$/
+					return 4 + const_point
+				elsif typename =~ /^(quint|qint|qulong|qlong|qreal)/
+					return 4 + const_point
+				else 
+					t = typename.sub(/^const\s+/, '')
+					t.sub!(/[&*]$/, '')
+					if isEnum(t)
+						return 2
+					end
+				end
+			elsif argtype == 'n'
+				if typename =~ /^double$|^qreal$/
+					return 6 + const_point
+				elsif typename =~ /^float$/
+					return 4 + const_point
+				elsif typename =~ /^int&?$/
+					return 2 + const_point
+				elsif typename =~ /^(?:short|ushort|uint|long|ulong|signed|unsigned|float|double)$/
+					return 2 + const_point
+				else 
+					t = typename.sub(/^const\s+/, '')
+					t.sub!(/[&*]$/, '')
+					if isEnum(t)
+						return 2 + const_point
+					end
+				end
+			elsif argtype == 'B'
+				if typename =~ /^(?:bool)[*&]?$/
+					return 2 + const_point
+				end
+			elsif argtype == 's'
+				if typename =~ /^(const )?((QChar)[*&]?)$/
+					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.
+				if typename =~ /^(?:
+						const\ QCOORD\*|
+						(?:const\ )?
+						(?:
+						    QStringList[\*&]?|
+						    QValueList<int>[\*&]?|
+						    QRgb\*|
+						    char\*\*
+						)
+					        )$/x
+					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 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 2 + const_point
+				end
+			elsif argtype == 'U'
+				if typename =~ /QStringList/
+					return 4 + const_point
+				else
+					return 2 + const_point
+				end
+			else
+				t = typename.sub(/^const\s+/, '')
+				t.sub!(/(::)?Ptr$/, '')
+				t.sub!(/[&*]$/, '')
+				if argtype == t
+					return 4 + const_point
+				elsif classIsa(argtype, t)
+					return 2 + const_point
+				elsif isEnum(argtype) and 
+						(t =~ /int|qint32|uint|quint32|long|ulong/ or isEnum(t))
+					return 2 + const_point
+				end
+			end
+			return -99
+		end
+
+		def Internal.find_class(classname)
+			@@classes[classname]
+		end
+		
+		# Runs the initializer as far as allocating the Qt C++ instance.
+		# Then use a throw to jump back to here with the C++ instance 
+		# wrapped in a new ruby variable of type T_DATA
+		def Internal.try_initialize(instance, *args)
+			initializer = instance.method(:initialize)
+			catch :newqt do
+				initializer.call(*args)
+			end
+		end
+		
+        # If a block was passed to the constructor, then
+		# run that now. Either run the context of the new instance
+		# 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 || block.arity == 0
+				instance.instance_eval(&block)
+			elsif block.arity == 1
+				block.call(instance)
+			else
+				raise ArgumentError, "Wrong number of arguments to block(#{block.arity} for 1)"
+			end
+		end
+
+		def Internal.do_method_missing(package, method, klass, this, *args)
+			if klass.class == Module
+				classname = klass.name
+			else
+				classname = @@cpp_names[klass.name]
+				if classname.nil?
+					if klass != Object and klass != Qt
+						return do_method_missing(package, method, klass.superclass, this, *args)
+					else
+						return nil
+					end
+				end
+			end
+			
+			if method == "new"
+				method = classname.dup 
+				method.gsub!(/^.*::/,"")
+			end
+			method = "operator" + method.sub("@","") if method !~ /[a-zA-Z]+/
+			# Change foobar= to setFoobar()					
+			method = 'set' + method[0,1].upcase + method[1,method.length].sub("=", "") if method =~ /.*[^-+%\/|=]=$/ && method != 'operator='
+
+			methods = []
+			methods << method.dup
+			args.each do |arg|
+				if arg.nil?
+					# For each nil arg encountered, triple the number of munged method
+					# templates, in order to cover all possible types that can match nil
+					temp = []
+					methods.collect! do |meth| 
+						temp << meth + '?' 
+						temp << meth + '#'
+						meth << '$'
+					end
+					methods.concat(temp)
+				elsif isObject(arg)
+					methods.collect! { |meth| meth << '#' }
+				elsif arg.kind_of? Array or arg.kind_of? Hash
+					methods.collect! { |meth| meth << '?' }
+				else
+					methods.collect! { |meth| meth << '$' }
+				end
+			end
+			
+			methodIds = []
+			methods.collect { |meth| methodIds.concat( findMethod(classname, meth) ) }
+			
+			if method =~ /._./ && methodIds.length == 0
+				# If the method name contains underscores, convert to camel case
+				# form and try again
+				method.gsub!(/(.)_(.)/) {$1 + $2.upcase}
+				return do_method_missing(package, method, klass, this, *args)
+			end
+
+			if debug_level >= DebugLevel::High
+				puts "classname    == #{classname}"
+				puts ":: method == #{method}"
+				puts "-> methodIds == #{methodIds.inspect}"
+				puts "candidate list:"
+				prototypes = dumpCandidates(methodIds).split("\n")
+				line_len = (prototypes.collect { |p| p.length }).max
+				prototypes.zip(methodIds) { 
+					|prototype,id| puts "#{prototype.ljust line_len}  (smoke: #{id.smoke} index: #{id.index})" 
+				}
+			end
+			
+			chosen = nil
+			if methodIds.length > 0
+				best_match = -1
+				methodIds.each do
+					|id|
+					puts "matching => smoke: #{id.smoke} index: #{id.index}" if debug_level >= DebugLevel::High
+					current_match = (isConstMethod(id) ? 1 : 0)
+					(0...args.length).each do
+						|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
+					if current_match > best_match
+						best_match = current_match
+						chosen = id
+					# Multiple matches are an error; the equality test below _cannot_ be commented out.
+					# 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
+						puts "multiple methods matching, this is an error" if debug_level >= DebugLevel::Minimal
+						chosen = nil
+					end
+					puts "match => #{id.index} score: #{current_match}" if debug_level >= DebugLevel::High
+				end
+					
+				puts "Resolved to id: #{chosen.index}" if !chosen.nil? && debug_level >= DebugLevel::High
+			end
+
+			if debug_level >= DebugLevel::Minimal && chosen.nil? && method !~ /^operator/
+				id = find_pclassid(normalize_classname(klass.name))
+				hash = findAllMethods(id)
+				constructor_names = nil
+				if method == classname
+					puts "No matching constructor found, possibles:\n"
+					constructor_names = hash.keys.grep(/^#{classname}/)
+				else
+					puts "Possible prototypes:"
+					constructor_names = hash.keys
+				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
+			setCurrentMethod(chosen) if chosen
+			return nil
+		end
+
+		def Internal.init_all_classes()
+			Qt::Internal::getClassList().each do |c|
+				if c == "Qt"
+					# Don't change Qt to Qt::t, just leave as is
+					@@cpp_names["Qt"] = c
+				elsif c != "QInternal" && !c.empty?
+					Qt::Internal::init_class(c)
+				end
+			end
+
+			@@classes['Qt::Integer'] = Qt::Integer
+			@@classes['Qt::Boolean'] = Qt::Boolean
+			@@classes['Qt::Enum'] = Qt::Enum
+		end
+		
+		def Internal.get_qinteger(num)
+			return num.value
+		end
+		
+		def Internal.set_qinteger(num, val)
+			return num.value = val
+		end
+		
+		def Internal.create_qenum(num, enum_type)
+			return Qt::Enum.new(num, enum_type)
+		end
+		
+		def Internal.get_qenum_type(e)
+			return e.type
+		end
+		
+		def Internal.get_qboolean(b)
+			return b.value
+		end
+		
+		def Internal.set_qboolean(b, val)
+			return b.value = val
+		end
+
+		def Internal.getAllParents(class_id, res)
+			getIsa(class_id).each do |s|
+				c = findClass(s)
+				res << c
+				getAllParents(c, res)
+			end
+		end
+	
+		# 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.
+		# That proc also adds new strings to the 'data' array, and updates 
+		# the corresponding 'pack_str' Array#pack template.
+		def Internal.string_table_handler(data, pack_str)
+			hsh = {}
+			offset = 0
+			return lambda do |str|
+				if !hsh.has_key? str
+					hsh[str] = offset
+					data << str
+					pack_str << "a*x"
+					offset += str.length + 1
+				end
+
+				return hsh[str]
+			end
+		end
+
+		def Internal.makeMetaData(classname, classinfos, dbus, signals, slots)
+			# Each entry in 'stringdata' corresponds to a string in the
+			# qt_meta_stringdata_<classname> structure.
+			# 'pack_string' is used to convert 'stringdata' into the
+			# binary sequence of null terminated strings for the metaObject
+			stringdata = []
+			pack_string = ""
+			string_table = string_table_handler(stringdata, pack_string)
+
+			# This is used to create the array of uints that make up the
+			# qt_meta_data_<classname> structure in the metaObject
+			data = [1, 								# revision
+					string_table.call(classname), 	# classname
+					classinfos.length, classinfos.length > 0 ? 10 : 0, 	# classinfo
+					signals.length + slots.length, 
+					10 + (2*classinfos.length), 	# methods
+					0, 0, 							# properties
+					0, 0]							# enums/sets
+
+			classinfos.each do |entry|
+				data.push string_table.call(entry[0])		# key
+				data.push string_table.call(entry[1])		# value
+			end
+
+			signals.each do |entry|
+				data.push string_table.call(entry.full_name)				# signature
+				data.push string_table.call(entry.full_name.delete("^,"))	# parameters
+				data.push string_table.call(entry.reply_type)				# type, "" means void
+				data.push string_table.call("")				# tag
+				if dbus
+					data.push MethodScriptable | MethodSignal | AccessPublic
+				else
+					data.push entry.access	# flags, always protected for now
+				end
+			end
+
+			slots.each do |entry|
+				data.push string_table.call(entry.full_name)				# signature
+				data.push string_table.call(entry.full_name.delete("^,"))	# parameters
+				data.push string_table.call(entry.reply_type)				# type, "" means void
+				data.push string_table.call("")				# tag
+				if dbus
+					data.push MethodScriptable | MethodSlot | AccessPublic	# flags, always public for now
+				else
+					data.push entry.access		# flags, always public for now
+				end
+			end
+
+			data.push 0		# eod
+
+			return [stringdata.pack(pack_string), data]
+		end
+		
+		def Internal.getMetaObject(klass, qobject)
+			if klass.nil?
+				klass = qobject.class
+			end
+
+			parentMeta = nil
+			if @@cpp_names[klass.superclass.name].nil?
+				parentMeta = getMetaObject(klass.superclass, qobject)
+			end
+
+			meta = Meta[klass.name]
+			if meta.nil?
+				meta = Qt::MetaInfo.new(klass) 
+			end
+
+			if meta.metaobject.nil? or meta.changed
+				stringdata, data = makeMetaData(	qobject.class.name,
+													meta.classinfos,  
+													meta.dbus,
+													meta.signals, 
+													meta.slots )
+				meta.metaobject = make_metaObject(qobject, parentMeta, stringdata, data)
+				meta.changed = false
+			end
+			
+			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
+			return Qt::Object.connect(	src,
+										signal,
+										Qt::BlockInvocation.new(target, block.to_proc, signature),
+										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
+			return Qt::Object.connect(	src,
+										signal,
+										Qt::SignalBlockInvocation.new(src, block.to_proc, 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 = {}
+	
+	# An entry for each signal or slot
+	# Example 
+	#  int foobar(QString,bool)
+	#  :name is 'foobar'
+	#  :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, :access
+
+	class MetaInfo
+		attr_accessor :classinfos, :dbus, :signals, :slots, :metaobject, :mocargs, :changed
+
+		def initialize(klass)
+			Meta[klass.name] = self
+			@klass = klass
+			@metaobject = nil
+			@signals = []
+			@slots = []
+			@classinfos = []
+			@dbus = false
+			@changed = false
+			Internal.addMetaObjectMethods(klass)
+		end
+		
+		def add_signals(signal_list, access)
+			signal_names = []
+			signal_list.each do |signal|
+				if signal.kind_of? Symbol
+					signal = signal.to_s + "()"
+				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,
+					                                    access )
+					signal_names << $3
+				else
+					qWarning( "#{@klass.name}: Invalid signal format: '#{signal}'" )
+				end
+			end
+			Internal.addSignalMethods(@klass, signal_names)
+		end
+		
+		# Return a list of signals, including inherited ones
+		def get_signals
+			all_signals = []
+			current = @klass
+			while current != Qt::Base
+				meta = Meta[current.name]
+				if !meta.nil?
+					all_signals.concat meta.signals
+				end
+				current = current.superclass
+			end
+			return all_signals
+		end
+		
+		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,
+					                                access )
+				else
+					qWarning( "#{@klass.name}: Invalid slot format: '#{slot}'" )
+				end
+			end
+		end
+
+		def add_classinfo(key, value)
+			@classinfos.push [key, value]
+			if key == 'D-Bus Interface'
+				@dbus = true
+			end
+		end
+	end # Qt::MetaInfo
+
+	# These values are from the enum WindowType in qnamespace.h.
+	# Some of the names such as 'Qt::Dialog', clash with QtRuby 
+	# class names. So add some constants here to use instead,
+	# renamed with an ending of 'Type'.
+	WidgetType = 0x00000000
+	WindowType = 0x00000001
+	DialogType = 0x00000002 | WindowType
+	SheetType = 0x00000004 | WindowType
+	DrawerType = 0x00000006 | WindowType
+	PopupType = 0x00000008 | WindowType
+	ToolType = 0x0000000a | WindowType
+	ToolTipType = 0x0000000c | WindowType
+	SplashScreenType = 0x0000000e | WindowType
+	DesktopType = 0x00000010 | WindowType
+	SubWindowType =  0x00000012
+		
+end # Qt
+
+class Object
+	def SIGNAL(signal)
+		if signal.kind_of? Symbol
+			return "2" + signal.to_s + "()"
+		else
+			return "2" + signal
+		end
+	end
+
+	def SLOT(slot)
+		if slot.kind_of? Symbol
+			return "1" + slot.to_s + "()"
+		else
+			return "1" + slot
+		end
+	end
+
+	def emit(signal)
+		return signal
+	end
+
+	def QT_TR_NOOP(x) x end
+	def QT_TRANSLATE_NOOP(scope, x) x end
+
+	# See the discussion here: http://eigenclass.org/hiki.rb?instance_exec
+	# about implementations of the ruby 1.9 method instance_exec(). This
+	# version is the one from Rails. It isn't thread safe, but that doesn't
+	# matter for the intended use in invoking blocks as Qt slots.
+	def instance_exec(*arguments, &block)
+		block.bind(self)[*arguments]
+	end unless defined? instance_exec
+end
+
+class Proc 
+	# Part of the Rails Object#instance_exec implementation
+	def bind(object)
+		block, time = self, Time.now
+		(class << object; self end).class_eval do
+			method_name = "__bind_#{time.to_i}_#{time.usec}"
+			define_method(method_name, &block)
+			method = instance_method(method_name)
+			remove_method(method_name)
+			method
+		end.bind(object)
+	end
+end
+
+class Module
+	alias_method :_constants, :constants
+	alias_method :_instance_methods, :instance_methods
+	alias_method :_protected_instance_methods, :protected_instance_methods
+	alias_method :_public_instance_methods, :public_instance_methods
+
+	private :_constants, :_instance_methods
+	private :_protected_instance_methods, :_public_instance_methods
+
+	def constants
+		qt_methods(_constants, 0x10, true)
+	end
+
+	def instance_methods(inc_super=true)
+		qt_methods(_instance_methods(inc_super), 0x0, inc_super)
+	end
+
+	def protected_instance_methods(inc_super=true)
+		qt_methods(_protected_instance_methods(inc_super), 0x80, inc_super)
+	end
+
+	def public_instance_methods(inc_super=true)
+		qt_methods(_public_instance_methods(inc_super), 0x0, inc_super)
+	end
+
+	private
+	def qt_methods(meths, flags, inc_super=true)
+		if !self.kind_of? Class
+			return meths
+		end
+
+		klass = self
+		classid = Qt::Internal::ModuleIndex.new(0, 0)
+		loop do
+			classid = Qt::Internal::find_pclassid(klass.name)
+			break if classid.index
+			
+			klass = klass.superclass
+			if klass.nil?
+				return meths
+			end
+		end
+
+		# These methods are all defined in Qt::Base, even if they aren't supported by a particular
+		# subclass, so remove them to avoid confusion
+		meths -= ["%", "&", "*", "**", "+", "-", "-@", "/", "<", "<<", "<=", ">", ">=", ">>", "|", "~", "^"]
+		ids = []
+		if inc_super
+			Qt::Internal::getAllParents(classid, ids)
+		end
+		ids << classid
+		ids.each { |c| Qt::Internal::findAllMethodNames(meths, c, flags) }
+		return meths.uniq
+	end
+end
+
+# kate: space-indent false;