Skip to content
Navigation Menu
{{ message }}
-
Notifications
You must be signed in to change notification settings - Fork 109
Expand file tree
/
Copy pathPythonQtStdDecorators.h
More file actions
265 lines (230 loc) · 10.7 KB
/
Copy pathPythonQtStdDecorators.h
File metadata and controls
265 lines (230 loc) · 10.7 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
#ifndef _PYTHONQTSTDDECORATORS_H
#define _PYTHONQTSTDDECORATORS_H
/*
*
* Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed 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
* Lesser General Public License for more details.
*
* Further, this software is distributed without any warranty that it is
* free of the rightful claim of any third person regarding infringement
* or the like. Any license provided herein, whether implied or
* otherwise, applies only to this software file. Patent licenses, if
* any, provided herein do not apply to combinations of this program with
* other software, or any other product whatsoever.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
* 28359 Bremen, Germany or:
*
* http://www.mevis.de
*
*/
//----------------------------------------------------------------------------------
/*!
// \file PythonQtStdDecorators.h
// \author Florian Link
// \author Last changed by $Author: florian $
// \date 2007-04
*/
//----------------------------------------------------------------------------------
#include "PythonQtPythonInclude.h"
#include "PythonQt.h"
#include <QObject>
#include <QVariantList>
#include <QTextDocument>
#include <QColor>
#include <QDateTime>
#include <QDate>
#include <QTime>
#include <QTimer>
#include <QImage>
#include <QMetaMethod>
#include <QMetaEnum>
#include <QMetaProperty>
#if (QT_VERSION >= QT_VERSION_CHECK(5, 15, 0))
#include <QRandomGenerator>
#endif
class PYTHONQT_EXPORT PythonQtStdDecorators : public QObject
{
Q_OBJECT
public Q_SLOTS:
bool connect(QObject* sender, const QByteArray& signal, PyObject* callable);
bool connect(QObject* sender, const QByteArray& signal, QObject* receiver, const QByteArray& slot,
Qt::ConnectionType type = Qt::AutoConnection);
bool connect(QObject* receiver, QObject* sender, const QByteArray& signal, const QByteArray& slot,
Qt::ConnectionType type = Qt::AutoConnection)
{
return connect(sender, signal, receiver, slot, type);
}
bool static_QObject_connect(QObject* sender, const QByteArray& signal, PyObject* callable)
{
return connect(sender, signal, callable);
}
bool static_QObject_connect(QObject* sender, const QByteArray& signal, QObject* receiver, const QByteArray& slot,
Qt::ConnectionType type = Qt::AutoConnection)
{
return connect(sender, signal, receiver, slot, type);
}
bool disconnect(QObject* sender, const QByteArray& signal, PyObject* callable = nullptr);
bool disconnect(QObject* sender, const QByteArray& signal, QObject* receiver, const QByteArray& slot);
bool static_QObject_disconnect(QObject* sender, const QByteArray& signal, PyObject* callable = nullptr)
{
return disconnect(sender, signal, callable);
}
bool static_QObject_disconnect(QObject* sender, const QByteArray& signal, QObject* receiver, const QByteArray& slot)
{
return disconnect(sender, signal, receiver, slot);
}
const QMetaObject* metaObject(QObject* obj);
QObject* parent(QObject* o);
void setParent(QObject* o, PythonQtNewOwnerOfThis<QObject*> parent);
const QObjectList* children(QObject* o);
QObject* findChild(QObject* parent, PyObject* type, const QString& name = QString());
QList<QObject*> findChildren(QObject* parent, PyObject* type, const QString& name = QString());
QList<QObject*> findChildren(QObject* parent, PyObject* type, const QRegularExpression& regExp);
bool setProperty(QObject* o, const char* name, const QVariant& value);
QVariant property(QObject* o, const char* name);
double static_Qt_qAbs(double a) { return qAbs(a); }
double static_Qt_qBound(double a, double b, double c) { return qBound(a, b, c); }
void static_Qt_qDebug(const QByteArray& msg) { qDebug("%s", msg.constData()); }
// TODO: multi arg qDebug...
void static_Qt_qWarning(const QByteArray& msg) { qWarning("%s", msg.constData()); }
// TODO: multi arg qWarning...
void static_Qt_qCritical(const QByteArray& msg) { qCritical("%s", msg.constData()); }
// TODO: multi arg qCritical...
void static_Qt_qFatal(const QByteArray& msg) { qFatal("%s", msg.constData()); }
// TODO: multi arg qFatal...
bool static_Qt_qFuzzyCompare(double a, double b) { return qFuzzyCompare(a, b); }
double static_Qt_qMax(double a, double b) { return qMax(a, b); }
double static_Qt_qMin(double a, double b) { return qMin(a, b); }
int static_Qt_qRound(double a) { return qRound(a); }
qint64 static_Qt_qRound64(double a) { return qRound64(a); }
const char* static_Qt_qVersion() { return qVersion(); }
int static_Qt_qrand()
{
#if (QT_VERSION < QT_VERSION_CHECK(5, 15, 0))
return qrand();
#else
return QRandomGenerator::global()->generate();
#endif
}
void static_Qt_qsrand(uint a)
{
#if (QT_VERSION < QT_VERSION_CHECK(5, 15, 0))
qsrand(a);
#else
QRandomGenerator::global()->seed(a);
#endif
}
QString tr(QObject* obj, const QString& text, const QString& ambig = QString(), int n = -1);
QString static_Qt_SIGNAL(const QString& s) { return QString("2") + s; }
QString static_Qt_SLOT(const QString& s) { return QString("1") + s; }
void static_QTimer_singleShot(int msec, PyObject* callable);
private:
QObject* findChild(const QObject* parent, const char* typeName, const QMetaObject* meta, const QString& name);
void findChildren(const QObject* parent, const char* typeName, const QMetaObject* meta, const QString& name,
QList<QObject*>& list);
void findChildren(const QObject* parent, const char* typeName, const QMetaObject* meta,
const QRegularExpression& regExp, QList<QObject*>& list);
};
class PythonQtSingleShotTimer : public QTimer
{
Q_OBJECT
public:
PythonQtSingleShotTimer(int msec, const PythonQtObjectPtr& callable);
~PythonQtSingleShotTimer() override;
public Q_SLOTS:
void slotTimeout();
private:
PythonQtObjectPtr _callable;
};
class PythonQtWrapper_QMetaObject : public QObject
{
Q_OBJECT
public Q_SLOTS:
// Python 3: PythonQt shadows className, so we need an extra getClassName method...
const char* getClassName(QMetaObject* obj) const { return obj->className(); }
const QMetaObject* superClass(QMetaObject* obj) const { return obj->superClass(); }
int methodOffset(QMetaObject* obj) const { return obj->methodOffset(); }
int enumeratorOffset(QMetaObject* obj) const { return obj->enumeratorOffset(); }
int propertyOffset(QMetaObject* obj) const { return obj->propertyOffset(); }
int classInfoOffset(QMetaObject* obj) const { return obj->classInfoOffset(); }
int constructorCount(QMetaObject* obj) const { return obj->constructorCount(); }
int methodCount(QMetaObject* obj) const { return obj->methodCount(); }
int enumeratorCount(QMetaObject* obj) const { return obj->enumeratorCount(); }
int propertyCount(QMetaObject* obj) const { return obj->propertyCount(); }
int classInfoCount(QMetaObject* obj) const { return obj->classInfoCount(); }
int indexOfConstructor(QMetaObject* obj, const char* constructor) const
{
return obj->indexOfConstructor(constructor);
}
int indexOfMethod(QMetaObject* obj, const char* method) const { return obj->indexOfMethod(method); }
int indexOfSignal(QMetaObject* obj, const char* signal) const { return obj->indexOfSignal(signal); }
int indexOfSlot(QMetaObject* obj, const char* slot) const { return obj->indexOfSlot(slot); }
int indexOfEnumerator(QMetaObject* obj, const char* name) const { return obj->indexOfEnumerator(name); }
int indexOfProperty(QMetaObject* obj, const char* name) const { return obj->indexOfProperty(name); }
int indexOfClassInfo(QMetaObject* obj, const char* name) const { return obj->indexOfClassInfo(name); }
QMetaMethod constructor(QMetaObject* obj, int index) const { return obj->constructor(index); }
QMetaMethod method(QMetaObject* obj, int index) const { return obj->method(index); }
QMetaEnum enumerator(QMetaObject* obj, int index) const { return obj->enumerator(index); }
QMetaProperty property(QMetaObject* obj, int index) const { return obj->property(index); }
QMetaClassInfo classInfo(QMetaObject* obj, int index) const { return obj->classInfo(index); }
QMetaProperty userProperty(QMetaObject* obj) const { return obj->userProperty(); }
bool static_QMetaObject_checkConnectArgs(const char* signal, const char* method)
{
return QMetaObject::checkConnectArgs(signal, method);
}
QByteArray static_QMetaObject_normalizedSignature(const char* method)
{
return QMetaObject::normalizedSignature(method);
}
QByteArray static_QMetaObject_normalizedType(const char* type) { return QMetaObject::normalizedType(type); }
};
//! Some methods to set properties of PythonQt from Python
class PYTHONQT_EXPORT PythonQtConfigAPI : public QObject
{
Q_OBJECT
public:
PythonQtConfigAPI(QObject* parent)
: QObject(parent) {};
public slots:
//! Set a callable that is used as the argument for the add_done_callback for the Task/Future
//! created when, e.g., an async function is connected to signal.
void setTaskDoneCallback(PyObject* object);
};
//! Some helper methods that allow testing of the ownership
class PYTHONQT_EXPORT PythonQtDebugAPI : public QObject
{
Q_OBJECT
public:
PythonQtDebugAPI(QObject* parent)
: QObject(parent) {};
public slots:
//! Returns if the C++ object is owned by PythonQt and will be deleted when the reference goes away.
bool isOwnedByPython(PyObject* object);
//! Returns if the C++ object is an instance of a Python class that derives a C++ class.
bool isDerivedShellInstance(PyObject* object);
//! Returns if the shell instance has an extra ref count from the C++ side.
bool hasExtraShellRefCount(PyObject* object);
//! Pass the ownership of the given object to CPP (so that it will not be deleted by Python if the reference goes away)
bool passOwnershipToCPP(PyObject* object);
//! Pass the ownership of the given object to Python (so that the C++ object will be deleted when the Python reference goes away)
bool passOwnershipToPython(PyObject* object);
//! Returns if the given object is a PythonQt instance wrapper (or derived class)
bool isPythonQtInstanceWrapper(PyObject* object);
//! Returns if the given object is a PythonQt class wrapper (or derived class)
bool isPythonQtClassWrapper(PyObject* object);
};
#endif
You can’t perform that action at this time.