// 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
