diff options
Diffstat (limited to 'python/pyqt/sip/qt/qobject.sip')
| -rw-r--r-- | python/pyqt/sip/qt/qobject.sip | 1369 |
1 files changed, 1369 insertions, 0 deletions
diff --git a/python/pyqt/sip/qt/qobject.sip b/python/pyqt/sip/qt/qobject.sip new file mode 100644 index 00000000..97b3ff88 --- /dev/null +++ b/python/pyqt/sip/qt/qobject.sip @@ -0,0 +1,1369 @@ +// 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 { + 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 (sipEmitSignal(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 = sipGetSender(); +%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 = sipGetSender(); +%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 + + +// This is Qt support code for SIP v4.4 and later. +%ModuleCode + +#include <qobject.h> +#include <qvariant.h> +#include <qmetaobject.h> +#include <private/qucom_p.h> +#include <private/qucomextra_p.h> + + +// 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, sipSlotConnection *conn, const char **member); + ~UniversalSlot(); + + virtual QMetaObject *metaObject() const + { + return staticMetaObject(); + } + + virtual bool qt_invoke(int, QUObject *args); + static QMetaObject *staticMetaObject(); + + static const QObject *lastSender; + + static UniversalSlot *unislots; + UniversalSlot *nextus, *prevus; + sipSlotConnection 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, sipSlotConnection *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() +{ + sipFreeConnection(&conn); + + // Remove this one from the global list. + if (nextus) + nextus -> prevus = prevus; + + if (prevus) + prevus -> nextus = nextus; + else + unislots = nextus; +} + + +QMetaObject *UniversalSlot::metaObj = 0; + +#if QT_VERSION >= 0x030100 +static QMetaObjectCleanUp cleanUp_UniversalSlot("UniversalSlot", &UniversalSlot::staticMetaObject); +#else +static QMetaObjectCleanUp cleanUp_UniversalSlot; +#endif + +const 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 sipSignature *psig = conn.sc_signature; + QVariant *qv; + + // Save in case it is asked for later. + lastSender = 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 && sipEmitToSlot(&conn.sc_slot, argtup) < 0) + ok = FALSE; + + Py_DECREF(argtup); + } + + if (!ok) + PyErr_Print(); + +#ifdef WITH_THREAD + PyGILState_Release(state); +#endif + + return ok; +} + + +// Declare explicit C linkage. +extern "C" +{ + static void *sipQtCreateUniversalSlot(sipWrapper *, sipSlotConnection *, const char **); + 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 sipQtSignalsBlocked(void *); + static const void *sipQtGetSender(); + static void sipQtForgetSender(); + static int sipQtSameSignalSlotName(const char *, const char *); + static sipSlotConnection *sipQtFindConnection(void *, void **); +} + + +// 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, sipSlotConnection *conn, const char **member) +{ + 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(tx, (PyTypeObject *)sipClass_QObject)) + qtx = reinterpret_cast<QObject *>(conn->sc_transmitter); + + return new UniversalSlot(qtx, conn, member); +} + + +// 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) + if (sipSameConnection(&us->conn, tx, sig, 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 signals are currently blocked for a QObject. +static int sipQtSignalsBlocked(void *qobj) +{ + return reinterpret_cast<QObject *>(qobj)->signalsBlocked(); +} + + +// Get the last sender for QObject::sender(). +static const void *sipQtGetSender() +{ + return UniversalSlot::lastSender; +} + + +// Forget the last sender. +static void sipQtForgetSender() +{ + UniversalSlot::lastSender = 0; +} + + +// 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 connection for a particular transmitter. This will be +// called with the GIL locked. +static sipSlotConnection *sipQtFindConnection(void *tx, void **context) +{ + UniversalSlot *us = *reinterpret_cast<UniversalSlot **>(context); + + if (!us) + us = UniversalSlot::unislots; + + sipSlotConnection *conn = 0; + + while (us) + { + sipSlotConnection *this_conn = &us->conn; + + us = us->nextus; + + if (this_conn->sc_transmitter == tx) + { + conn = this_conn; + break; + } + } + + *context = us; + + return conn; +} + +%End |