qtbindings 4.6.3.0 → 4.6.3.1

data/ext/ruby/qtruby/examples/xml/saxbookmarks/main.rb

@@ -1,34 +0,0 @@
-=begin
-**
-** Copyright (C) 2004-2005 Trolltech AS. All rights reserved.
-**
-** This file is part of the example classes of the Qt Toolkit.
-**
-** This file may be used under the terms of the GNU General Public
-** License version 2.0 as published by the Free Software Foundation
-** and appearing in the file LICENSE.GPL included in the packaging of
-** this file.  Please review the following information to ensure GNU
-** General Public Licensing requirements will be met:
-** http://www.trolltech.com/products/qt/opensource.html
-**
-** If you are unsure which license is appropriate for your use, please
-** review the following information:
-** http://www.trolltech.com/products/qt/licensing.html or contact the
-** sales department at sales@trolltech.com.
-**
-** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
-** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-**
-
-** Translated to QtRuby by Richard Dale
-=end
-
-require 'Qt'
-require 'mainwindow.rb'
-
-$KCODE = 'u'
-
-app = Qt::Application.new(ARGV)
-mainWin = MainWindow.new
-mainWin.show
-app.exec

data/ext/ruby/qtruby/examples/xml/saxbookmarks/mainwindow.rb

@@ -1,144 +0,0 @@
-=begin
-**
-** Copyright (C) 2004-2005 Trolltech AS. All rights reserved.
-**
-** This file is part of the example classes of the Qt Toolkit.
-**
-** This file may be used under the terms of the GNU General Public
-** License version 2.0 as published by the Free Software Foundation
-** and appearing in the file LICENSE.GPL included in the packaging of
-** this file.  Please review the following information to ensure GNU
-** General Public Licensing requirements will be met:
-** http://www.trolltech.com/products/qt/opensource.html
-**
-** If you are unsure which license is appropriate for your use, please
-** review the following information:
-** http://www.trolltech.com/products/qt/licensing.html or contact the
-** sales department at sales@trolltech.com.
-**
-** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
-** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-**
-
-** Translated to QtRuby by Richard Dale
-=end
-	
-require 'xbelhandler.rb'
-	
-class MainWindow < Qt::MainWindow
-		
-	slots :open, :saveAs, :about
-	
-	def initialize(parent = nil)
-		super(parent)
-	    labels = []
-	    labels << tr("Title") << tr("Location")
-	
-	    @treeWidget = Qt::TreeWidget.new
-	    @treeWidget.header().resizeMode = Qt::HeaderView::Stretch
-	    @treeWidget.headerLabels = labels
-	    setCentralWidget(@treeWidget)
-	
-	    createActions()
-	    createMenus()
-	
-	    statusBar().showMessage(tr("Ready"))
-	
-	    setWindowTitle(tr("SAX Bookmarks"))
-	    resize(480, 320)
-	end
-	
-	def open()
-	    fileName =
-	            Qt::FileDialog.getOpenFileName(self, tr("Open Bookmark File"),
-	                                         Qt::Dir.currentPath(),
-	                                         tr("XBEL Files (*.xbel *.xml)"))
-	    if fileName.nil?
-	        return
-		end
-	
-	    @treeWidget.clear()
-	
-	    handler = XbelHandler.new(@treeWidget)
-	    reader = Qt::XmlSimpleReader.new
-	    reader.contentHandler = handler
-	    reader.errorHandler = handler
-	
-	    file = Qt::File.new(fileName)
-	    if !file.open(Qt::File::ReadOnly | Qt::File::Text)
-	        Qt::MessageBox.warning(self, tr("SAX Bookmarks"),
-	                             tr("Cannot read file %s:\n%s." %
-	                             [fileName, file.errorString]))
-	        return
-	    end
-	
-	    xmlInputSource = Qt::XmlInputSource.new(file)
-	    if reader.parse(xmlInputSource, false)
-	        statusBar().showMessage(tr("File loaded"), 2000)
-		end
-	end
-	
-	def saveAs()
-	    fileName =
-	            Qt::FileDialog::getSaveFileName(self, tr("Save Bookmark File"),
-	                                         Qt::Dir.currentPath(),
-	                                         tr("XBEL Files (*.xbel *.xml)"))
-	    if fileName.nil?
-	        return
-		end
-	
-	    file = Qt::File.new(fileName)
-	    if !file.open(Qt::File::WriteOnly | Qt::File::Text.to_i)
-	        Qt::MessageBox.warning(self, tr("SAX Bookmarks"),
-	                             tr("Cannot write file %s:\n%s." %
-	                             [fileName, file.errorString]))
-	        return
-	    end
-	
-	    generator = XbelGenerator.new(@treeWidget)
-	    if generator.write(file)
-	        statusBar().showMessage(tr("File saved"), 2000)
-		end
-		file.close
-	end
-	
-	def about()
-	   Qt::MessageBox.about(self, tr("About SAX Bookmarks"),
-	            tr("The <b>SAX Bookmarks</b> example demonstrates how to use Qt's " \
-	               "SAX classes to read XML documents and how to generate XML by " \
-	               "hand."))
-	end
-	
-	def createActions()
-	    @openAct = Qt::Action.new(tr("&Open..."), self)
-	    @openAct.shortcut = Qt::KeySequence.new( tr("Ctrl+O"))
-	    connect(@openAct, SIGNAL(:triggered), self, SLOT(:open))
-	
-	    @saveAsAct = Qt::Action.new(tr("&Save As..."), self)
-	    @saveAsAct.shortcut = Qt::KeySequence.new( tr("Ctrl+S"))
-	    connect(@saveAsAct, SIGNAL(:triggered), self, SLOT(:saveAs))
-	
-	    @exitAct = Qt::Action.new(tr("E&xit"), self)
-	    @exitAct.shortcut = Qt::KeySequence.new( tr("Ctrl+Q"))
-	    connect(@exitAct, SIGNAL(:triggered), self, SLOT(:close))
-	
-	    @aboutAct = Qt::Action.new(tr("&About"), self)
-	    connect(@aboutAct, SIGNAL(:triggered), self, SLOT(:about))
-	
-	    @aboutQtAct = Qt::Action.new(tr("About &Qt"), self)
-	    connect(@aboutQtAct, SIGNAL(:triggered), $qApp, SLOT(:aboutQt))
-	end
-	
-	def createMenus()
-	    @fileMenu = menuBar.addMenu(tr("&File"))
-	    @fileMenu.addAction(@openAct)
-	    @fileMenu.addAction(@saveAsAct)
-	    @fileMenu.addAction(@exitAct)
-	
-	    menuBar().addSeparator()
-	
-	    @helpMenu = menuBar.addMenu(tr("&Help"))
-	    @helpMenu.addAction(@aboutAct)
-	    @helpMenu.addAction(@aboutQtAct)	
-	end
-end

