Initial import of python-qt3

1 files changed, 2319 insertions, 0 deletions

diff --git a/sip/qt/qobject.sip b/sip/qt/qobject.sip
new file mode 100644
index 0000000..0129284
--- /dev/null
+++ b/sip/qt/qobject.sip
@@ -0,0 +1,2319 @@
+// This is the SIP interface definition for QObject.
+//
+// Copyright (c) 2007
+// 	Riverbank Computing Limited <info@riverbankcomputing.co.uk>
+// 
+// This file is part of PyQt.
+// 
+// This copy of PyQt is free software; you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by the Free
+// Software Foundation; either version 2, or (at your option) any later
+// version.
+// 
+// PyQt is supplied in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+// FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+// details.
+// 
+// You should have received a copy of the GNU General Public License along with
+// PyQt; see the file LICENSE.  If not, write to the Free Software Foundation,
+// Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+
+%ExportedDoc
+<Sect2><Title>QObject</Title>
+<FuncSynopsis>
+	<FuncDef>bool <Function>disconnect</Function></FuncDef>
+	<ParamDef>const QObject *<Parameter>receiver</Parameter></ParamDef>
+	<ParamDef>const char *<Parameter>member</Parameter> = 0</ParamDef>
+</FuncSynopsis>
+<Para>
+Not yet implemented.
+</Para>
+
+<FuncSynopsis>
+	<FuncDef>bool <Function>disconnect</Function></FuncDef>
+	<ParamDef>const char *<Parameter>signal</Parameter> = 0</ParamDef>
+	<ParamDef>const QObject *<Parameter>receiver</Parameter> = 0</ParamDef>
+	<ParamDef>const char *<Parameter>member</Parameter> = 0</ParamDef>
+</FuncSynopsis>
+<Para>
+Not yet implemented.
+</Para>
+
+<FuncSynopsis>
+	<FuncDef>static bool <Function>disconnect</Function></FuncDef>
+	<ParamDef>const QObject *<Parameter>sender</Parameter></ParamDef>
+	<ParamDef>const char *<Parameter>signal</Parameter></ParamDef>
+	<ParamDef>const QObject *<Parameter>receiver</Parameter></ParamDef>
+	<ParamDef>const char *<Parameter>member</Parameter></ParamDef>
+</FuncSynopsis>
+<Para>
+At the moment PyQt does not support the full behaviour of the corresponding Qt
+method. In particular, specifying None (ie. 0 in C++) for the
+<Literal>signal</Literal> and <Literal>receiver</Literal> parameters is not yet
+supported.
+</Para>
+</Sect2>
+%End
+
+
+%If (Qt_2_00 -)
+
+class QObject : Qt
+{
+%TypeHeaderCode
+#include <qobject.h>
+#include <qapplication.h>
+%End
+
+public:
+	QObject(QObject * /TransferThis/ = 0,const char * = 0);
+
+%ConvertToSubClassCode
+	static struct class_graph {
+		const char *name;
+		sipWrapperType **type;
+		int yes, no;
+	} graph[] = {
+		{sipName_QWidget,	&sipClass_QWidget,	25, 1},
+#if QT_VERSION >= 0x030100 && defined(SIP_FEATURE_Qt_ASSISTANTCLIENT)
+		{sipName_QAssistantClient,	&sipClass_QAssistantClient,	-1, 2},
+#else
+		{NULL,				NULL,				-1, 2},
+#endif
+		{sipName_QSessionManager,	&sipClass_QSessionManager,	-1, 3},
+		{sipName_QTranslator,	&sipClass_QTranslator,	-1, 4},
+#if QT_VERSION >= 0x030000
+		{sipName_QProcess,	&sipClass_QProcess,	-1, 5},
+#else
+		{NULL,			NULL,			-1, 5},
+#endif
+		{sipName_QToolTipGroup,	&sipClass_QToolTipGroup,	-1, 6},
+#if defined(SIP_FEATURE_Qt_FILEDIALOG)
+		{sipName_QFileIconProvider,	&sipClass_QFileIconProvider,	-1, 7},
+#else
+		{NULL,				NULL,				-1, 7},
+#endif
+#if QT_VERSION >= 220 && defined(SIP_FEATURE_Qt_ACTION)
+		{sipName_QAction,	&sipClass_QAction,	89, 8},
+#else
+		{NULL,			NULL,			-1, 8},
+#endif
+#if QT_VERSION >= 0x030000
+		{sipName_QObjectCleanupHandler,	&sipClass_QObjectCleanupHandler,	-1, 9},
+#else
+		{NULL,				NULL,					-1, 9},
+#endif
+		{sipName_QTimer,	&sipClass_QTimer,	-1, 10},
+		{sipName_QLayout,	&sipClass_QLayout,	90, 11},
+#if QT_VERSION >= 210 && defined(SIP_FEATURE_Qt_NETWORKPROTOCOL)
+		{sipName_QUrlOperator,	&sipClass_QUrlOperator,	-1, 12},
+#else
+		{NULL,			NULL,			-1, 12},
+#endif
+		{sipName_QStyleSheet,	&sipClass_QStyleSheet,	-1, 13},
+		{sipName_QValidator,	&sipClass_QValidator,	94, 14},
+#if QT_VERSION >= 210 && defined(SIP_FEATURE_Qt_NETWORKPROTOCOL)
+		{sipName_QNetworkOperation,	&sipClass_QNetworkOperation,	-1, 15},
+#else
+		{NULL,				NULL,				-1, 15},
+#endif
+		{sipName_QAccel,	&sipClass_QAccel,	-1, 16},
+#if QT_VERSION >= 0x030100
+		{sipName_QEventLoop,	&sipClass_QEventLoop,	-1, 17},
+#else
+		{NULL,			NULL,			-1, 17},
+#endif
+#if QT_VERSION >= 210 && defined(SIP_FEATURE_Qt_NETWORKPROTOCOL)
+		{sipName_QNetworkProtocol,	&sipClass_QNetworkProtocol,	-1, 18},
+#else
+		{NULL,				NULL,				-1, 18},
+#endif
+#if QT_VERSION >= 220 && defined(SIP_FEATURE_Qt_SOUND)
+		{sipName_QSound,	&sipClass_QSound,	-1, 19},
+#else
+		{NULL,			NULL,			-1, 19},
+#endif
+		{sipName_QApplication,	&sipClass_QApplication,	-1, 20},
+		{sipName_QDragObject,	&sipClass_QDragObject,	97, 21},
+		{sipName_QSocketNotifier,	&sipClass_QSocketNotifier,	-1, 22},
+		{sipName_QStyle,	&sipClass_QStyle,	103, 23},
+		{sipName_QSignalMapper,	&sipClass_QSignalMapper,	-1, 24},
+#if defined(SIP_FEATURE_Qt_CLIPBOARD)
+		{sipName_QClipboard,	&sipClass_QClipboard,	-1, -1},
+#else
+		{NULL,			NULL,			-1, -1},
+#endif
+		{sipName_QStatusBar,	&sipClass_QStatusBar,	-1, 26},
+#if defined(SIP_FEATURE_Qt_SIZEGRIP)
+		{sipName_QSizeGrip,	&sipClass_QSizeGrip,	-1, 27},
+#else
+		{NULL,			NULL,			-1, 27},
+#endif
+		{sipName_QTabWidget,	&sipClass_QTabWidget,	-1, 28},
+#if QT_VERSION >= 0x030000
+		{sipName_QDateEdit,	&sipClass_QDateEdit,	-1, 29},
+#else
+		{NULL,			NULL,			-1, 29},
+#endif
+		{sipName_QMainWindow,	&sipClass_QMainWindow,	-1, 30},
+#if QT_VERSION >= 0x030000
+		{sipName_QDateTimeEdit,	&sipClass_QDateTimeEdit,	-1, 31},
+#else
+		{NULL,			NULL,			-1, 31},
+#endif
+#if QT_VERSION >= 0x030000
+		{sipName_QTimeEdit,	&sipClass_QTimeEdit,	-1, 32},
+#else
+		{NULL,			NULL,			-1, 32},
+#endif
+		{sipName_QFrame,	&sipClass_QFrame,	46, 33},
+		{sipName_QScrollBar,	&sipClass_QScrollBar,	-1, 34},
+#if QT_VERSION >= 220 && defined(SIP_FEATURE_Qt_DIAL)
+		{sipName_QDial,		&sipClass_QDial,	-1, 35},
+#else
+		{NULL,			NULL,			-1, 35},
+#endif
+		{sipName_QButton,	&sipClass_QButton,	75, 36},
+		{sipName_QTabBar,	&sipClass_QTabBar,	-1, 37},
+		{sipName_QDialog,	&sipClass_QDialog,	79, 38},
+		{sipName_QComboBox,	&sipClass_QComboBox,	-1, 39},
+		{sipName_QHeader,	&sipClass_QHeader,	-1, 40},
+#if QT_VERSION >= 0x030000
+		{sipName_QDockArea,	&sipClass_QDockArea,	-1, 41},
+#else
+		{NULL,			NULL,			-1, 41},
+#endif
+#if QT_VERSION >= 0x030200
+		{sipName_QSplashScreen,	&sipClass_QSplashScreen,	-1, 42},
+#else
+		{NULL,			NULL,				-1, 42},
+#endif
+		{sipName_QSlider,	&sipClass_QSlider,	-1, 43},
+		{sipName_QSpinBox,	&sipClass_QSpinBox,	-1, 44},
+#if QT_VERSION >= 210 && defined(SIP_FEATURE_Qt_WORKSPACE)
+		{sipName_QWorkspace,	&sipClass_QWorkspace,	-1, 45},
+#else
+		{NULL,			NULL,			-1, 45},
+#endif
+#if QT_VERSION >= 0x030000
+		{sipName_QDesktopWidget,	&sipClass_QDesktopWidget,	-1, -1},
+#else
+		{NULL,				NULL,				-1, -1},
+#endif
+		{sipName_QGrid,	&sipClass_QGrid,	-1, 47},
+		{sipName_QLineEdit,	&sipClass_QLineEdit,	-1, 48},
+#if QT_VERSION >= 0x030200
+		{sipName_QToolBox,	&sipClass_QToolBox,	-1, 49},
+#else
+		{NULL,			NULL,			-1, 49},
+#endif
+		{sipName_QWidgetStack,	&sipClass_QWidgetStack,	-1, 50},
+#if QT_VERSION >= 0x030000
+		{sipName_QDockWindow,	&sipClass_QDockWindow,	60, 51},
+#else
+		{NULL,			NULL,			-1, 51},
+#endif
+		{sipName_QMenuBar,	&sipClass_QMenuBar,	-1, 52},
+		{sipName_QLabel,	&sipClass_QLabel,	-1, 53},
+		{sipName_QGroupBox,	&sipClass_QGroupBox,	61, 54},
+		{sipName_QPopupMenu,	&sipClass_QPopupMenu,	-1, 55},
+#if defined(SIP_FEATURE_Qt_SPLITTER)
+		{sipName_QSplitter,	&sipClass_QSplitter,	-1, 56},
+#else
+		{NULL,			NULL,			-1, 56},
+#endif
+		{sipName_QProgressBar,	&sipClass_QProgressBar,	-1, 57},
+		{sipName_QScrollView,	&sipClass_QScrollView,	66, 58},
+		{sipName_QHBox,		&sipClass_QHBox,	74, 59},
+		{sipName_QLCDNumber,	&sipClass_QLCDNumber,	-1, -1},
+		{sipName_QToolBar,	&sipClass_QToolBar,	-1, -1},
+		{sipName_QButtonGroup,	&sipClass_QButtonGroup,	64, 62},
+		{sipName_QHGroupBox,	&sipClass_QHGroupBox,	-1, 63},
+		{sipName_QVGroupBox,	&sipClass_QVGroupBox,	-1, -1},
+		{sipName_QVButtonGroup,	&sipClass_QVButtonGroup,	-1, 65},
+		{sipName_QHButtonGroup,	&sipClass_QHButtonGroup,	-1, -1},
+#if QT_VERSION >= 210 && defined(SIP_FEATURE_Qt_ICONVIEW)
+		{sipName_QIconView,	&sipClass_QIconView,	-1, 67},
+#else
+		{NULL,			NULL,			-1, 67},
+#endif
+		{sipName_QListView,	&sipClass_QListView,	-1, 68},
+		{sipName_QListBox,	&sipClass_QListBox,	-1, 69},
+#if QT_VERSION >= 0x030000
+		{sipName_QGridView,	&sipClass_QGridView,	-1, 70},
+#else
+		{NULL,			NULL,			-1, 70},
+#endif
+#if QT_VERSION >= 0x030000
+		{sipName_QTextEdit,	&sipClass_QTextEdit,	71, -1},
+#else
+		{NULL,			NULL,			-1, -1},
+#endif
+		{sipName_QTextBrowser,	&sipClass_QTextBrowser,	-1, 72},
+		{sipName_QMultiLineEdit,	&sipClass_QMultiLineEdit,	-1, 73},
+		{sipName_QTextView,	&sipClass_QTextView,	-1, -1},
+		{sipName_QVBox,		&sipClass_QVBox,	-1, -1},
+		{sipName_QToolButton,	&sipClass_QToolButton,	-1, 76},
+		{sipName_QRadioButton,	&sipClass_QRadioButton,	-1, 77},
+		{sipName_QPushButton,	&sipClass_QPushButton,	-1, 78},
+		{sipName_QCheckBox,	&sipClass_QCheckBox,	-1, -1},
+#if defined(WS_X11) && defined(SIP_FEATURE_Qt_PRINTDIALOG)
+		{sipName_QPrintDialog,	&sipClass_QPrintDialog,	-1, 80},
+#else
+		{NULL,			NULL,			-1, 80},
+#endif
+#if QT_VERSION >= 0x030000
+		{sipName_QErrorMessage,	&sipClass_QErrorMessage,	-1, 81},
+#else
+		{NULL,			NULL,				-1, 81},
+#endif
+#if QT_VERSION >= 210 && defined(SIP_FEATURE_Qt_INPUTDIALOG)
+		{sipName_QInputDialog,	&sipClass_QInputDialog,	-1, 82},
+#else
+		{NULL,			NULL,			-1, 82},
+#endif
+#if defined(SIP_FEATURE_Qt_MESSAGEBOX)
+		{sipName_QMessageBox,	&sipClass_QMessageBox,	-1, 83},
+#else
+		{NULL,			NULL,			-1, 83},
+#endif
+#if defined(SIP_FEATURE_Qt_WIZARD)
+		{sipName_QWizard,	&sipClass_QWizard,	-1, 84},
+#else
+		{NULL,			NULL,			-1, 84},
+#endif
+#if defined(SIP_FEATURE_Qt_COLORDIALOG)
+		{sipName_QColorDialog,	&sipClass_QColorDialog,	-1, 85},
+#else
+		{NULL,			NULL,			-1, 85},
+#endif
+#if defined(SIP_FEATURE_Qt_FONTDIALOG)
+		{sipName_QFontDialog,	&sipClass_QFontDialog,	-1, 86},
+#else
+		{NULL,			NULL,			-1, 86},
+#endif
+#if defined(SIP_FEATURE_Qt_FILEDIALOG)
+		{sipName_QFileDialog,	&sipClass_QFileDialog,	-1, 87},
+#else
+		{NULL,			NULL,			-1, 87},
+#endif
+#if defined(SIP_FEATURE_Qt_PROGRESSDIALOG)
+		{sipName_QProgressDialog,	&sipClass_QProgressDialog,	-1, 88},
+#else
+		{NULL,				NULL,				-1, 88},
+#endif
+#if defined(SIP_FEATURE_Qt_TABDIALOG)
+		{sipName_QTabDialog,	&sipClass_QTabDialog,	-1, -1},
+#else
+		{NULL,			NULL,			-1, -1},
+#endif
+#if QT_VERSION >= 220 && defined(SIP_FEATURE_Qt_ACTION)
+		{sipName_QActionGroup,	&sipClass_QActionGroup,	-1, -1},
+#else
+		{NULL,			NULL,			-1, -1},
+#endif
+		{sipName_QGridLayout,	&sipClass_QGridLayout,	-1, 91},
+		{sipName_QBoxLayout,	&sipClass_QBoxLayout,	92, -1},
+		{sipName_QHBoxLayout,	&sipClass_QHBoxLayout,	-1, 93},
+		{sipName_QVBoxLayout,	&sipClass_QVBoxLayout,	-1, -1},
+		{sipName_QDoubleValidator,	&sipClass_QDoubleValidator,	-1, 95},
+		{sipName_QIntValidator,	&sipClass_QIntValidator,	-1, 96},
+#if QT_VERSION >= 0x030000
+		{sipName_QRegExpValidator,	&sipClass_QRegExpValidator,	-1, -1},
+#else
+		{NULL,				NULL,				-1, -1},
+#endif
+		{sipName_QTextDrag,	&sipClass_QTextDrag,	-1, 98},
+		{sipName_QStoredDrag,	&sipClass_QStoredDrag,	101, 99},
+#if QT_VERSION >= 210 && defined(SIP_FEATURE_Qt_ICONVIEW) && defined(SIP_FEATURE_Qt_DRAGANDDROP)
+		{sipName_QIconDrag,	&sipClass_QIconDrag,	-1, 100},
+#else
+		{NULL,			NULL,			-1, 100},
+#endif
+		{sipName_QImageDrag,	&sipClass_QImageDrag,	-1, -1},
+#if QT_VERSION >= 210
+		{sipName_QColorDrag,	&sipClass_QColorDrag,	-1, 102},
+#else
+		{NULL,			NULL,			-1, 102},
+#endif
+		{sipName_QUriDrag,	&sipClass_QUriDrag,	-1, -1},
+		{sipName_QCommonStyle,	&sipClass_QCommonStyle,	104, -1},
+#if defined(SIP_FEATURE_Qt_STYLE_WINDOWS)
+		{sipName_QWindowsStyle,	&sipClass_QWindowsStyle,	106, 105},
+#else
+		{NULL,			NULL,				-1, 105},
+#endif
+#if defined(SIP_FEATURE_Qt_STYLE_MOTIF)
+		{sipName_QMotifStyle,	&sipClass_QMotifStyle,	107, -1},
+#else
+		{NULL,			NULL,			-1, -1},
+#endif
+#if defined(SIP_FEATURE_Qt_STYLE_PLATINUM)
+		{sipName_QPlatinumStyle,	&sipClass_QPlatinumStyle,	-1, 110},
+#else
+		{NULL,				NULL,				-1, 110},
+#endif
+#if defined(SIP_FEATURE_Qt_STYLE_CDE)
+		{sipName_QCDEStyle,	&sipClass_QCDEStyle,	-1, 108},
+#else
+		{NULL,			NULL,			-1, 108},
+#endif
+#if QT_VERSION >= 220 && defined(SIP_FEATURE_Qt_STYLE_MOTIFPLUS)
+		{sipName_QMotifPlusStyle,	&sipClass_QMotifPlusStyle,	-1, 109},
+#else
+		{NULL,				NULL,				-1, 109},
+#endif
+#if QT_VERSION >= 220 && defined(SIP_FEATURE_Qt_STYLE_SGI)
+		{sipName_QSGIStyle,	&sipClass_QSGIStyle,	-1, -1},
+#else
+		{NULL,			NULL,			-1, -1},
+#endif
+#if defined(PYQT_STYLE_WINDOWSXP)
+		{sipName_QWindowsXPStyle,	&sipClass_QWindowsXPStyle,	-1, -1},
+#else
+		{NULL,				NULL,				-1, -1},
+#endif
+	};
+
+	int i = 0;
+
+	sipClass = NULL;
+
+	do
+	{
+		struct class_graph *cg = &graph[i];
+
+		if (cg->name != NULL && sipCpp->inherits(cg->name))
+		{
+			sipClass = *cg->type;
+			i = cg->yes;
+		}
+		else
+			i = cg->no;
+	}
+	while (i >= 0);
+%End
+
+	// This is really virtual.  With the way we are implementing it doesn't
+	// need to be and has the advantage that the C++ implementation can be
+	// used in %ConvertToSubClassCode to get the C++ name for Python
+	// sub-classes.  However, it is also means that C++ plugins can't get
+	// the true (Python) class name.
+	SIP_PYOBJECT className() const;
+%MethodCode
+		sipRes = sipClassName(sipSelf);
+%End
+
+%If (- Qt_3_0_0)
+	static QString tr(const char *) /AutoGen=Qt_TRANSLATION/;
+%End
+%If (Qt_2_2_0 - Qt_2_3_1)
+	// There was an apparent bug in moc prior to Qt v2.3.1 where this
+	// method wasn't automatically generated.
+
+	static QString tr(const char *,const char *);
+%End
+%If (Qt_2_3_1 - Qt_3_0_0)
+	static QString tr(const char *,const char *) /AutoGen=Qt_TRANSLATION/;
+%End
+%If (Qt_3_0_0 -)
+	// Note that tr() and trUtf8() are really static methods.  We pretend
+	// they aren't so that we can use self to get hold of the class name.
+	// We could mimic moc's behaviour more accurately by creating tr() and
+	// trUtf8() methods for a Python sub-class instance in the sub-class's
+	// ctor.
+
+	QString tr(const char *,const char * = 0);
+%MethodCode
+		PyObject *nmobj;
+
+		if ((nmobj = sipClassName(sipSelf)) == NULL)
+			sipIsErr = 1;
+		else
+		{
+			char *cname = PyString_AsString(nmobj);
+
+			Py_BEGIN_ALLOW_THREADS
+
+			if (cname && qApp)
+				sipRes = new QString(qApp -> translate(cname,a0,a1,QApplication::DefaultCodec));
+			else
+				sipRes = new QString(QString::fromLatin1(a0));
+
+			Py_END_ALLOW_THREADS
+
+			Py_DECREF(nmobj);
+		}
+%End
+
+	QString trUtf8(const char *,const char * = 0);
+%MethodCode
+		PyObject *nmobj;
+
+		if ((nmobj = sipClassName(sipSelf)) == NULL)
+			sipIsErr = 1;
+		else
+		{
+			char *cname = PyString_AsString(nmobj);
+
+			Py_BEGIN_ALLOW_THREADS
+
+			if (cname && qApp)
+				sipRes = new QString(qApp -> translate(cname,a0,a1,QApplication::UnicodeUTF8));
+			else
+				sipRes = new QString(QString::fromUtf8(a0));
+
+			Py_END_ALLOW_THREADS
+
+			Py_DECREF(nmobj);
+		}
+%End
+%End
+	virtual QMetaObject *metaObject() const /AutoGen/;
+	virtual bool event(QEvent *);
+	virtual bool eventFilter(QObject *,QEvent *);
+
+	bool isA(const char *) const;
+%MethodCode
+		// The Qt implementation doesn't know anything about Python
+		// sub-classes.  For SIP v4 we use the Python type's name.  For
+		// SIP v3 we use the broken Qt behaviour as it's deprecated and
+		// we want to keep things simple.
+
+#if SIP_VERSION >= 0x040000
+		sipRes = (strcmp(sipSelf -> ob_type -> tp_name,a0) == 0);
+#else
+		Py_BEGIN_ALLOW_THREADS
+		sipRes = sipCpp -> QObject::isA(a0);
+		Py_END_ALLOW_THREADS
+#endif
+%End
+
+	bool inherits(const char *) const;
+%MethodCode
+		// The Qt implementation doesn't know anything about Python
+		// sub-classes.  For SIP v4 we use the Python type's MRO.  For
+		// SIP v3 we use the broken Qt behaviour as it's deprecated and
+		// we want to keep things simple.
+
+#if SIP_VERSION >= 0x040000
+		PyObject *mro = sipSelf -> ob_type -> tp_mro;
+
+		sipRes = 0;
+
+		for (int i = 0; i < PyTuple_GET_SIZE(mro); ++i)
+			if (strcmp(((PyTypeObject *)PyTuple_GET_ITEM(mro,i)) -> tp_name,a0) == 0)
+			{
+				sipRes = 1;
+				break;
+			}
+#else
+		Py_BEGIN_ALLOW_THREADS
+		sipRes = sipCpp -> QObject::inherits(a0);
+		Py_END_ALLOW_THREADS
+#endif
+%End
+
+%If (- Qt_3_0_0)
+	QStringList superClasses(bool = 0) const;
+%End
+	const char *name() const;
+	const char *name(const char *) const;
+	virtual void setName(const char *);
+	bool isWidgetType() const;
+	bool highPriority() const;
+	bool signalsBlocked() const;
+	void blockSignals(bool);
+	int startTimer(int);
+	void killTimer(int);
+	void killTimers();
+%If (- Qt_3_0_0)
+	QObject *child(const char *,const char * = 0);
+%End
+%If (Qt_3_0_0 -)
+	QObject *child(const char *,const char * = 0,bool = 1);
+%End
+	const QObjectList *children() const;
+%If (Qt_2_1_0 -)
+	static const QObjectList *objectTrees();
+%End
+%If (- Qt_3_0_0)
+	QObjectList *queryList(char * = 0,char * = 0,bool = 1,bool = 1);
+%End
+
+%If (Qt_3_0_0 -)
+	QObjectList *queryList(char * = 0,char * = 0,bool = 1,bool = 1) const;
+%MethodCode
+		// The Qt implementation doesn't know anything about Python
+		// sub-classes.  For SIP v4 we get all classes and then use the
+		// Python type's MRO to weed out those we don't want.  For SIP
+		// v3 we use the broken Qt behaviour as it's deprecated and we
+		// want to keep things simple.
+
+#if SIP_VERSION >= 0x040000
+		sipRes = sipCpp -> QObject::queryList(0, a1, a2, a3);
+
+		if (a0 && sipRes)
+		{
+			QObject *o = sipRes -> first();
+
+			while (o)
+			{
+				bool remove = TRUE;
+				PyObject *pyo = sipConvertFromInstance(o, sipClass_QObject, 0);
+
+				if (pyo)
+				{
+					PyObject *mro = pyo -> ob_type -> tp_mro;
+
+					for (int i = 0; i < PyTuple_GET_SIZE(mro); ++i)
+						if (strcmp(((PyTypeObject *)PyTuple_GET_ITEM(mro,i)) -> tp_name,a0) == 0)
+						{
+							remove = FALSE;
+							break;
+						}
+
+					Py_DECREF(pyo);
+				}
+
+				if (remove)
+				{
+					sipRes -> remove();
+					o = sipRes -> current();
+				}
+				else
+					o = sipRes -> next();
+			}
+		}
+#else
+		Py_BEGIN_ALLOW_THREADS
+		sipRes = sipCpp -> QObject::queryList(a0, a1, a2, a3);
+		Py_END_ALLOW_THREADS
+#endif
+%End
+%End
+
+	virtual void insertChild(QObject * /Transfer/);
+	virtual void removeChild(QObject * /TransferBack/);
+	void installEventFilter(const QObject *);
+	void removeEventFilter(const QObject *);
+
+	static SIP_PYOBJECT connect(SIP_QOBJECT,SIP_SIGNAL,SIP_QOBJECT,SIP_SLOT);
+%MethodCode
+		sipRes = sipConnectRx(a0,a1,a2,a3,0);
+%End
+
+	static SIP_PYOBJECT connect(SIP_QOBJECT,SIP_SIGNAL,SIP_PYCALLABLE);
+%MethodCode
+		sipRes = sipConnectRx(a0,a1,a2,0,0);
+%End
+
+	SIP_PYOBJECT connect(SIP_QOBJECT,SIP_SIGNAL,SIP_SLOT) const;
+%MethodCode
+		sipRes = sipConnectRx(a0,a1,sipSelf,a2,0);
+%End
+
+	static SIP_PYOBJECT disconnect(SIP_QOBJECT,SIP_SIGNAL,SIP_QOBJECT,SIP_SLOT);
+%MethodCode
+		sipRes = sipDisconnectRx(a0,a1,a2,a3);
+%End
+
+	static SIP_PYOBJECT disconnect(SIP_QOBJECT,SIP_SIGNAL,SIP_PYCALLABLE);
+%MethodCode
+		sipRes = sipDisconnectRx(a0,a1,a2,0);
+%End
+
+//	bool disconnect(const char * = 0,const QObject * = 0,const char * = 0);
+//	bool disconnect(const QObject *,const char * = 0);
+	void dumpObjectTree();
+	void dumpObjectInfo();
+	QObject *parent() const;
+
+	void emit(SIP_SIGNAL,SIP_PYTUPLE);
+%MethodCode
+		if (pyqt3EmitSignal(sipSelf, a0, a1) < 0)
+			sipIsErr = 1;
+%End
+
+%If (Qt_PROPERTIES)
+%If (Qt_2_1_0 - Qt_3_0_0)
+	bool setProperty(const char *,const QVariant &);
+	QVariant property(const char *) const;
+%End
+%If (Qt_3_0_0 -)
+	virtual bool setProperty(const char *,const QVariant &);
+	virtual QVariant property(const char *) const;
+%End
+%End
+
+signals:
+	void destroyed();
+%If (Qt_3_0_0 -)
+	void destroyed(QObject *);
+%End
+
+public slots:
+%If (Qt_3_0_0 -)
+	void deleteLater();
+%End
+
+public:
+	// This is actually protected, but we never need to call the real
+	// method.
+	SIP_PYOBJECT sender();
+%MethodCode
+		sipRes = pyqt3GetSender();
+%End
+
+protected:
+	virtual void timerEvent(QTimerEvent *);
+	virtual void childEvent(QChildEvent *);
+%If (Qt_3_0_0 -)
+	virtual void customEvent(QCustomEvent *);
+%End
+
+private:
+	QObject(const QObject &);
+};
+
+
+SIP_PYOBJECT QT_TR_NOOP(SIP_PYOBJECT);
+%MethodCode
+	Py_INCREF(a0);
+	sipRes = a0;
+%End
+
+
+SIP_PYOBJECT QT_TRANSLATE_NOOP(SIP_PYOBJECT,SIP_PYOBJECT);
+%MethodCode
+	Py_INCREF(a1);
+	sipRes = a1;
+%End
+
+%End
+
+
+%If (- Qt_2_00)
+
+class QObject
+{
+%TypeHeaderCode
+#include <qobject.h>
+%End
+
+public:
+	QObject(QObject * /TransferThis/ = 0,const char * = 0);
+
+%ConvertToSubClassCode
+	// The table of Python class objects indexed by their names.  The table
+	// must be sorted by name.
+
+	static sipStringTypeClassMap map[] = {
+		{sipName_QAccel,		&sipClass_QAccel},
+		{sipName_QApplication,		&sipClass_QApplication},
+		{sipName_QBoxLayout,		&sipClass_QBoxLayout},
+		{sipName_QButton,		&sipClass_QButton},
+		{sipName_QButtonGroup,		&sipClass_QButtonGroup},
+		{sipName_QCheckBox,		&sipClass_QCheckBox},
+#if defined(SIP_FEATURE_Qt_CLIPBOARD)
+		{sipName_QClipboard,		&sipClass_QClipboard},
+#endif
+		{sipName_QComboBox,		&sipClass_QComboBox},
+		{sipName_QDialog,		&sipClass_QDialog},
+		{sipName_QDoubleValidator,	&sipClass_QDoubleValidator},
+		{sipName_QDragObject,		&sipClass_QDragObject},
+#if defined(SIP_FEATURE_Qt_FILEDIALOG)
+		{sipName_QFileDialog,		&sipClass_QFileDialog},
+		{sipName_QFileIconProvider,	&sipClass_QFileIconProvider},
+#endif
+		{sipName_QFrame,		&sipClass_QFrame},
+		{sipName_QGridLayout,		&sipClass_QGridLayout},
+		{sipName_QGroupBox,		&sipClass_QGroupBox},
+		{sipName_QHBoxLayout,		&sipClass_QHBoxLayout},
+		{sipName_QHeader,		&sipClass_QHeader},
+		{sipName_QImageDrag,		&sipClass_QImageDrag},
+		{sipName_QIntValidator,		&sipClass_QIntValidator},
+		{sipName_QLCDNumber,		&sipClass_QLCDNumber},
+		{sipName_QLabel,		&sipClass_QLabel},
+		{sipName_QLayout,		&sipClass_QLayout},
+		{sipName_QLineEdit,		&sipClass_QLineEdit},
+		{sipName_QListBox,		&sipClass_QListBox},
+		{sipName_QListView,		&sipClass_QListView},
+		{sipName_QMainWindow,		&sipClass_QMainWindow},
+		{sipName_QMenuBar,		&sipClass_QMenuBar},
+#if defined(SIP_FEATURE_Qt_MESSAGEBOX)
+		{sipName_QMessageBox,		&sipClass_QMessageBox},
+#endif
+		{sipName_QMultiLineEdit,	&sipClass_QMultiLineEdit},
+		{sipName_QPopupMenu,		&sipClass_QPopupMenu},
+#if defined(WS_X11) && defined(SIP_FEATURE_Qt_PRINTDIALOG)
+		{sipName_QPrintDialog,		&sipClass_QPrintDialog},
+#endif
+		{sipName_QProgressBar,		&sipClass_QProgressBar},
+#if defined(SIP_FEATURE_Qt_PROGRESSDIALOG)
+		{sipName_QProgressDialog,	&sipClass_QProgressDialog},
+#endif
+		{sipName_QPushButton,		&sipClass_QPushButton},
+		{sipName_QRadioButton,		&sipClass_QRadioButton},
+		{sipName_QScrollBar,		&sipClass_QScrollBar},
+		{sipName_QScrollView,		&sipClass_QScrollView},
+		{sipName_QSlider,		&sipClass_QSlider},
+		{sipName_QSocketNotifier,	&sipClass_QSocketNotifier},
+		{sipName_QSpinBox,		&sipClass_QSpinBox},
+#if defined(SIP_FEATURE_Qt_SPLITTER)
+		{sipName_QSplitter,		&sipClass_QSplitter},
+#endif
+		{sipName_QStatusBar,		&sipClass_QStatusBar},
+		{sipName_QStoredDrag,		&sipClass_QStoredDrag},
+		{sipName_QTabBar,		&sipClass_QTabBar},
+		{sipName_QTextDrag,		&sipClass_QTextDrag},
+		{sipName_QTimer,		&sipClass_QTimer},
+		{sipName_QToolBar,		&sipClass_QToolBar},
+		{sipName_QToolButton,		&sipClass_QToolButton},
+		{sipName_QToolTipGroup,		&sipClass_QToolTipGroup},
+		{sipName_QVBoxLayout,		&sipClass_QVBoxLayout},
+		{sipName_QValidator,		&sipClass_QValidator},
+		{sipName_QWidget,		&sipClass_QWidget},
+		{sipName_QWidgetStack,		&sipClass_QWidgetStack}
+	};
+
+	sipClass = sipMapStringToClass(sipCpp -> className(),map,sizeof (map)/sizeof (map[0]));
+%End
+
+	static SIP_PYOBJECT connect(SIP_QOBJECT,SIP_SIGNAL,SIP_QOBJECT,SIP_SLOT);
+%MethodCode
+		sipRes = sipConnectRx(a0,a1,a2,a3,0);
+%End
+
+	static SIP_PYOBJECT connect(SIP_QOBJECT,SIP_SIGNAL,SIP_PYCALLABLE);
+%MethodCode
+		sipRes = sipConnectRx(a0,a1,a2,0,0);
+%End
+
+	static SIP_PYOBJECT disconnect(SIP_QOBJECT,SIP_SIGNAL,SIP_QOBJECT,SIP_SLOT);
+%MethodCode
+		sipRes = sipDisconnectRx(a0,a1,a2,a3);
+%End
+
+	static SIP_PYOBJECT disconnect(SIP_QOBJECT,SIP_SIGNAL,SIP_PYCALLABLE);
+%MethodCode
+		sipRes = sipDisconnectRx(a0,a1,a2,0);
+%End
+
+	virtual bool event(QEvent *);
+	virtual bool eventFilter(QObject *,QEvent *);
+	const char *tr(const char *) const;
+	virtual QMetaObject *metaObject() const /AutoGen/;
+
+	// This is actually virtual.  However, with the way we are implementing
+	// it we can ignore it.
+	SIP_PYOBJECT className() const;
+%MethodCode
+		sipRes = sipClassName(sipSelf);
+%End
+
+	bool isA(const char *) const;
+	bool inherits(const char *) const;
+	const char *name() const;
+	const char *name(const char *) const;
+	void setName(const char *);
+	bool isWidgetType() const;
+	bool highPriority() const;
+	bool signalsBlocked() const;
+	void blockSignals(bool);
+	int startTimer(int);
+	void killTimer(int);
+	void killTimers();
+	const QObjectList *children() const;
+	QObjectList *queryList(char * = 0,char * = 0,bool = 1,bool = 1);
+	void insertChild(QObject * /Transfer/);
+	void removeChild(QObject * /TransferBack/);
+	void installEventFilter(const QObject *);
+	void removeEventFilter(const QObject *);
+//	bool connect(QObject *,const char *,const char *);
+//	bool disconnect(const char * = 0,const QObject * = 0,const char * = 0);
+//	bool disconnect(const QObject *,const char * = 0);
+	void dumpObjectTree();
+	void dumpObjectInfo();
+	QObject *parent() const;
+
+	void emit(SIP_SIGNAL,SIP_PYTUPLE);
+%MethodCode
+		if (sipEmitSignal(sipSelf,a0,a1) < 0)
+			sipIsErr = 1;
+%End
+
+signals:
+	void destroyed();
+
+public:
+	// This is actually protected, but we never need to call the real
+	// method.
+	SIP_PYOBJECT sender();
+%MethodCode
+		sipRes = pyqt3GetSender();
+%End
+
+protected:
+	virtual void timerEvent(QTimerEvent *);
+
+private:
+	QObject(const QObject &);
+};
+
+%End
+
+
+SIP_PYOBJECT SLOT(const char *);
+%MethodCode
+	if (!a0)
+	{
+		PyErr_Format(PyExc_TypeError,"qt.SLOT() slot name cannot be None");
+		sipIsErr = 1;
+	}
+	else
+	{
+		int len = strlen(a0);
+
+		if ((sipRes = PyString_FromStringAndSize(NULL,1 + len)) == NULL)
+			sipIsErr = 1;
+		else
+		{
+			char *dp = PyString_AS_STRING(sipRes);
+
+			*dp++ = '1';
+
+			memcpy(dp,a0,len + 1);
+		}
+	}
+%End
+
+
+SIP_PYOBJECT SIGNAL(const char *);
+%MethodCode
+	if (!a0)
+	{
+		PyErr_Format(PyExc_TypeError,"qt.SIGNAL() signal cannot be None");
+		sipIsErr = 1;
+	}
+	else
+	{
+		int len = strlen(a0);
+
+		if ((sipRes = PyString_FromStringAndSize(NULL,1 + len)) == NULL)
+			sipIsErr = 1;
+		else
+		{
+			char *dp = PyString_AS_STRING(sipRes);
+
+			*dp++ = '2';
+
+			memcpy(dp,a0,len + 1);
+		}
+	}
+%End
+
+
+SIP_PYOBJECT PYSIGNAL(const char *);
+%MethodCode
+	if (!a0)
+	{
+		PyErr_Format(PyExc_TypeError,"qt.PYSIGNAL() signal cannot be None");
+		sipIsErr = 1;
+	}
+	else
+	{
+		int len = strlen(a0);
+
+		if ((sipRes = PyString_FromStringAndSize(NULL,1 + len)) == NULL)
+			sipIsErr = 1;
+		else
+		{
+			char *dp = PyString_AS_STRING(sipRes);
+
+			*dp++ = '9';
+
+			memcpy(dp,a0,len + 1);
+		}
+	}
+%End
+
+
+%ModuleHeaderCode
+
+int pyqt3EmitSignal(PyObject *self, const char *sig, PyObject *sigargs);
+PyObject *pyqt3GetSender();
+
+%End
+
+
+// This is the Qt support code for SIP v4.4 and later.
+%ModuleCode
+
+#include <string.h>
+
+#include <qobject.h>
+#include <qvariant.h>
+#include <qmetaobject.h>
+#include <private/qucom_p.h>
+#include <private/qucomextra_p.h>
+
+
+// These optional parts of the legacy Qt support API for SIP are implemented.
+#undef sipQtEmitSignal
+#undef sipQtConnectPySignal
+#undef sipQtDisconnectPySignal
+
+
+// Declare explicit C linkage.
+extern "C"
+{
+	static void *sipQtCreateUniversalSlot(sipWrapper *, const char *,
+            PyObject *, const char *, const char **, int);
+	static void sipQtDestroyUniversalSlot(void *);
+	static void *sipQtFindSlot(void *, const char *, PyObject *, const char *,
+            const char **);
+	static int sipQtConnect(void *, const char *, void *, const char *, int);
+	static int sipQtDisconnect(void *, const char *, void *, const char *);
+	static int sipQtSameSignalSlotName(const char *, const char *);
+    static sipSlot *sipQtFindSipslot(void *, void **);
+    static int sipQtEmitSignal(PyObject *, const char *, PyObject *);
+    static int sipQtConnectPySignal(PyObject *, const char *, PyObject *,
+            const char *);
+    static void sipQtDisconnectPySignal(PyObject *, const char *,
+            PyObject *, const char *);
+}
+
+
+extern "C" {
+
+// The meta-type for PyQt classes.  It is just a marker type so that we can
+// safely cast to get access to PyQt3-specific data structures.
+PyTypeObject pyqtWrapperType_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                      /* ob_size */
+    "qt.pyqtWrapperType",   /* tp_name */
+    sizeof (sipWrapperType),    /* tp_basicsize */
+    0,                      /* tp_itemsize */
+    0,                      /* tp_dealloc */
+    0,                      /* tp_print */
+    0,                      /* tp_getattr */
+    0,                      /* tp_setattr */
+    0,                      /* tp_compare */
+    0,                      /* tp_repr */
+    0,                      /* tp_as_number */
+    0,                      /* tp_as_sequence */
+    0,                      /* tp_as_mapping */
+    0,                      /* tp_hash */
+    0,                      /* tp_call */
+    0,                      /* tp_str */
+    0,                      /* tp_getattro */
+    0,                      /* tp_setattro */
+    0,                      /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,   /* tp_flags */
+    0,                      /* tp_doc */
+    0,                      /* tp_traverse */
+    0,                      /* tp_clear */
+    0,                      /* tp_richcompare */
+    0,                      /* tp_weaklistoffset */
+    0,                      /* tp_iter */
+    0,                      /* tp_iternext */
+    0,                      /* tp_methods */
+    0,                      /* tp_members */
+    0,                      /* tp_getset */
+    0,                      /* tp_base */
+    0,                      /* tp_dict */
+    0,                      /* tp_descr_get */
+    0,                      /* tp_descr_set */
+    0,                      /* tp_dictoffset */
+    0,                      /* tp_init */
+    0,                      /* tp_alloc */
+    0,                      /* tp_new */
+    0,                      /* tp_free */
+    0,                      /* tp_is_gc */
+    0,                      /* tp_bases */
+    0,                      /* tp_mro */
+    0,                      /* tp_cache */
+    0,                      /* tp_subclasses */
+    0,                      /* tp_weaklist */
+    0,                      /* tp_del */
+#if PY_VERSION_HEX >= 0x02060000
+    0,                      /* tp_version_tag */
+#endif
+};
+
+
+/*
+ * An entry in a linked list of slots.
+ */
+typedef struct _pyqt3SlotList {
+    /* The receiver. */
+    sipSlot rx;
+
+    /* Next in the list. */
+    struct _pyqt3SlotList *next;
+} pyqt3SlotList;
+
+
+/*
+ * A Python signal.
+ */
+typedef struct _pyqt3PySig {
+    /* The name of the signal. */
+    char *name;
+
+    /* The list of receivers. */
+    pyqt3SlotList *rxlist;
+
+    /* Next in the list. */
+    struct _pyqt3PySig *next;
+} pyqt3PySig;
+
+
+/*
+ * The C++ wrapper object used by PyQt3.
+ */
+typedef struct _pyqtWrapper {
+    /* The super-type. */
+    sipWrapper super;
+
+    /* The list of Python signals. */
+    pyqt3PySig *pySigList;
+} pyqtWrapper;
+
+
+/*
+ * Clear any slots connected to any Python signals.
+ */
+static void clear_py_signals_slots(pyqtWrapper *pw)
+{
+    pyqt3PySig *ps;
+
+    for (ps = pw->pySigList; ps != NULL; ps = ps->next)
+    {
+        pyqt3SlotList *psrx;
+
+        for (psrx = ps->rxlist; psrx != NULL; psrx = psrx->next)
+            sipClearAnySlotReference(&psrx->rx);
+    }
+}
+
+
+/*
+ * Find the given Python signal.
+ */
+static pyqt3PySig *find_py_signal(pyqtWrapper *pw, const char *sig)
+{
+    pyqt3PySig *ps;
+
+    for (ps = pw->pySigList; ps != NULL; ps = ps->next)
+        if (sipQtSameSignalSlotName(ps->name, sig))
+            return ps;
+
+    return 0;
+}
+
+
+/*
+ * Free an slot list entry.
+ */
+static void free_slot_list(pyqt3SlotList *sl)
+{
+    sipFreeSipslot(&sl->rx);
+    sipFree(sl);
+}
+
+
+/*
+ * The instance clear slot.
+ */
+static int pyqtWrapper_clear(pyqtWrapper *self)
+{
+    clear_py_signals_slots(self);
+
+    return sipWrapper_Type->tp_clear((PyObject *)self);
+}
+
+
+/*
+ * The instance dealloc slot.
+ */
+static void pyqtWrapper_dealloc(pyqtWrapper *self)
+{
+    clear_py_signals_slots(self);
+
+    while (self->pySigList != NULL)
+    {
+        pyqt3PySig *ps;
+        pyqt3SlotList *psrx;
+
+        /* Take this one out of the list. */
+        ps = self->pySigList;
+        self->pySigList = ps->next;
+
+        while ((psrx = ps->rxlist) != NULL)
+        {
+            ps->rxlist = psrx->next;
+            free_slot_list(psrx);
+        }
+
+        sipFree(ps->name);
+        sipFree(ps);
+    }
+
+    sipWrapper_Type->tp_dealloc((PyObject *)self);
+}
+
+
+/*
+ * The instance traverse slot.
+ */
+static int pyqtWrapper_traverse(pyqtWrapper *self, visitproc visit, void *arg)
+{
+    int vret;
+    pyqt3PySig *ps;
+
+    if ((vret = sipWrapper_Type->tp_traverse((PyObject *)self, visit, arg)) != 0)
+        return vret;
+
+    for (ps = self->pySigList; ps != NULL; ps = ps->next)
+    {
+        pyqt3SlotList *psrx;
+
+        for (psrx = ps->rxlist; psrx != NULL; psrx = psrx->next)
+            if ((vret = sipVisitSlot(&psrx->rx, visit, arg)) != 0)
+                return vret;
+    }
+
+    return 0;
+}
+
+
+static sipWrapperType pyqtWrapper_Type = {
+#if !defined(STACKLESS)
+    {
+#endif
+        {
+            PyObject_HEAD_INIT(&pyqtWrapperType_Type)
+            0,              /* ob_size */
+            "qt.pyqtWrapper",   /* tp_name */
+            sizeof (pyqtWrapper),   /* tp_basicsize */
+            0,              /* tp_itemsize */
+            (destructor)pyqtWrapper_dealloc,    /* tp_dealloc */
+            0,              /* tp_print */
+            0,              /* tp_getattr */
+            0,              /* tp_setattr */
+            0,              /* tp_compare */
+            0,              /* tp_repr */
+            0,              /* tp_as_number */
+            0,              /* tp_as_sequence */
+            0,              /* tp_as_mapping */
+            0,              /* tp_hash */
+            0,              /* tp_call */
+            0,              /* tp_str */
+            0,              /* tp_getattro */
+            0,              /* tp_setattro */
+            0,              /* tp_as_buffer */
+            Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,  /* tp_flags */
+            0,              /* tp_doc */
+            (traverseproc)pyqtWrapper_traverse, /* tp_traverse */
+            (inquiry)pyqtWrapper_clear, /* tp_clear */
+            0,              /* tp_richcompare */
+            0,              /* tp_weaklistoffset */
+            0,              /* tp_iter */
+            0,              /* tp_iternext */
+            0,              /* tp_methods */
+            0,              /* tp_members */
+            0,              /* tp_getset */
+            0,              /* tp_base */
+            0,              /* tp_dict */
+            0,              /* tp_descr_get */
+            0,              /* tp_descr_set */
+            0,              /* tp_dictoffset */
+            0,              /* tp_init */
+            0,              /* tp_alloc */
+            0,              /* tp_new */
+            0,              /* tp_free */
+            0,              /* tp_is_gc */
+            0,              /* tp_bases */
+            0,              /* tp_mro */
+            0,              /* tp_cache */
+            0,              /* tp_subclasses */
+            0,              /* tp_weaklist */
+            0,              /* tp_del */
+#if PY_VERSION_HEX >= 0x02060000
+            0,              /* tp_version_tag */
+#endif
+        },
+#if !defined(STACKLESS)
+    },
+#endif
+    0,
+    0,
+    0
+};
+
+};
+
+
+// This enumerates the different dynamic signal argument types.
+enum pyqt3SigArgType {
+    unknown_sat,
+    char_sat,
+    uchar_sat,
+    string_sat,
+    ustring_sat,
+    short_sat,
+    ushort_sat,
+    int_sat,
+    uint_sat,
+    long_sat,
+    ulong_sat,
+    longlong_sat,
+    ulonglong_sat,
+    float_sat,
+    double_sat,
+    enum_sat,
+    bool_sat,
+    void_sat,
+    class_sat,
+    classp_sat,
+    mtype_sat,
+    mtypep_sat,
+    qvariant_sat,
+    qvariantp_sat,
+    pyobject_sat,
+    schar_sat,
+    sstring_sat,
+    wchar_sat,
+    wstring_sat
+};
+
+
+// This defines a single dynamic signal argument type.
+struct pyqt3SigArg
+{
+    // The type.
+    pyqt3SigArgType atype;
+
+    union {
+        // The Python type for classes.
+        sipWrapperType *wt;
+
+        // The data for mapped types.
+        const sipTypeDef *mt;
+
+        // The Python type for named enums.
+        PyTypeObject *et;
+    } u;
+};
+
+
+// A parsed signal signature.
+struct pyqt3Signature {
+    // The number of arguments.
+    int sg_nrargs;
+
+    // The parsed arguments (heap).
+    pyqt3SigArg *sg_args;
+
+    // The unparsed signature (heap).
+    char *sg_signature;
+
+    // The next in the list.
+    pyqt3Signature *sg_next;
+};
+
+
+// A connection to a universal slot.
+struct pyqt3SlotConnection
+{
+    // The transmitter QObject.
+    void *sc_transmitter;
+
+    // The parsed signature.
+    const pyqt3Signature *sc_signature;
+
+    // The slot.
+    sipSlot sc_slot;
+};
+
+
+// This class is used as a slot on behalf of connections to a Python callable.
+// It is derived from QObject but is not run through moc.  Instead the normal
+// moc-generated methods are handwritten in order to implement a universal
+// slot.  This requires some knowledge of the internal implementation of
+// signals and slots but it is likely that they will only change between major
+// Qt versions.
+class UniversalSlot : public QObject
+{
+public:
+	UniversalSlot(QObject *qtx, pyqt3SlotConnection *conn, const char **member);
+	~UniversalSlot();
+
+	virtual QMetaObject *metaObject() const
+	{
+		return staticMetaObject();
+	}
+
+	virtual bool qt_invoke(int, QUObject *args);
+	static QMetaObject *staticMetaObject();
+
+	static QObject *lastSender;
+
+	static UniversalSlot *unislots;
+	UniversalSlot *nextus, *prevus;
+	pyqt3SlotConnection conn;
+
+private:
+	static QMetaObject *metaObj;
+};
+
+
+// Create a universal slot.  Note that this will leak if there is no signal
+// transmitter (ie. no parent) - QTimer.singleShot() for example.
+UniversalSlot::UniversalSlot(QObject *qtx, pyqt3SlotConnection *connection, const char **member) : QObject()
+{
+	// Save the connection.
+	conn = *connection;
+
+	// Detect when the transmitter is destroyed.
+	if (qtx)
+		connect(qtx, SIGNAL(destroyed(QObject *)), SLOT(deleteLater()));
+
+	// Return the slot to connect to.
+	*member = SLOT(unislot());
+
+	// Add this one to the global list.
+	nextus = unislots;
+
+	if (nextus)
+		nextus -> prevus = this;
+
+	prevus = 0;
+	unislots = this;
+}
+
+
+// Destroy a universal slot.
+UniversalSlot::~UniversalSlot()
+{
+    SIP_BLOCK_THREADS
+	sipFreeSipslot(&conn.sc_slot);
+    SIP_UNBLOCK_THREADS
+
+	// Remove this one from the global list.
+	if (nextus)
+		nextus -> prevus = prevus;
+
+	if (prevus)
+		prevus -> nextus = nextus;
+	else
+		unislots = nextus;
+}
+
+
+// The last Python signal sender.
+static PyObject *py_sender = 0;
+
+
+QMetaObject *UniversalSlot::metaObj = 0;
+
+#if QT_VERSION >= 0x030100
+static QMetaObjectCleanUp cleanUp_UniversalSlot("UniversalSlot", &UniversalSlot::staticMetaObject);
+#else
+static QMetaObjectCleanUp cleanUp_UniversalSlot;
+#endif
+
+QObject *UniversalSlot::lastSender = 0;
+UniversalSlot *UniversalSlot::unislots = 0;
+
+
+QMetaObject *UniversalSlot::staticMetaObject()
+{
+	if (metaObj)
+		return metaObj;
+
+	// Define a single slot that takes no arguments and so will accept any
+	// connection.
+	static const QUMethod slot = {"unislot", 0, 0};
+	static const QMetaData slot_tbl[] = {
+		{"unislot()", &slot, QMetaData::Public}
+	};
+
+	metaObj = QMetaObject::new_metaobject(
+			"UniversalSlot", QObject::staticMetaObject(),
+			slot_tbl, 1,
+			0, 0,
+#ifndef QT_NO_PROPERTIES
+			0, 0,
+			0, 0,
+#endif
+			0, 0);
+
+	cleanUp_UniversalSlot.setMetaObject(metaObj);
+
+	return metaObj;
+}
+
+
+bool UniversalSlot::qt_invoke(int id, QUObject *qargs)
+{
+	if (id - staticMetaObject()->slotOffset() != 0)
+		return QObject::qt_invoke(id, qargs);
+
+	bool ok = TRUE;
+	const pyqt3Signature *psig = conn.sc_signature;
+	QVariant *qv;
+
+	// Save in case it is asked for later.
+	lastSender = const_cast<QObject *>(sender());
+
+	// If the sender was a QSignal then the single argument will be wrapped
+	// in a QVariant instance.  At the moment we handle int argument as
+	// that is all that is needed by PyQt (and PyKDE).
+	if (lastSender->inherits("QSignal"))
+		qv = &static_QUType_QVariant.get(qargs + 1);
+	else
+		qv = 0;
+
+#ifdef WITH_THREAD
+	PyGILState_STATE state = PyGILState_Ensure();
+#endif
+
+	PyObject *argtup = PyTuple_New(psig->sg_nrargs);
+
+	if (!argtup)
+		ok = FALSE;
+	else
+	{
+		for (int a = 0; a < psig->sg_nrargs; ++a)
+		{
+			PyObject *arg;
+
+			++qargs;
+
+			switch (psig->sg_args[a].atype)
+			{
+			case char_sat:
+			case schar_sat:
+			case uchar_sat:
+				arg = PyString_FromStringAndSize((char *)static_QUType_ptr.get(qargs), 1);
+				break;
+
+			case string_sat:
+			case sstring_sat:
+			case ustring_sat:
+				arg = PyString_FromString((char *)static_QUType_ptr.get(qargs));
+				break;
+
+			case short_sat:
+				arg = PyInt_FromLong(*(short *)static_QUType_ptr.get(qargs));
+				break;
+
+			case ushort_sat:
+				arg = PyLong_FromUnsignedLong(*(unsigned short *)static_QUType_ptr.get(qargs));
+				break;
+
+			case int_sat:
+				if (qv)
+					arg = PyInt_FromLong(qv -> asInt());
+				else
+					arg = PyInt_FromLong(static_QUType_int.get(qargs));
+				break;
+
+			case uint_sat:
+				arg = PyLong_FromUnsignedLong(*(unsigned *)static_QUType_ptr.get(qargs));
+				break;
+
+			case long_sat:
+				arg = PyLong_FromLong(*(long *)static_QUType_ptr.get(qargs));
+				break;
+
+			case ulong_sat:
+				arg = PyLong_FromUnsignedLong(*(unsigned long *)static_QUType_ptr.get(qargs));
+				break;
+
+			case longlong_sat:
+				arg = PyLong_FromLongLong(*(PY_LONG_LONG *)static_QUType_ptr.get(qargs));
+				break;
+
+			case ulonglong_sat:
+				arg = PyLong_FromUnsignedLongLong(*(unsigned PY_LONG_LONG *)static_QUType_ptr.get(qargs));
+				break;
+
+			case float_sat:
+				arg = PyFloat_FromDouble(*(float *)static_QUType_ptr.get(qargs));
+				break;
+
+			case double_sat:
+				arg = PyFloat_FromDouble(static_QUType_double.get(qargs));
+				break;
+
+			case enum_sat:
+				arg = sipConvertFromNamedEnum(*(int *)static_QUType_ptr.get(qargs), psig->sg_args[a].u.et);
+				break;
+
+			case bool_sat:
+				arg = PyInt_FromLong(static_QUType_bool.get(qargs));
+				break;
+
+			case void_sat:
+				arg = sipConvertFromVoidPtr((void *)static_QUType_ptr.get(qargs));
+				break;
+
+			case class_sat:
+			case classp_sat:
+				arg = sipConvertFromInstance((void *)static_QUType_ptr.get(qargs),psig->sg_args[a].u.wt,0);
+				break;
+
+			case mtype_sat:
+			case mtypep_sat:
+				arg = sipConvertFromMappedType((void *)static_QUType_ptr.get(qargs),psig->sg_args[a].u.mt,0);
+				break;
+
+			case qvariant_sat:
+			case qvariantp_sat:
+				arg = sipConvertFromInstance((void *)&static_QUType_QVariant.get(qargs),sipClass_QVariant,0);
+				break;
+
+			case pyobject_sat:
+				arg = (PyObject *)static_QUType_ptr.get(qargs);
+				break;
+
+			default:
+				arg = Py_NotImplemented;
+				Py_INCREF(Py_NotImplemented);
+			}
+
+			PyTuple_SET_ITEM(argtup, a, arg);
+		}
+
+		// Dispatch to the real slot.
+		if (ok)
+        {
+		    PyObject *res = sipInvokeSlot(&conn.sc_slot, argtup);
+
+            if (res)
+                Py_DECREF(res);
+            else
+			    ok = FALSE;
+        }
+
+		Py_DECREF(argtup);
+	}
+
+	if (!ok)
+		PyErr_Print();
+
+#ifdef WITH_THREAD
+	PyGILState_Release(state);
+#endif
+
+	return ok;
+}
+
+
+static pyqt3Signature *parseSignature(const char *sig);
+static void parseType(const char *type, pyqt3SigArg *arg);
+
+
+// Factory function to create a universal slot instance.  Returns a pointer to
+// the instance or 0 if there was an error.
+static void *sipQtCreateUniversalSlot(sipWrapper *tx, const char *sig,
+        PyObject *rxObj, const char *slot, const char **member, int)
+{
+    pyqt3SlotConnection conn;
+
+    /* Initialise the connection. */
+    conn.sc_transmitter = (tx ? sipGetCppPtr((sipSimpleWrapper *)tx, 0) : 0);
+
+    /* Save the real slot. */
+    if (sipSaveSlot(&conn.sc_slot, rxObj, slot) < 0)
+        return 0;
+
+    /* Parse the signature and create the universal slot. */
+    if ((conn.sc_signature = parseSignature(sig)) == NULL)
+    {
+        sipFreeSipslot(&conn.sc_slot);
+        return 0;
+    }
+
+	QObject *qtx = 0;
+
+	// See if the transmitter is a QObject in which case we will connect
+	// to it's destroyed signal so that the universal slot can be destroyed
+	// at the same time.  (Note that we used to do this by making the
+	// universal slot a child of the transmitter.  This doesn't work as
+	// expected because QWidget destroys its children before emitting the
+	// destroyed signal.)
+	if (tx && PyObject_TypeCheck((PyObject *)tx, (PyTypeObject *)sipClass_QObject))
+		qtx = reinterpret_cast<QObject *>(conn.sc_transmitter);
+
+	return new UniversalSlot(qtx, &conn, member);
+}
+
+
+// Parse the signal arguments for a connection.
+static pyqt3Signature *parseSignature(const char *sig)
+{
+    static pyqt3Signature *psig_list = NULL;
+    pyqt3Signature *psig;
+    const char *sp, *ep;
+
+    // First see if it has already been parsed.  Note that both sides of a
+    // connection will probably be parsed twice because the function names will
+    // be different even though the signatures will probably be the same.  We
+    // could be more clever, the most saving is when repeatedly emitting a
+    // signal for which this is sufficient.
+    for (psig = psig_list; psig != NULL; psig = psig->sg_next)
+        if (sipQtSameSignalSlotName(psig->sg_signature, sig))
+            return psig;
+
+    // Create a new one including space for the copy of the signature.
+    if ((psig = (pyqt3Signature *)sipMalloc(sizeof (pyqt3Signature) + strlen(sig) + 1)) == NULL)
+        return NULL;
+
+    psig->sg_signature = (char *)&psig[1];
+    psig->sg_nrargs = 0;
+    psig->sg_args = 0;
+
+    // Find the start and end of the arguments.
+    sp = strchr(sig, '(');
+    ep = strrchr(sig, ')');
+
+    // If the signal isn't well formed we assume Qt will pick it up.
+    if (sp && ep && sp < ep)
+    {
+        // Copy the signature arguments while counting them and removing
+        // non-significant spaces.  Each argument is left as a '\0' terminated
+        // string.
+        char *dp = psig->sg_signature;
+        int depth = 0, nrcommas = 0, argstart = TRUE;
+
+        for (;;)
+        {
+            char ch = *++sp;
+
+            if (strchr(",*&)<>", ch))
+            {
+                // Backup over any previous trailing space.
+                if (dp > psig->sg_signature && dp[-1] == ' ')
+                    --dp;
+
+                if (sp == ep)
+                {
+                    *dp = '\0';
+                    break;
+                }
+
+                if (ch == ',' && depth == 0)
+                {
+                    *dp++ = '\0';
+                    ++nrcommas;
+                    argstart = TRUE;
+                }
+                else
+                {
+                    *dp++ = ch;
+
+                    // Make sure commas in template arguments are ignored.
+                    if (ch == '<')
+                        ++depth;
+                    else if (ch == '>')
+                        --depth;
+                }
+            }
+            else if (ch == ' ')
+            {
+                // Ignore leading and multiple spaces.
+                if (!argstart && dp[-1] != ' ')
+                    *dp++ = ch;
+            }
+            else
+            {
+                *dp++ = ch;
+                argstart = FALSE;
+            }
+        }
+
+        // Handle the arguments now they are in a normal form.
+        if (*psig->sg_signature)
+        {
+            char *arg = psig->sg_signature;
+            int a;
+
+            // Allocate the space.
+            psig->sg_nrargs = nrcommas + 1;
+
+            if ((psig->sg_args = (pyqt3SigArg *)sipMalloc(sizeof (pyqt3SigArg) * psig->sg_nrargs)) == NULL)
+            {
+                sipFree(psig);
+                return NULL;
+            }
+
+            for (a = 0; a < psig->sg_nrargs; ++a)
+            {
+                parseType(arg, &psig->sg_args[a]);
+
+                // Move to the start of the next argument.
+                arg += strlen(arg) + 1;
+            }
+        }
+    }
+
+    // Make a deep copy of the signal.
+    strcpy(psig->sg_signature, sig);
+
+    // Add it to the list so it can be re-used.
+    psig->sg_next = psig_list;
+    psig_list = psig;
+
+    return psig;
+}
+
+
+// Parse a single type.
+static void parseType(const char *type, pyqt3SigArg *arg)
+{
+    size_t btlen = 0;
+    int unsup, isref = FALSE, indir = 0;
+    const char *ep;
+    pyqt3SigArgType sat = unknown_sat;
+
+    // Find the start of the significant part of the type.
+    if (strncmp(type, "const ", 6) == 0)
+        type += 6;
+
+    // Find the length of the base type, the number of indirections and if it
+    // is a reference.
+    for (ep = type; *ep; ++ep)
+        if (*ep == '&')
+            isref = TRUE;
+        else if (*ep == '*')
+            ++indir;
+        else
+            ++btlen;
+
+    // Extract the base type as a separate string.
+    char type_str[btlen + 1];
+
+    strncpy(type_str, type, btlen);
+    type_str[btlen] = '\0';
+
+    // Resolve any typedef which may mean more indirection.
+    type = sipResolveTypedef(type_str);
+
+    // See if we need to make another copy.
+    bool copy = false;
+
+    if (type)
+    {
+        btlen = strlen(type);
+
+        // Remove any additional indirection.
+        while (btlen)
+        {
+            if (type[--btlen] == '*')
+            {
+                copy = true;
+                ++indir;
+            }
+        }
+    }
+    else
+        type = type_str;
+
+    // Make sure this doesn't go out of scope while it is being used.
+    char base_type_str[btlen + 1];
+
+    if (copy)
+    {
+        // Extract the base type again.
+        strncpy(base_type_str, type, btlen);
+        base_type_str[btlen] = '\0';
+        type = base_type_str;
+    }
+
+    // Assume that anything other than a base type is unsupported.
+    unsup = (isref || indir);
+
+    // Parse the base type.
+    switch (btlen)
+    {
+    case 3:
+        if (strcmp(type, "int") == 0)
+            sat = int_sat;
+        break;
+
+    case 4:
+        if (strcmp(type, "bool") == 0)
+            sat = bool_sat;
+        else if (strcmp(type, "long") == 0)
+            sat = long_sat;
+        else if (strcmp(type, "char") == 0)
+        {
+            sat = (indir ? string_sat : char_sat);
+            unsup = (isref || indir > 1);
+        }
+        else if (strcmp(type, "void") == 0)
+        {
+            sat = void_sat;
+            unsup = (isref || indir != 1);
+        }
+        break;
+
+    case 5:
+        if (strcmp(type, "float") == 0)
+            sat = float_sat;
+        else if (strcmp(type, "short") == 0)
+            sat = short_sat;
+        break;
+
+    case 6:
+        if (strcmp(type, "double") == 0)
+            sat = double_sat;
+        break;
+
+    case 7:
+        if (strcmp(type, "__int64") == 0)
+            sat = longlong_sat;
+        else if (strcmp(type, "wchar_t") == 0)
+        {
+            sat = (indir ? wstring_sat : wchar_sat);
+            unsup = (isref || indir > 1);
+        }
+        break;
+
+    case 8:
+        if (strcmp(type, "unsigned") == 0)
+            sat = uint_sat;
+        else if (strcmp(type, "QVariant") == 0)
+        {
+            if (indir == 0)
+            {
+                sat = qvariant_sat;
+                unsup = FALSE;
+            }
+            else if (indir == 1)
+            {
+                sat = qvariantp_sat;
+                unsup = FALSE;
+            }
+        }
+        break;
+
+    case 9:
+        if (strcmp(type, "long long") == 0)
+            sat = longlong_sat;
+        break;
+
+    case 11:
+        if (strcmp(type, "signed char") == 0)
+        {
+            sat = (indir ? sstring_sat : schar_sat);
+            unsup = (isref || indir > 1);
+        }
+        break;
+
+    case 12:
+        if (strcmp(type, "unsigned int") == 0)
+            sat = uint_sat;
+        break;
+
+    case 13:
+        if (strcmp(type, "unsigned long") == 0)
+            sat = ulong_sat;
+        else if (strcmp(type, "unsigned char") == 0)
+        {
+            sat = (indir ? ustring_sat : uchar_sat);
+            unsup = (isref || indir > 1);
+        }
+        else if (strcmp(type, "PyQt_PyObject") == 0 && indir == 0)
+        {
+            sat = pyobject_sat;
+            unsup = FALSE;
+        }
+        break;
+
+    case 14:
+        if (strcmp(type, "unsigned short") == 0)
+            sat = ushort_sat;
+        break;
+
+    case 16:
+        if (strcmp(type, "unsigned __int64") == 0)
+            sat = ulonglong_sat;
+        break;
+
+    case 18:
+        if (strcmp(type, "unsigned long long") == 0)
+            sat = ulonglong_sat;
+        break;
+    }
+
+    if (sat == unknown_sat)
+    {
+        const sipTypeDef *td = sipFindType(type);
+
+        if (td)
+        {
+            if (sipTypeIsClass(td))
+            {
+                if (indir == 0)
+                    sat = class_sat;
+                else if (indir == 1)
+                    sat = classp_sat;
+
+                arg->u.wt = (sipWrapperType *)sipTypeAsPyTypeObject(td);
+            }
+            else if (sipTypeIsMapped(td))
+            {
+                if (indir == 0)
+                    sat = mtype_sat;
+                else if (indir == 1)
+                    sat = mtypep_sat;
+
+                arg->u.mt = td;
+            }
+            else if (sipTypeIsEnum(td))
+            {
+                if (indir == 0)
+                    sat = enum_sat;
+
+                arg->u.et = sipTypeAsPyTypeObject(td);
+            }
+        }
+    }
+    else if (unsup)
+        sat = unknown_sat;
+
+    arg->atype = sat;
+}
+
+
+// Dispose of a receiver that might be a universal slot.
+static void sipQtDestroyUniversalSlot(void *rx)
+{
+	for (UniversalSlot *us = UniversalSlot::unislots; us; us = us->nextus)
+		if (us == reinterpret_cast<QObject *>(rx))
+		{
+			delete us;
+			break;
+		}
+}
+
+
+// Search for the universal slot connected to a particular Qt signal.
+static void *sipQtFindSlot(void *tx, const char *sig, PyObject *rxObj,
+        const char *slot, const char **member)
+{
+	for (UniversalSlot *us = UniversalSlot::unislots; us; us = us->nextus)
+    {
+        pyqt3SlotConnection *conn = &us->conn;
+
+        if (conn->sc_transmitter != tx)
+            continue;
+
+        if (!sipQtSameSignalSlotName(conn->sc_signature->sg_signature, sig))
+            continue;
+
+		if (sipSameSlot(&conn->sc_slot, rxObj, slot))
+		{
+			*member = SLOT(unislot());
+			return us;
+		}
+    }
+
+	return 0;
+}
+
+
+// Connect a Qt signal to a Qt slot.
+static int sipQtConnect(void *tx, const char *sig, void *rx, const char *slot, int)
+{
+	return QObject::connect(reinterpret_cast<QObject *>(tx), sig,
+				reinterpret_cast<QObject *>(rx), slot);
+}
+
+
+// Disconnect a Qt signal from a Qt slot.
+static int sipQtDisconnect(void *tx, const char *sig, void *rx, const char *slot)
+{
+	return QObject::disconnect(reinterpret_cast<QObject *>(tx), sig,
+				   reinterpret_cast<QObject *>(rx), slot);
+}
+
+
+// See if two signal or slot names are the same.
+static int sipQtSameSignalSlotName(const char *s1, const char *s2)
+{
+	// moc formats signal names, so we should first convert the supplied
+	// string to the same format before comparing them.  Instead we just
+	// compare them as they are, but ignoring all spaces - this will have
+	// the same result.
+	do
+	{
+		// Skip any spaces.
+
+		while (*s1 == ' ')
+			++s1;
+
+		while (*s2 == ' ')
+			++s2;
+
+		if (*s1++ != *s2)
+			return 0;
+	}
+	while (*s2++ != '\0');
+
+	return 1;
+}
+
+
+// Return the next slot for a particular transmitter.  This will be called with
+// the GIL locked.
+static sipSlot *sipQtFindSipslot(void *tx, void **context)
+{
+    UniversalSlot *us = *reinterpret_cast<UniversalSlot **>(context);
+
+    if (!us)
+        us = UniversalSlot::unislots;
+
+    sipSlot *slot = 0;
+
+    while (us)
+    {
+        pyqt3SlotConnection *this_conn = &us->conn;
+
+        us = us->nextus;
+
+        if (this_conn->sc_transmitter == tx)
+        {
+            slot = &this_conn->sc_slot;
+            break;
+        }
+    }
+
+    *context = us;
+
+    return slot;
+}
+
+
+// Connect a slot from a Python signal.
+static int sipQtConnectPySignal(PyObject *txObj, const char *sig,
+        PyObject *rxObj, const char *slot)
+{
+    pyqt3PySig *ps;
+    pyqt3SlotList *psrx;
+    pyqtWrapper *pw = (pyqtWrapper *)txObj;
+
+    /* Create a new one if necessary. */
+    if ((ps = find_py_signal(pw, sig)) == NULL)
+    {
+        if ((ps = (pyqt3PySig *)sipMalloc(sizeof (pyqt3PySig))) == NULL)
+            return -1;
+
+        if ((ps->name = (char *)sipMalloc(strlen(sig) + 1)) == NULL)
+        {
+            sipFree(ps);
+            return -1;
+        }
+
+        strcpy(ps->name, sig);
+
+        ps->rxlist = NULL;
+        ps->next = pw->pySigList;
+
+        pw->pySigList = ps;
+    }
+
+    /* Create the new receiver. */
+    if ((psrx = (pyqt3SlotList *)sipMalloc(sizeof (pyqt3SlotList))) == NULL)
+        return -1;
+
+    if (sipSaveSlot(&psrx->rx, rxObj, slot) < 0)
+    {
+        sipFree(psrx);
+        return -1;
+    }
+
+    psrx->next = ps->rxlist;
+    ps->rxlist = psrx;
+
+    return 0;
+}
+
+
+// Disconnect a slot from a Python signal.
+static void sipQtDisconnectPySignal(PyObject *txObj, const char *sig,
+        PyObject *rxObj, const char *slot)
+{
+    pyqt3PySig *ps;
+
+    if ((ps = find_py_signal((pyqtWrapper *)txObj, sig)) != NULL)
+    {
+        pyqt3SlotList **psrxp;
+
+        for (psrxp = &ps->rxlist; *psrxp != NULL; psrxp = &(*psrxp)->next)
+        {
+            pyqt3SlotList *psrx = *psrxp;
+
+            if (sipSameSlot(&psrx->rx, rxObj, slot))
+            {
+                *psrxp = psrx->next;
+                free_slot_list(psrx);
+                break;
+            }
+        }
+    }
+}
+
+
+// Emit a signal for the sip module.
+static int sipQtEmitSignal(PyObject *self, const char *sig, PyObject *sigargs)
+{
+    return pyqt3EmitSignal(self, sig, sigargs);
+}
+
+
+// Emit a Python or Qt signal.
+int pyqt3EmitSignal(PyObject *self, const char *sig, PyObject *sigargs)
+{
+    // Don't do anything if signals are blocked.  Qt signals would be blocked
+    // anyway, but this blocks Python signals as well.
+    void *tx = sipGetCppPtr((sipSimpleWrapper *)self, sipType_QObject);
+
+    if (!tx)
+        return 0;
+
+	if (reinterpret_cast<QObject *>(tx)->signalsBlocked())
+        return 0;
+
+    // See if it is a Qt signal.
+    if (*sig == '2')
+    {
+        pyqt3QtSignal *tab;
+
+        // Search the table.
+        for (tab = ((pyqt3ClassTypeDef *)((sipWrapperType *)(self->ob_type))->type)->qt3_emit; tab->st_name != NULL; ++tab)
+        {
+            const char *sp, *tp;
+            bool found;
+
+            // Compare only the base name.
+            sp = &sig[1];
+            tp = tab->st_name;
+
+            found = true;
+
+            while (*sp != '\0' && *sp != '(' && *tp != '\0')
+                if (*sp++ != *tp++)
+                {
+                    found = false;
+                    break;
+                }
+
+            if (found)
+                return (*tab->st_emitfunc)((sipSimpleWrapper *)self, sigargs);
+        }
+
+        // It wasn't found if we got this far.
+        PyErr_Format(PyExc_NameError, "Invalid signal %s", &sig[1]);
+
+        return -1;
+    }
+
+    pyqt3PySig *ps = find_py_signal((pyqtWrapper *)self, sig);
+
+    if (ps)
+    {
+        int rc = 0;
+        pyqt3SlotList *rxlist = ps->rxlist;
+
+        // Forget the last Qt sender and remember this one.
+	    UniversalSlot::lastSender = 0;
+        py_sender = self;
+
+        // Apply the arguments to each slot method.
+        while (rxlist && rc >= 0)
+        {
+            pyqt3SlotList *next;
+            PyObject *res;
+
+            // We get the next in the list before calling the slot in case the
+            // list gets changed by the slot - usually because the slot
+            // disconnects itself.
+            next = rxlist->next;
+
+            res = sipInvokeSlot(&rxlist->rx, sigargs);
+
+            if (res)
+                Py_DECREF(res);
+            else
+                rc = -1;
+
+            rxlist = next;
+        }
+
+        // Forget this as a sender.
+        py_sender = NULL;
+
+        return rc;
+    }
+
+    return 0;
+}
+
+
+// Return the most recent signal sender.
+PyObject *pyqt3GetSender()
+{
+    PyObject *sender;
+
+    // If there is a Qt sender then it is more recent than the last Python
+    // sender, so use it instead.
+    if (UniversalSlot::lastSender)
+    {
+        sender = sipConvertFromType(UniversalSlot::lastSender, sipType_QObject,
+                NULL);
+    }
+    else
+    {
+        sender = (py_sender ? py_sender : Py_None);
+        Py_INCREF(sender);
+    }
+
+    return sender;
+}
+
+%End
+
+%InitialisationCode
+    // Initialise the meta-type.
+    pyqtWrapperType_Type.tp_base = sipWrapperType_Type;
+
+    if (PyType_Ready(&pyqtWrapperType_Type) < 0)
+        Py_FatalError("qt: Failed to initialise pyqtWrapperType type");
+
+    // Register the meta-type.
+    if (sipRegisterPyType((PyTypeObject *)&pyqtWrapperType_Type) < 0)
+        Py_FatalError("qt: Failed to register pyqtWrapperType type");
+
+    // Initialise the super-type.
+#if PY_VERSION_HEX >= 0x02050000
+    pyqtWrapper_Type.super.ht_type.tp_base = sipWrapper_Type;
+#else
+    pyqtWrapper_Type.super.type.tp_base = sipWrapper_Type;
+#endif
+
+    if (PyType_Ready((PyTypeObject *)&pyqtWrapper_Type) < 0)
+        Py_FatalError("qt: Failed to initialise pyqtWrapper type");
+
+    // Register the super-type.
+    if (sipRegisterPyType((PyTypeObject *)&pyqtWrapper_Type) < 0)
+        Py_FatalError("qt: Failed to register pyqtWrapper type");
+%End