summaryrefslogtreecommitdiffstats
path: root/sip/qt/qobject.sip
diff options
context:
space:
mode:
Diffstat (limited to 'sip/qt/qobject.sip')
-rw-r--r--sip/qt/qobject.sip2319
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