data/ext/ruby/qtruby/examples/xml/saxbookmarks/xbelgenerator.rb

@@ -1,95 +0,0 @@
-=begin
-**
-** Copyright (C) 2004-2005 Trolltech AS. All rights reserved.
-**
-** This file is part of the example classes of the Qt Toolkit.
-**
-** This file may be used under the terms of the GNU General Public
-** License version 2.0 as published by the Free Software Foundation
-** and appearing in the file LICENSE.GPL included in the packaging of
-** this file.  Please review the following information to ensure GNU
-** General Public Licensing requirements will be met:
-** http://www.trolltech.com/products/qt/opensource.html
-**
-** If you are unsure which license is appropriate for your use, please
-** review the following information:
-** http://www.trolltech.com/products/qt/licensing.html or contact the
-** sales department at sales@trolltech.com.
-**
-** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
-** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-**
-
-** Translated to QtRuby by Richard Dale
-=end
-	
-		
-class XbelGenerator
-	IndentSize = 4
-	
-	def initialize(treeWidget)
-	    @treeWidget = treeWidget
-		@outf = Qt::TextStream.new
-	end
-	
-	def write(device)
-	    @outf.device = device
-	    @outf.codec = "UTF-8"
-	    @outf << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" <<
-	        "<!DOCTYPE xbel>\n" <<
-	        "<xbel version=\"1.0\">\n"
-		
-		for i in 0...@treeWidget.topLevelItemCount()
-	        generateItem(@treeWidget.topLevelItem(i), 1)
-		end
-	
-	    @outf << "</xbel>\n"
-	    return true
-	end
-	
-	def indent(depth)
-	    return " " * (IndentSize * depth)
-	end
-	
-	def escapedText(str)
-	    result = str
-	    result.gsub!("&", "&amp;")
-	    result.gsub!("<", "&lt;")
-	    result.gsub!(">", "&gt;")
-	    return result
-	end
-	
-	def escapedAttribute(str)
-	    result = escapedText(str)
-	    result.gsub!("\"", "&quot;")
-	    return '"' + result + '"'
-	end
-	
-	def generateItem(item, depth)
-	    tagName = item.data(0, Qt::UserRole).toString()
-	    if tagName == "folder"
-	        folded = !@treeWidget.isItemExpanded(item)
-	        @outf << indent(depth) << "<folder folded=\"" << (folded ? "yes" : "no") <<
-	                             "\">\n" <<
-	            indent(depth + 1) << "<title>" << escapedText(item.text(0)) <<
-	                                 "</title>\n"
-	
-			for i in 0...item.childCount()
-	            generateItem(item.child(i), depth + 1)
-			end
-	
-	        @outf << indent(depth) << "</folder>\n"
-	    elsif tagName == "bookmark"
-	        @outf << indent(depth) << "<bookmark"
-	        if !item.text(1).empty?
-	            @outf << " href=" << escapedAttribute(item.text(1))
-			end
-	        @outf << ">\n" <<
-	            indent(depth + 1) << "<title>" << escapedText(item.text(0)) <<
-	                                 "</title>\n" <<
-	            indent(depth) << "</bookmark>\n"
-	    elsif tagName == "separator"
-	        @outf << indent(depth) << "<separator/>\n"
-	    end
-	end
-end

