You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
pytqt/sip/qt/qobject.sip

2320 lines
60 KiB

// This is the SIP interface definition for TQObject.
//
// Copyright (c) 2007
// Riverbank Computing Limited <info@riverbankcomputing.co.uk>
//
// This file is part of PyTQt.
//
// This copy of PyTQt 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.
//
// PyTQt 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
// PyTQt; 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>TQObject</Title>
<FuncSynopsis>
<FuncDef>bool <Function>disconnect</Function></FuncDef>
<ParamDef>const TQObject *<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 TQObject *<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 TQObject *<Parameter>sender</Parameter></ParamDef>
<ParamDef>const char *<Parameter>signal</Parameter></ParamDef>
<ParamDef>const TQObject *<Parameter>receiver</Parameter></ParamDef>
<ParamDef>const char *<Parameter>member</Parameter></ParamDef>
</FuncSynopsis>
<Para>
At the moment PyTQt does not support the full behaviour of the corresponding TQt
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 (TQt_2_00 -)
class TQObject : TQt
{
%TypeHeaderCode
#include <qobject.h>
#include <qapplication.h>
%End
public:
TQObject(TQObject * /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_TQt_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_TQt_FILEDIALOG)
{sipName_QFileIconProvider, &sipClass_QFileIconProvider, -1, 7},
#else
{NULL, NULL, -1, 7},
#endif
#if QT_VERSION >= 220 && defined(SIP_FEATURE_TQt_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_TQt_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_TQt_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_TQt_NETWORKPROTOCOL)
{sipName_QNetworkProtocol, &sipClass_QNetworkProtocol, -1, 18},
#else
{NULL, NULL, -1, 18},
#endif
#if QT_VERSION >= 220 && defined(SIP_FEATURE_TQt_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_TQt_CLIPBOARD)
{sipName_QClipboard, &sipClass_QClipboard, -1, -1},
#else
{NULL, NULL, -1, -1},
#endif
{sipName_QStatusBar, &sipClass_QStatusBar, -1, 26},
#if defined(SIP_FEATURE_TQt_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_TQt_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_TQt_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_TQt_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_TQt_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_TQt_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_TQt_INPUTDIALOG)
{sipName_QInputDialog, &sipClass_QInputDialog, -1, 82},
#else
{NULL, NULL, -1, 82},
#endif
#if defined(SIP_FEATURE_TQt_MESSAGEBOX)
{sipName_QMessageBox, &sipClass_QMessageBox, -1, 83},
#else
{NULL, NULL, -1, 83},
#endif
#if defined(SIP_FEATURE_TQt_WIZARD)
{sipName_QWizard, &sipClass_QWizard, -1, 84},
#else
{NULL, NULL, -1, 84},
#endif
#if defined(SIP_FEATURE_TQt_COLORDIALOG)
{sipName_QColorDialog, &sipClass_QColorDialog, -1, 85},
#else
{NULL, NULL, -1, 85},
#endif
#if defined(SIP_FEATURE_TQt_FONTDIALOG)
{sipName_QFontDialog, &sipClass_QFontDialog, -1, 86},
#else
{NULL, NULL, -1, 86},
#endif
#if defined(SIP_FEATURE_TQt_FILEDIALOG)
{sipName_QFileDialog, &sipClass_QFileDialog, -1, 87},
#else
{NULL, NULL, -1, 87},
#endif
#if defined(SIP_FEATURE_TQt_PROGRESSDIALOG)
{sipName_QProgressDialog, &sipClass_QProgressDialog, -1, 88},
#else
{NULL, NULL, -1, 88},
#endif
#if defined(SIP_FEATURE_TQt_TABDIALOG)
{sipName_QTabDialog, &sipClass_QTabDialog, -1, -1},
#else
{NULL, NULL, -1, -1},
#endif
#if QT_VERSION >= 220 && defined(SIP_FEATURE_TQt_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_TQt_ICONVIEW) && defined(SIP_FEATURE_TQt_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_TQt_STYLE_WINDOWS)
{sipName_QWindowsStyle, &sipClass_QWindowsStyle, 106, 105},
#else
{NULL, NULL, -1, 105},
#endif
#if defined(SIP_FEATURE_TQt_STYLE_MOTIF)
{sipName_QMotifStyle, &sipClass_QMotifStyle, 107, -1},
#else
{NULL, NULL, -1, -1},
#endif
#if defined(SIP_FEATURE_TQt_STYLE_PLATINUM)
{sipName_QPlatinumStyle, &sipClass_QPlatinumStyle, -1, 110},
#else
{NULL, NULL, -1, 110},
#endif
#if defined(SIP_FEATURE_TQt_STYLE_CDE)
{sipName_QCDEStyle, &sipClass_QCDEStyle, -1, 108},
#else
{NULL, NULL, -1, 108},
#endif
#if QT_VERSION >= 220 && defined(SIP_FEATURE_TQt_STYLE_MOTIFPLUS)
{sipName_QMotifPlusStyle, &sipClass_QMotifPlusStyle, -1, 109},
#else
{NULL, NULL, -1, 109},
#endif
#if QT_VERSION >= 220 && defined(SIP_FEATURE_TQt_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 (- TQt_3_0_0)
static TQString tr(const char *) /AutoGen=TQt_TRANSLATION/;
%End
%If (TQt_2_2_0 - TQt_2_3_1)
// There was an apparent bug in moc prior to TQt v2.3.1 where this
// method wasn't automatically generated.
static TQString tr(const char *,const char *);
%End
%If (TQt_2_3_1 - TQt_3_0_0)
static TQString tr(const char *,const char *) /AutoGen=TQt_TRANSLATION/;
%End
%If (TQt_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.
TQString 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 TQString(qApp -> translate(cname,a0,a1,TQApplication::DefaultCodec));
else
sipRes = new TQString(TQString::fromLatin1(a0));
Py_END_ALLOW_THREADS
Py_DECREF(nmobj);
}
%End
TQString 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 TQString(qApp -> translate(cname,a0,a1,TQApplication::UnicodeUTF8));
else
sipRes = new TQString(TQString::fromUtf8(a0));
Py_END_ALLOW_THREADS
Py_DECREF(nmobj);
}
%End
%End
virtual TQMetaObject *metaObject() const /AutoGen/;
virtual bool event(TQEvent *);
virtual bool eventFilter(TQObject *,TQEvent *);
bool isA(const char *) const;
%MethodCode
// The TQt 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 TQt 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 -> TQObject::isA(a0);
Py_END_ALLOW_THREADS
#endif
%End
bool inherits(const char *) const;
%MethodCode
// The TQt 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 TQt 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 -> TQObject::inherits(a0);
Py_END_ALLOW_THREADS
#endif
%End
%If (- TQt_3_0_0)
TQStringList 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 (- TQt_3_0_0)
TQObject *child(const char *,const char * = 0);
%End
%If (TQt_3_0_0 -)
TQObject *child(const char *,const char * = 0,bool = 1);
%End
const TQObjectList *children() const;
%If (TQt_2_1_0 -)
static const TQObjectList *objectTrees();
%End
%If (- TQt_3_0_0)
TQObjectList *queryList(char * = 0,char * = 0,bool = 1,bool = 1);
%End
%If (TQt_3_0_0 -)
TQObjectList *queryList(char * = 0,char * = 0,bool = 1,bool = 1) const;
%MethodCode
// The TQt 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 TQt behaviour as it's deprecated and we
// want to keep things simple.
#if SIP_VERSION >= 0x040000
sipRes = sipCpp -> TQObject::queryList(0, a1, a2, a3);
if (a0 && sipRes)
{
TQObject *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 -> TQObject::queryList(a0, a1, a2, a3);
Py_END_ALLOW_THREADS
#endif
%End
%End
virtual void insertChild(TQObject * /Transfer/);
virtual void removeChild(TQObject * /TransferBack/);
void installEventFilter(const TQObject *);
void removeEventFilter(const TQObject *);
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 TQObject * = 0,const char * = 0);
// bool disconnect(const TQObject *,const char * = 0);
void dumpObjectTree();
void dumpObjectInfo();
TQObject *parent() const;
void emit(SIP_SIGNAL,SIP_PYTUPLE);
%MethodCode
if (pyqt3EmitSignal(sipSelf, a0, a1) < 0)
sipIsErr = 1;
%End
%If (TQt_PROPERTIES)
%If (TQt_2_1_0 - TQt_3_0_0)
bool setProperty(const char *,const TQVariant &);
TQVariant property(const char *) const;
%End
%If (TQt_3_0_0 -)
virtual bool setProperty(const char *,const TQVariant &);
virtual TQVariant property(const char *) const;
%End
%End
signals:
void destroyed();
%If (TQt_3_0_0 -)
void destroyed(TQObject *);
%End
public slots:
%If (TQt_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(TQTimerEvent *);
virtual void childEvent(TQChildEvent *);
%If (TQt_3_0_0 -)
virtual void customEvent(TQCustomEvent *);
%End
private:
TQObject(const TQObject &);
};
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 (- TQt_2_00)
class TQObject
{
%TypeHeaderCode
#include <qobject.h>
%End
public:
TQObject(TQObject * /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_TQt_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_TQt_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_TQt_MESSAGEBOX)
{sipName_QMessageBox, &sipClass_QMessageBox},
#endif
{sipName_QMultiLineEdit, &sipClass_QMultiLineEdit},
{sipName_QPopupMenu, &sipClass_QPopupMenu},
#if defined(WS_X11) && defined(SIP_FEATURE_TQt_PRINTDIALOG)
{sipName_QPrintDialog, &sipClass_QPrintDialog},
#endif
{sipName_QProgressBar, &sipClass_QProgressBar},
#if defined(SIP_FEATURE_TQt_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_TQt_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(TQEvent *);
virtual bool eventFilter(TQObject *,TQEvent *);
const char *tr(const char *) const;
virtual TQMetaObject *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 TQObjectList *children() const;
TQObjectList *queryList(char * = 0,char * = 0,bool = 1,bool = 1);
void insertChild(TQObject * /Transfer/);
void removeChild(TQObject * /TransferBack/);
void installEventFilter(const TQObject *);
void removeEventFilter(const TQObject *);
// bool connect(TQObject *,const char *,const char *);
// bool disconnect(const char * = 0,const TQObject * = 0,const char * = 0);
// bool disconnect(const TQObject *,const char * = 0);
void dumpObjectTree();
void dumpObjectInfo();
TQObject *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(TQTimerEvent *);
private:
TQObject(const TQObject &);
};
%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 TQt 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 TQt support API for SIP are implemented.
#undef sipTQtEmitSignal
#undef sipTQtConnectPySignal
#undef sipTQtDisconnectPySignal
// Declare explicit C linkage.
extern "C"
{
static void *sipTQtCreateUniversalSlot(sipWrapper *, const char *,
PyObject *, const char *, const char **, int);
static void sipTQtDestroyUniversalSlot(void *);
static void *sipTQtFindSlot(void *, const char *, PyObject *, const char *,
const char **);
static int sipTQtConnect(void *, const char *, void *, const char *, int);
static int sipTQtDisconnect(void *, const char *, void *, const char *);
static int sipTQtSameSignalSlotName(const char *, const char *);
static sipSlot *sipTQtFindSipslot(void *, void **);
static int sipTQtEmitSignal(PyObject *, const char *, PyObject *);
static int sipTQtConnectPySignal(PyObject *, const char *, PyObject *,
const char *);
static void sipTQtDisconnectPySignal(PyObject *, const char *,
PyObject *, const char *);
}
extern "C" {
// The meta-type for PyTQt classes. It is just a marker type so that we can
// safely cast to get access to PyTQt3-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 PyTQt3.
*/
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 (sipTQtSameSignalSlotName(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 */
(intquiry)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 TQObject.
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 TQObject but is not run through moc. Instead the normal
// moc-generated methods are handwritten in order to implement a universal
// slot. This retquires some knowledge of the internal implementation of
// signals and slots but it is likely that they will only change between major
// TQt versions.
class UniversalSlot : public TQObject
{
public:
UniversalSlot(TQObject *qtx, pyqt3SlotConnection *conn, const char **member);
~UniversalSlot();
virtual TQMetaObject *metaObject() const
{
return staticMetaObject();
}
virtual bool qt_invoke(int, TQUObject *args);
static TQMetaObject *staticMetaObject();
static TQObject *lastSender;
static UniversalSlot *unislots;
UniversalSlot *nextus, *prevus;
pyqt3SlotConnection conn;
private:
static TQMetaObject *metaObj;
};
// Create a universal slot. Note that this will leak if there is no signal
// transmitter (ie. no parent) - TQTimer.singleShot() for example.
UniversalSlot::UniversalSlot(TQObject *qtx, pyqt3SlotConnection *connection, const char **member) : TQObject()
{
// Save the connection.
conn = *connection;
// Detect when the transmitter is destroyed.
if (qtx)
connect(qtx, SIGNAL(destroyed(TQObject *)), 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;
TQMetaObject *UniversalSlot::metaObj = 0;
#if QT_VERSION >= 0x030100
static TQMetaObjectCleanUp cleanUp_UniversalSlot("UniversalSlot", &UniversalSlot::staticMetaObject);
#else
static TQMetaObjectCleanUp cleanUp_UniversalSlot;
#endif
TQObject *UniversalSlot::lastSender = 0;
UniversalSlot *UniversalSlot::unislots = 0;
TQMetaObject *UniversalSlot::staticMetaObject()
{
if (metaObj)
return metaObj;
// Define a single slot that takes no arguments and so will accept any
// connection.
static const TQUMethod slot = {"unislot", 0, 0};
static const TQMetaData slot_tbl[] = {
{"unislot()", &slot, TQMetaData::Public}
};
metaObj = TQMetaObject::new_metaobject(
"UniversalSlot", TQObject::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, TQUObject *qargs)
{
if (id - staticMetaObject()->slotOffset() != 0)
return TQObject::qt_invoke(id, qargs);
bool ok = TRUE;
const pyqt3Signature *psig = conn.sc_signature;
TQVariant *qv;
// Save in case it is asked for later.
lastSender = const_cast<TQObject *>(sender());
// If the sender was a TQSignal then the single argument will be wrapped
// in a TQVariant instance. At the moment we handle int argument as
// that is all that is needed by PyTQt (and PyKDE).
if (lastSender->inherits("TQSignal"))
qv = &static_QUType_TQVariant.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_TQVariant.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 *sipTQtCreateUniversalSlot(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;
}
TQObject *qtx = 0;
// See if the transmitter is a TQObject 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 TQWidget destroys its children before emitting the
// destroyed signal.)
if (tx && PyObject_TypeCheck((PyObject *)tx, (PyTypeObject *)sipClass_QObject))
qtx = reinterpret_cast<TQObject *>(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 (sipTQtSameSignalSlotName(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 TQt 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, "TQVariant") == 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, "PyTQt_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 sipTQtDestroyUniversalSlot(void *rx)
{
for (UniversalSlot *us = UniversalSlot::unislots; us; us = us->nextus)
if (us == reinterpret_cast<TQObject *>(rx))
{
delete us;
break;
}
}
// Search for the universal slot connected to a particular TQt signal.
static void *sipTQtFindSlot(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 (!sipTQtSameSignalSlotName(conn->sc_signature->sg_signature, sig))
continue;
if (sipSameSlot(&conn->sc_slot, rxObj, slot))
{
*member = SLOT(unislot());
return us;
}
}
return 0;
}
// Connect a TQt signal to a TQt slot.
static int sipTQtConnect(void *tx, const char *sig, void *rx, const char *slot, int)
{
return TQObject::connect(reinterpret_cast<TQObject *>(tx), sig,
reinterpret_cast<TQObject *>(rx), slot);
}
// Disconnect a TQt signal from a TQt slot.
static int sipTQtDisconnect(void *tx, const char *sig, void *rx, const char *slot)
{
return TQObject::disconnect(reinterpret_cast<TQObject *>(tx), sig,
reinterpret_cast<TQObject *>(rx), slot);
}
// See if two signal or slot names are the same.
static int sipTQtSameSignalSlotName(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 *sipTQtFindSipslot(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 sipTQtConnectPySignal(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 sipTQtDisconnectPySignal(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 sipTQtEmitSignal(PyObject *self, const char *sig, PyObject *sigargs)
{
return pyqt3EmitSignal(self, sig, sigargs);
}
// Emit a Python or TQt signal.
int pyqt3EmitSignal(PyObject *self, const char *sig, PyObject *sigargs)
{
// Don't do anything if signals are blocked. TQt 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<TQObject *>(tx)->signalsBlocked())
return 0;
// See if it is a TQt signal.
if (*sig == '2')
{
pyqt3TQtSignal *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 TQt 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 TQt 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