data/ext/ruby/qtruby/examples/xml/saxbookmarks/xbelhandler.rb

@@ -1,122 +0,0 @@
-=begin
-**
-** Copyright (C) 2004-2005 Trolltech AS. All rights reserved.
-**
-** This file is part of the example classes of the Qt Toolkit.
-**
-** This file may be used under the terms of the GNU General Public
-** License version 2.0 as published by the Free Software Foundation
-** and appearing in the file LICENSE.GPL included in the packaging of
-** this file.  Please review the following information to ensure GNU
-** General Public Licensing requirements will be met:
-** http://www.trolltech.com/products/qt/opensource.html
-**
-** If you are unsure which license is appropriate for your use, please
-** review the following information:
-** http://www.trolltech.com/products/qt/licensing.html or contact the
-** sales department at sales@trolltech.com.
-**
-** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
-** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-**
-
-** Translated to QtRuby by Richard Dale
-=end
-		
-require 'xbelgenerator.rb'
-
-class XbelHandler < Qt::XmlDefaultHandler
-	
-	def initialize(treeWidget)
-	    super()
-		@treeWidget = treeWidget
-	    @item = nil
-	    @metXbelTag = false
-		@currentText = ""
-	
-	    style = @treeWidget.style()
-	
-		@folderIcon = Qt::Icon.new
-	    @folderIcon.addPixmap(style.standardPixmap(Qt::Style::SP_DirClosedIcon),
-	                         Qt::Icon::Normal, Qt::Icon::Off)
-	    @folderIcon.addPixmap(style.standardPixmap(Qt::Style::SP_DirOpenIcon),
-	                         Qt::Icon::Normal, Qt::Icon::On)
-		@bookmarkIcon = Qt::Icon.new
-	    @bookmarkIcon.addPixmap(style.standardPixmap(Qt::Style::SP_FileIcon))
-	end
-	
-	def startElement(namespaceURI, localName, qName, attributes)
-	    if !@metXbelTag && qName != "xbel"
-	        @errorStr = Qt::Object.tr("The file is not an XBEL file.")
-	        return false
-	    end
-	
-	    if qName == "xbel"
-	        version = attributes.value("version")
-	        if !version.empty? && version != "1.0"
-	            @errorStr = Qt::Object.tr("The file is not an XBEL version 1.0 file.")
-	            return false
-	        end
-	        @metXbelTag = true
-	    elsif qName == "folder"
-	        @item = createChildItem(qName)
-	        @item.flags = @item.flags | Qt::ItemIsEditable.to_i
-	        @item.setIcon(0, @folderIcon)
-	        @item.setText(0, Qt::Object.tr("Folder"))
-	        folded = (attributes.value("folded") != "no")
-	        @treeWidget.setItemExpanded(@item, !folded)
-	    elsif qName == "bookmark"
-	        @item = createChildItem(qName)
-	        @item.flags = @item.flags | Qt::ItemIsEditable.to_i
-	        @item.setIcon(0, @bookmarkIcon)
-	        @item.setText(0, Qt::Object.tr("Unknown title"))
-	        @item.setText(1, attributes.value("href"))
-	    elsif qName == "separator"
-	        @item = createChildItem(qName)
-	        @item.flags = @item.flags & ~Qt::ItemIsSelectable.to_i
-#	        @item.setText(0, Qt::String(30, 0xB7))
-	        @item.setText(0, "..............................")
-	    end
-	
-		@currentText = ""
-	    return true
-	end
-	
-	def endElement(namespaceURI, localName, qName)
-	    if qName == "title"
-	        if !@item.nil?
-	            @item.setText(0, @currentText)
-			end
-	    elsif qName == "folder" || qName == "bookmark" ||
-	               qName == "separator"
-	        @item = @item.parent()
-	    end
-	    return true
-	end
-	
-	def characters(str)
-	    @currentText += str
-	    return true
-	end
-	
-	def fatalError(exception)
-	    Qt::MessageBox.information(@treeWidget.window(), Qt::Object.tr("SAX Bookmarks"),
-	                             Qt::Object::tr("Parse error at line %s, column %s:\n%s" %
-	                             [exception.lineNumber, exception.columnNumber,exception.message]))
-	    return false
-	end
-	
-	def errorString()
-	    return @errorStr
-	end
-	
-	def createChildItem(tagName)
-	    if !@item.nil?
-	        childItem = Qt::TreeWidgetItem.new(@item, Qt::TreeWidgetItem::Type)
-	    else
-	        childItem = Qt::TreeWidgetItem.new(@treeWidget)
-	    end
-	    childItem.setData(0, Qt::UserRole, Qt::Variant.new(tagName))
-	    return childItem
-	end
-end

data/ext/ruby/qtruby/src/lib/CMakeLists.txt

@@ -1,16 +0,0 @@
-
-add_subdirectory( Qt )
-
-install( FILES  Qt.rb Qt4.rb Qt3.rb DESTINATION ${CUSTOM_RUBY_SITE_LIB_DIR} )
-
-#original Makefile.am contents follow:
-
-#SUBDIRS = Qt 
-#
-#rubylibdir = $(RUBY_SITEDIR)
-#rubylib_DATA = Qt4.rb Qt3.rb
-#
-#install-data-local:
-#	@-rm -f $(RUBY_SITEDIR)/Qt.rb
-#	@$(LN_S) $(RUBY_SITEDIR)/Qt4.rb $(RUBY_SITEDIR)/Qt.rb
-#

data/ext/ruby/qtruby/src/lib/Qt.rb

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

data/ext/ruby/qtruby/src/lib/Qt/CMakeLists.txt

@@ -1,9 +0,0 @@
-
-install( FILES  qtruby4.rb DESTINATION ${CUSTOM_RUBY_SITE_LIB_DIR}/Qt )
-
-
-
-#original Makefile.am contents follow:
-
-#qtrubylibdir = $(RUBY_SITEDIR)/Qt
-#qtrubylib_DATA = qtruby4.rb

data/ext/ruby/qtruby/src/lib/Qt/qtruby4.rb

@@ -1,3177 +0,0 @@
-=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|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;