diff options
Diffstat (limited to 'sources/pyside2/PySide2/glue')
| -rw-r--r-- | sources/pyside2/PySide2/glue/qtcharts.cpp | 42 | ||||
| -rw-r--r-- | sources/pyside2/PySide2/glue/qtcore.cpp | 1010 | ||||
| -rw-r--r-- | sources/pyside2/PySide2/glue/qtdatavisualization.cpp | 42 | ||||
| -rw-r--r-- | sources/pyside2/PySide2/glue/qtgui.cpp | 494 | ||||
| -rw-r--r-- | sources/pyside2/PySide2/glue/qtmultimedia.cpp | 45 | ||||
| -rw-r--r-- | sources/pyside2/PySide2/glue/qtnetwork.cpp | 80 | ||||
| -rw-r--r-- | sources/pyside2/PySide2/glue/qtopengl.cpp | 74 | ||||
| -rw-r--r-- | sources/pyside2/PySide2/glue/qtqml.cpp | 52 | ||||
| -rw-r--r-- | sources/pyside2/PySide2/glue/qtquick.cpp | 42 | ||||
| -rw-r--r-- | sources/pyside2/PySide2/glue/qtscript.cpp | 74 | ||||
| -rw-r--r-- | sources/pyside2/PySide2/glue/qtuitools.cpp | 57 | ||||
| -rw-r--r-- | sources/pyside2/PySide2/glue/qtwebkitwidgets.cpp | 77 | ||||
| -rw-r--r-- | sources/pyside2/PySide2/glue/qtwidgets.cpp | 365 | ||||
| -rw-r--r-- | sources/pyside2/PySide2/glue/qtxml.cpp | 48 | ||||
| -rw-r--r-- | sources/pyside2/PySide2/glue/qtxmlpatterns.cpp | 43 |
15 files changed, 2545 insertions, 0 deletions
diff --git a/sources/pyside2/PySide2/glue/qtcharts.cpp b/sources/pyside2/PySide2/glue/qtcharts.cpp new file mode 100644 index 000000000..1828fecc0 --- /dev/null +++ b/sources/pyside2/PySide2/glue/qtcharts.cpp @@ -0,0 +1,42 @@ +/**************************************************************************** +** +** Copyright (C) 2018 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qt for Python. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// @snippet qchart-releaseownership +Shiboken::Object::releaseOwnership(%PYARG_1); +// @snippet qchart-releaseownership diff --git a/sources/pyside2/PySide2/glue/qtcore.cpp b/sources/pyside2/PySide2/glue/qtcore.cpp new file mode 100644 index 000000000..f4114db3f --- /dev/null +++ b/sources/pyside2/PySide2/glue/qtcore.cpp @@ -0,0 +1,1010 @@ +/**************************************************************************** +** +** Copyright (C) 2018 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qt for Python. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// @snippet include-pyside +#include <pyside.h> +// @snippet include-pyside + +// @snippet pystring-check +bool py2kStrCheck(PyObject *obj) +{ +#ifdef IS_PY3K + return false; +#else + return PyString_Check(obj); +#endif +} +// @snippet pystring-check + +// @snippet qvariant-conversion +static const char *QVariant_resolveMetaType(PyTypeObject *type, int *typeId) +{ + if (PyObject_TypeCheck(type, SbkObjectType_TypeF())) { + SbkObjectType* sbkType = (SbkObjectType*)type; + const char* typeName = Shiboken::ObjectType::getOriginalName(sbkType); + if (!typeName) + return nullptr; + const bool valueType = '*' != typeName[qstrlen(typeName) - 1]; + // Do not convert user type of value + if (valueType && Shiboken::ObjectType::isUserType(type)) + return nullptr; + int obTypeId = QMetaType::type(typeName); + if (obTypeId) { + *typeId = obTypeId; + return typeName; + } + // Do not resolve types to value type + if (valueType) + return 0; + // Find in base types. First check tp_bases, and only after check tp_base, because + // tp_base does not always point to the first base class, but rather to the first + // that has added any python fields or slots to its object layout. + // See https://mail.python.org/pipermail/python-list/2009-January/520733.html + if (type->tp_bases) { + for (int i = 0, size = PyTuple_GET_SIZE(type->tp_bases); i < size; ++i) { + const char *derivedName = QVariant_resolveMetaType(reinterpret_cast<PyTypeObject *>(PyTuple_GET_ITEM( + type->tp_bases, i)), typeId); + if (derivedName) + return derivedName; + } + } + else if (type->tp_base) { + return QVariant_resolveMetaType(type->tp_base, typeId); + } + } + *typeId = 0; + return 0; +} +static QVariant QVariant_convertToValueList(PyObject *list) +{ + if (PySequence_Size(list) < 0) { + // clear the error if < 0 which means no length at all + PyErr_Clear(); + return QVariant(); + } + + Shiboken::AutoDecRef element(PySequence_GetItem(list, 0)); + int typeId; + const char *typeName = QVariant_resolveMetaType(element.cast<PyTypeObject*>(), &typeId); + if (typeName) { + QByteArray listTypeName("QList<"); + listTypeName += typeName; + listTypeName += '>'; + typeId = QMetaType::type(listTypeName); + if (typeId > 0) { + Shiboken::Conversions::SpecificConverter converter(listTypeName); + if (converter) { + QVariant var(typeId, nullptr); + converter.toCpp(list, &var); + return var; + } + qWarning() << "Type converter for :" << listTypeName << "not registered."; + } + } + return QVariant(); +} +static bool QVariant_isStringList(PyObject *list) +{ + if (!PySequence_Check(list)) { + // If it is not a list or a derived list class + // we assume that will not be a String list neither. + return false; + } + + if (PySequence_Size(list) < 0) { + // clear the error if < 0 which means no length at all + PyErr_Clear(); + return false; + } + + Shiboken::AutoDecRef fast(PySequence_Fast(list, "Failed to convert QVariantList")); + const Py_ssize_t size = PySequence_Fast_GET_SIZE(fast.object()); + for (Py_ssize_t i = 0; i < size; ++i) { + PyObject *item = PySequence_Fast_GET_ITEM(fast.object(), i); + if (!%CHECKTYPE[QString](item)) + return false; + } + return true; +} +static QVariant QVariant_convertToVariantMap(PyObject *map) +{ + Py_ssize_t pos = 0; + Shiboken::AutoDecRef keys(PyDict_Keys(map)); + if (!QVariant_isStringList(keys)) + return QVariant(); + PyObject *key; + PyObject *value; + QMap<QString,QVariant> ret; + while (PyDict_Next(map, &pos, &key, &value)) { + QString cppKey = %CONVERTTOCPP[QString](key); + QVariant cppValue = %CONVERTTOCPP[QVariant](value); + ret.insert(cppKey, cppValue); + } + return QVariant(ret); +} +static QVariant QVariant_convertToVariantList(PyObject *list) +{ + if (QVariant_isStringList(list)) { + QList<QString > lst = %CONVERTTOCPP[QList<QString>](list); + return QVariant(QStringList(lst)); + } + QVariant valueList = QVariant_convertToValueList(list); + if (valueList.isValid()) + return valueList; + + if (PySequence_Size(list) < 0) { + // clear the error if < 0 which means no length at all + PyErr_Clear(); + return QVariant(); + } + + QList<QVariant> lst; + Shiboken::AutoDecRef fast(PySequence_Fast(list, "Failed to convert QVariantList")); + const Py_ssize_t size = PySequence_Fast_GET_SIZE(fast.object()); + for (Py_ssize_t i = 0; i < size; ++i) { + PyObject *pyItem = PySequence_Fast_GET_ITEM(fast.object(), i); + QVariant item = %CONVERTTOCPP[QVariant](pyItem); + lst.append(item); + } + return QVariant(lst); +} +// @snippet qvariant-conversion + +// @snippet qvariantmap-register +Shiboken::Conversions::registerConverterName(SbkPySide2_QtCoreTypeConverters[SBK_QTCORE_QMAP_QSTRING_QVARIANT_IDX], "QVariantMap"); +// @snippet qvariantmap-register + +// @snippet qvariantmap-check +static bool QVariantType_isStringList(PyObject *list) +{ + Shiboken::AutoDecRef fast(PySequence_Fast(list, "Failed to convert QVariantList")); + const Py_ssize_t size = PySequence_Fast_GET_SIZE(fast.object()); + for (Py_ssize_t i=0; i < size; i++) { + PyObject *item = PySequence_Fast_GET_ITEM(fast.object(), i); + if (!%CHECKTYPE[QString](item)) + return false; + } + return true; +} +static bool QVariantType_checkAllStringKeys(PyObject *dict) +{ + Shiboken::AutoDecRef keys(PyDict_Keys(dict)); + return QVariantType_isStringList(keys); +} +// @snippet qvariantmap-check + +// @snippet qt-qabs +double _abs = qAbs(%1); +%PYARG_0 = %CONVERTTOPYTHON[double](_abs); +// @snippet qt-qabs + +// @snippet qt-postroutine +namespace PySide { +static QStack<PyObject*> globalPostRoutineFunctions; +void globalPostRoutineCallback() +{ + Shiboken::GilState state; + foreach (PyObject *callback, globalPostRoutineFunctions) { + Shiboken::AutoDecRef result(PyObject_CallObject(callback, NULL)); + Py_DECREF(callback); + } + globalPostRoutineFunctions.clear(); +} +void addPostRoutine(PyObject *callback) +{ + if (PyCallable_Check(callback)) { + globalPostRoutineFunctions << callback; + Py_INCREF(callback); + } else { + PyErr_SetString(PyExc_TypeError, "qAddPostRoutine: The argument must be a callable object."); + } +} +} // namespace +// @snippet qt-postroutine + +// @snippet qt-addpostroutine +PySide::addPostRoutine(%1); +// @snippet qt-addpostroutine + +// @snippet qt-qaddpostroutine +qAddPostRoutine(PySide::globalPostRoutineCallback); +// @snippet qt-qaddpostroutine + +// @snippet qt-version +QList<QByteArray> version = QByteArray(qVersion()).split('.'); +PyObject *pyQtVersion = PyTuple_New(3); +for (int i = 0; i < 3; ++i) + PyTuple_SET_ITEM(pyQtVersion, i, PyInt_FromLong(version[i].toInt())); +PyModule_AddObject(module, "__version_info__", pyQtVersion); +PyModule_AddStringConstant(module, "__version__", qVersion()); +// @snippet qt-version + +// @snippet qobject-connect-1 +// %FUNCTION_NAME() - disable generation of function call. +bool %0 = qobjectConnect(%1, %2, %CPPSELF, %3, %4); +%PYARG_0 = %CONVERTTOPYTHON[bool](%0); +// @snippet qobject-connect-1 + +// @snippet qobject-connect-2 +// %FUNCTION_NAME() - disable generation of function call. +bool %0 = qobjectConnect(%1, %2, %3, %4, %5); +%PYARG_0 = %CONVERTTOPYTHON[bool](%0); +// @snippet qobject-connect-2 + +// @snippet qobject-connect-3 +// %FUNCTION_NAME() - disable generation of function call. +bool %0 = qobjectConnect(%1, %2, %3, %4, %5); +%PYARG_0 = %CONVERTTOPYTHON[bool](%0); +// @snippet qobject-connect-3 + +// @snippet qobject-connect-4 +// %FUNCTION_NAME() - disable generation of function call. +%RETURN_TYPE %0 = qobjectConnectCallback(%1, %2, %PYARG_3, %4); +%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); +// @snippet qobject-connect-4 + +// @snippet qobject-connect-5 +// %FUNCTION_NAME() - disable generation of function call. +%RETURN_TYPE %0 = qobjectConnectCallback(%CPPSELF, %1, %PYARG_2, %3); +%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); +// @snippet qobject-connect-5 + +// @snippet qobject-connect-6 +// %FUNCTION_NAME() - disable generation of function call. +%RETURN_TYPE %0 = qobjectConnect(%CPPSELF, %1, %2, %3, %4); +%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); +// @snippet qobject-connect-6 + +// @snippet qobject-emit +%RETURN_TYPE %0 = PySide::SignalManager::instance().emitSignal(%CPPSELF, %1, %PYARG_2); +%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); +// @snippet qobject-emit + +// @snippet qobject-disconnect-1 +// %FUNCTION_NAME() - disable generation of function call. +%RETURN_TYPE %0 = qobjectDisconnectCallback(%CPPSELF, %1, %2); +%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); +// @snippet qobject-disconnect-1 + +// @snippet qobject-disconnect-2 +// %FUNCTION_NAME() - disable generation of function call. +%RETURN_TYPE %0 = qobjectDisconnectCallback(%1, %2, %3); +%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); +// @snippet qobject-disconnect-2 + +// @snippet qfatal +// qFatal doesn't have a stream version, so we do a +// qWarning call followed by a qFatal() call using a +// literal. +qWarning() << %1; +qFatal("[A qFatal() call was made from Python code]"); +// @snippet qfatal + +// @snippet moduleshutdown +PySide::runCleanupFunctions(); +// @snippet moduleshutdown + +// @snippet qt-pysideinit +Shiboken::Conversions::registerConverterName(SbkPySide2_QtCoreTypeConverters[SBK_QSTRING_IDX], "unicode"); +Shiboken::Conversions::registerConverterName(SbkPySide2_QtCoreTypeConverters[SBK_QSTRING_IDX], "str"); +Shiboken::Conversions::registerConverterName(SbkPySide2_QtCoreTypeConverters[SBK_QTCORE_QLIST_QVARIANT_IDX], "QVariantList"); + +PySide::registerInternalQtConf(); +PySide::init(module); +Py_AtExit(QtCoreModuleExit); +// @snippet qt-pysideinit + +// @snippet qt-messagehandler +// Define a global variable to handle qInstallMessageHandler callback +static PyObject *qtmsghandler = nullptr; + +static void msgHandlerCallback(QtMsgType type, const QMessageLogContext &ctx, const QString &msg) +{ + Shiboken::GilState state; + Shiboken::AutoDecRef arglist(PyTuple_New(3)); + PyTuple_SET_ITEM(arglist, 0, %CONVERTTOPYTHON[QtMsgType](type)); + PyTuple_SET_ITEM(arglist, 1, %CONVERTTOPYTHON[QMessageLogContext &](ctx)); + QByteArray array = msg.toLocal8Bit(); + char *data = array.data(); + PyTuple_SET_ITEM(arglist, 2, %CONVERTTOPYTHON[char *](data)); + Shiboken::AutoDecRef ret(PyObject_CallObject(qtmsghandler, arglist)); +} +static void QtCoreModuleExit() +{ + PySide::SignalManager::instance().clear(); +} +// @snippet qt-messagehandler + +// @snippet qt-installmessagehandler +if (%PYARG_1 == Py_None) { + qInstallMessageHandler(0); + %PYARG_0 = qtmsghandler ? qtmsghandler : Py_None; + qtmsghandler = 0; +} else if (!PyCallable_Check(%PYARG_1)) { + PyErr_SetString(PyExc_TypeError, "parameter must be callable"); +} else { + %PYARG_0 = qtmsghandler ? qtmsghandler : Py_None; + Py_INCREF(%PYARG_1); + qtmsghandler = %PYARG_1; + qInstallMessageHandler(msgHandlerCallback); +} + +if (%PYARG_0 == Py_None) + Py_INCREF(%PYARG_0); +// @snippet qt-installmessagehandler + +// @snippet qline-hash +namespace PySide { + template<> inline uint hash(const QLine &v) { + return qHash(qMakePair(qMakePair(v.x1(), v.y1()), qMakePair(v.x2(), v.y2()))); + } +}; +// @snippet qline-hash + +// @snippet qlinef-intersect +QPointF p; +%RETURN_TYPE retval = %CPPSELF.%FUNCTION_NAME(%ARGUMENT_NAMES, &p); +%PYARG_0 = PyTuple_New(2); +PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval)); +PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QPointF](p)); +// @snippet qlinef-intersect + +// @snippet qresource-data +const void *d = %CPPSELF.%FUNCTION_NAME(); +if (d) { + %PYARG_0 = Shiboken::Buffer::newObject(d, %CPPSELF.size()); +} else { + Py_INCREF(Py_None); + %PYARG_0 = Py_None; +} +// @snippet qresource-data + +// @snippet qdate-topython +if (!PyDateTimeAPI) + PySideDateTime_IMPORT; +%PYARG_0 = PyDate_FromDate(%CPPSELF.year(), %CPPSELF.month(), %CPPSELF.day()); +// @snippet qdate-topython + +// @snippet qdate-getdate +int year, month, day; +%BEGIN_ALLOW_THREADS +%CPPSELF.%FUNCTION_NAME(&year, &month, &day); +%END_ALLOW_THREADS +%PYARG_0 = PyTuple_New(3); +PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[int](year)); +PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[int](month)); +PyTuple_SET_ITEM(%PYARG_0, 2, %CONVERTTOPYTHON[int](day)); +// @snippet qdate-getdate + +// @snippet qdate-weeknumber +int yearNumber; +%BEGIN_ALLOW_THREADS +int week = %CPPSELF.%FUNCTION_NAME(&yearNumber); +%END_ALLOW_THREADS +%PYARG_0 = PyTuple_New(2); +PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[int](week)); +PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[int](yearNumber)); +// @snippet qdate-weeknumber + +// @snippet qdatetime-1 +QDate date(%1, %2, %3); +QTime time(%4, %5, %6, %7); +%0 = new %TYPE(date, time, Qt::TimeSpec(%8)); +// @snippet qdatetime-1 + +// @snippet qdatetime-2 +QDate date(%1, %2, %3); +QTime time(%4, %5, %6); +%0 = new %TYPE(date, time); +// @snippet qdatetime-2 + +// @snippet qdatetime-topython +QDate date = %CPPSELF.date(); +QTime time = %CPPSELF.time(); +if (!PyDateTimeAPI) PySideDateTime_IMPORT; +%PYARG_0 = PyDateTime_FromDateAndTime(date.year(), date.month(), date.day(), time.hour(), time.minute(), time.second(), time.msec()*1000); +// @snippet qdatetime-topython + +// @snippet qpoint +namespace PySide { + template<> inline uint hash(const QPoint &v) { + return qHash(qMakePair(v.x(), v.y())); + } +}; +// @snippet qpoint + +// @snippet qrect +namespace PySide { + template<> inline uint hash(const QRect &v) { + return qHash(qMakePair(qMakePair(v.x(), v.y()), qMakePair(v.width(), v.height()))); + } +}; +// @snippet qrect + +// @snippet qsize +namespace PySide { + template<> inline uint hash(const QSize &v) { + return qHash(qMakePair(v.width(), v.height())); + } +}; +// @snippet qsize + +// @snippet qtime-topython +if (!PyDateTimeAPI) + PySideDateTime_IMPORT; +%PYARG_0 = PyTime_FromTime(%CPPSELF.hour(), %CPPSELF.minute(), %CPPSELF.second(), %CPPSELF.msec()*1000); +// @snippet qtime-topython + +// @snippet qbitarray-len +return %CPPSELF.size(); +// @snippet qbitarray-len + +// @snippet qbitarray-getitem +if (_i < 0 || _i >= %CPPSELF.size()) { + PyErr_SetString(PyExc_IndexError, "index out of bounds"); + return 0; +} +bool ret = %CPPSELF.at(_i); +return %CONVERTTOPYTHON[bool](ret); +// @snippet qbitarray-getitem + +// @snippet qbitarray-setitem +PyObject *args = Py_BuildValue("(iiO)", _i, 1, _value); +PyObject *result = Sbk_QBitArrayFunc_setBit(self, args); +Py_DECREF(args); +Py_XDECREF(result); +return !result ? -1 : 0; +// @snippet qbitarray-setitem + +// @snippet unlock +%CPPSELF.unlock(); +// @snippet unlock + +// @snippet qabstractitemmodel-createindex +%RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(%1, %2, %PYARG_3); +%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); +// @snippet qabstractitemmodel-createindex + +// @snippet qabstractitemmodel +qRegisterMetaType<QVector<int> >("QVector<int>"); +// @snippet qabstractitemmodel + +// @snippet qobject-metaobject +%RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(); +%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); +// @snippet qobject-metaobject + +// @snippet qobject-findchild +QObject *child = _findChildHelper(%CPPSELF, %2, (PyTypeObject*)%PYARG_1); +%PYARG_0 = %CONVERTTOPYTHON[QObject*](child); +// @snippet qobject-findchild + +// @snippet qobject-findchildren-1 +%PYARG_0 = PyList_New(0); +_findChildrenHelper(%CPPSELF, %2, (PyTypeObject*)%PYARG_1, %PYARG_0); +// @snippet qobject-findchildren-1 + +// @snippet qobject-findchildren-2 +%PYARG_0 = PyList_New(0); +_findChildrenHelper(%CPPSELF, %2, (PyTypeObject*)%PYARG_1, %PYARG_0); +// @snippet qobject-findchildren-2 + +// @snippet qobject-tr +QString result; +if (QCoreApplication::instance()) { + PyObject *klass = PyObject_GetAttrString(%PYSELF, "__class__"); + PyObject *cname = PyObject_GetAttrString(klass, "__name__"); + result = QString(QCoreApplication::instance()->translate(Shiboken::String::toCString(cname), + /* %1, %2, QCoreApplication::CodecForTr, %3)); */ + %1, %2, %3)); + + Py_DECREF(klass); + Py_DECREF(cname); +} else { + result = QString(QString::fromLatin1(%1)); +} +%PYARG_0 = %CONVERTTOPYTHON[QString](result); +// @snippet qobject-tr + +// @snippet qobject-receivers +// Avoid return +1 because SignalManager connect to "destroyed()" signal to control object timelife +int ret = %CPPSELF.%FUNCTION_NAME(%1); +if (ret > 0 && ((strcmp(%1, SIGNAL(destroyed())) == 0) || (strcmp(%1, SIGNAL(destroyed(QObject*))) == 0))) + ret -= PySide::SignalManager::instance().countConnectionsWith(%CPPSELF); + +%PYARG_0 = %CONVERTTOPYTHON[int](ret); +// @snippet qobject-receivers + +// @snippet qregexp-replace +%1.replace(*%CPPSELF, %2); +%PYARG_0 = %CONVERTTOPYTHON[QString](%1); +// @snippet qregexp-replace + +// @snippet qbytearray-operatorplus-1 +QByteArray ba = QByteArray(PyBytes_AS_STRING(%PYARG_1), PyBytes_GET_SIZE(%PYARG_1)) + *%CPPSELF; +%PYARG_0 = %CONVERTTOPYTHON[QByteArray](ba); +// @snippet qbytearray-operatorplus-1 + +// @snippet qbytearray-operatorplus-2 +QByteArray ba = QByteArray(PyByteArray_AsString(%PYARG_1), PyByteArray_Size(%PYARG_1)) + *%CPPSELF; +%PYARG_0 = %CONVERTTOPYTHON[QByteArray](ba); +// @snippet qbytearray-operatorplus-2 + +// @snippet qbytearray-operatorplus-3 +QByteArray ba = *%CPPSELF + QByteArray(PyByteArray_AsString(%PYARG_1), PyByteArray_Size(%PYARG_1)); +%PYARG_0 = %CONVERTTOPYTHON[QByteArray](ba); +// @snippet qbytearray-operatorplus-3 + +// @snippet qbytearray-operatorplusequal +*%CPPSELF += QByteArray(PyByteArray_AsString(%PYARG_1), PyByteArray_Size(%PYARG_1)); +// @snippet qbytearray-operatorplusequal + +// @snippet qbytearray-operatorequalequal +if (PyUnicode_CheckExact(%PYARG_1)) { + Shiboken::AutoDecRef data(PyUnicode_AsASCIIString(%PYARG_1)); + QByteArray ba = QByteArray(PyBytes_AsString(data.object()), PyBytes_GET_SIZE(data.object())); + bool cppResult = %CPPSELF == ba; + %PYARG_0 = %CONVERTTOPYTHON[bool](cppResult); +} +// @snippet qbytearray-operatorequalequal + +// @snippet qbytearray-operatornotequal +if (PyUnicode_CheckExact(%PYARG_1)) { + Shiboken::AutoDecRef data(PyUnicode_AsASCIIString(%PYARG_1)); + QByteArray ba = QByteArray(PyBytes_AsString(data.object()), PyBytes_GET_SIZE(data.object())); + bool cppResult = %CPPSELF != ba; + %PYARG_0 = %CONVERTTOPYTHON[bool](cppResult); +} +// @snippet qbytearray-operatornotequal + +// @snippet qbytearray-operatorgreater +if (PyUnicode_CheckExact(%PYARG_1)) { + Shiboken::AutoDecRef data(PyUnicode_AsASCIIString(%PYARG_1)); + QByteArray ba = QByteArray(PyBytes_AsString(data.object()), PyBytes_GET_SIZE(data.object())); + bool cppResult = %CPPSELF > ba; + %PYARG_0 = %CONVERTTOPYTHON[bool](cppResult); +} +// @snippet qbytearray-operatorgreater + +// @snippet qbytearray-operatorgreaterequal +if (PyUnicode_CheckExact(%PYARG_1)) { + Shiboken::AutoDecRef data(PyUnicode_AsASCIIString(%PYARG_1)); + QByteArray ba = QByteArray(PyBytes_AsString(data.object()), PyBytes_GET_SIZE(data.object())); + bool cppResult = %CPPSELF >= ba; + %PYARG_0 = %CONVERTTOPYTHON[bool](cppResult); +} +// @snippet qbytearray-operatorgreaterequal + +// @snippet qbytearray-operatorlower +if (PyUnicode_CheckExact(%PYARG_1)) { + Shiboken::AutoDecRef data(PyUnicode_AsASCIIString(%PYARG_1)); + QByteArray ba = QByteArray(PyBytes_AsString(data.object()), PyBytes_GET_SIZE(data.object())); + bool cppResult = %CPPSELF < ba; + %PYARG_0 = %CONVERTTOPYTHON[bool](cppResult); +} +// @snippet qbytearray-operatorlower + +// @snippet qbytearray-operatorlowerequal +if (PyUnicode_CheckExact(%PYARG_1)) { + Shiboken::AutoDecRef data(PyUnicode_AsASCIIString(%PYARG_1)); + QByteArray ba = QByteArray(PyBytes_AsString(data.object()), PyBytes_GET_SIZE(data.object())); + bool cppResult = %CPPSELF <= ba; + %PYARG_0 = %CONVERTTOPYTHON[bool](cppResult); +} +// @snippet qbytearray-operatorlowerequal + +// @snippet qbytearray-repr +PyObject *aux = PyBytes_FromStringAndSize(%CPPSELF.constData(), %CPPSELF.size()); +if (aux == NULL) { + return NULL; +} +QByteArray b(Py_TYPE(%PYSELF)->tp_name); +#ifdef IS_PY3K + %PYARG_0 = PyUnicode_FromFormat("%s(%R)", b.constData(), aux); +#else + aux = PyObject_Repr(aux); + b += '('; + b += QByteArray(PyBytes_AS_STRING(aux), PyBytes_GET_SIZE(aux)); + b += ')'; + %PYARG_0 = Shiboken::String::fromStringAndSize(b.constData(), b.size()); +#endif +Py_DECREF(aux); +// @snippet qbytearray-repr + +// @snippet qbytearray-1 +if (PyBytes_Check(%PYARG_1)) { + %0 = new QByteArray(PyBytes_AsString(%PYARG_1), PyBytes_GET_SIZE(%PYARG_1)); +} else if (Shiboken::String::check(%PYARG_1)) { + %0 = new QByteArray(Shiboken::String::toCString(%PYARG_1), Shiboken::String::len(%PYARG_1)); +} +// @snippet qbytearray-1 + +// @snippet qbytearray-2 +%0 = new QByteArray(PyByteArray_AsString(%PYARG_1), PyByteArray_Size(%PYARG_1)); +// @snippet qbytearray-2 + +// @snippet qbytearray-3 +%0 = new QByteArray(PyBytes_AS_STRING(%PYARG_1), PyBytes_GET_SIZE(%PYARG_1)); +// @snippet qbytearray-3 + +// @snippet qbytearray-py3 +#if PY_VERSION_HEX < 0x03000000 + Shiboken::SbkType<QByteArray>()->tp_as_buffer = &SbkQByteArrayBufferProc; + Shiboken::SbkType<QByteArray>()->tp_flags |= Py_TPFLAGS_HAVE_GETCHARBUFFER; +#endif +// @snippet qbytearray-py3 + +// @snippet qbytearray-data +%PYARG_0 = PyBytes_FromStringAndSize(%CPPSELF.%FUNCTION_NAME(), %CPPSELF.size()); +// @snippet qbytearray-data + +// @snippet qbytearray-fromrawdata +%RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(PyBytes_AsString(%PYARG_1), PyBytes_GET_SIZE(%PYARG_1)); +%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); +// @snippet qbytearray-fromrawdata + +// @snippet qbytearray-str +PyObject *aux = PyBytes_FromStringAndSize(%CPPSELF.constData(), %CPPSELF.size()); +if (aux == NULL) { + return NULL; +} +#ifdef IS_PY3K + %PYARG_0 = PyObject_Repr(aux); + Py_DECREF(aux); +#else + %PYARG_0 = aux; +#endif +// @snippet qbytearray-str + +// @snippet qbytearray-len +return %CPPSELF.count(); +// @snippet qbytearray-len + +// @snippet qbytearray-getitem +if (_i < 0 || _i >= %CPPSELF.size()) { + PyErr_SetString(PyExc_IndexError, "index out of bounds"); + return 0; +} else { + char res[2]; + res[0] = %CPPSELF.at(_i); + res[1] = 0; + return PyBytes_FromStringAndSize(res, 1); +} +// @snippet qbytearray-getitem + +// @snippet qbytearray-setitem +%CPPSELF.remove(_i, 1); +PyObject *args = Py_BuildValue("(nO)", _i, _value); +PyObject *result = Sbk_QByteArrayFunc_insert(self, args); +Py_DECREF(args); +Py_XDECREF(result); +return !result ? -1 : 0; +// @snippet qbytearray-setitem + +// @snippet qfiledevice-unmap +uchar *ptr = reinterpret_cast<uchar*>(Shiboken::Buffer::getPointer(%PYARG_1)); +%RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(ptr); +%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); +// @snippet qfiledevice-unmap + +// @snippet qfiledevice-map +%PYARG_0 = Shiboken::Buffer::newObject(%CPPSELF.%FUNCTION_NAME(%1, %2, %3), %2, Shiboken::Buffer::ReadWrite); +// @snippet qfiledevice-map + +// @snippet qiodevice-readdata +QByteArray ba(1 + int(%2), char(0)); +%CPPSELF.%FUNCTION_NAME(ba.data(), int(%2)); +%PYARG_0 = Shiboken::String::fromCString(ba.constData()); +// @snippet qiodevice-readdata + +// @snippet qcryptographichash-adddata +%CPPSELF.%FUNCTION_NAME(Shiboken::String::toCString(%PYARG_1), Shiboken::String::len(%PYARG_1)); +// @snippet qcryptographichash-adddata + +// @snippet qsocketnotifier +Shiboken::AutoDecRef socket(%PYARG_1); +if (!socket.isNull()) { + // We use qintptr as PyLong, but we check for int + // since it is currently an alias to be Python2 compatible. + // Internally, ints are qlonglongs. + if (%CHECKTYPE[int](socket)) { + int cppSocket = %CONVERTTOCPP[int](socket); + qintptr socket = (qintptr)cppSocket; + %0 = new %TYPE(socket, %2, %3); + } else { + PyErr_SetString(PyExc_TypeError, + "QSocketNotifier: first argument (socket) must be an int."); + } +} +// @snippet qsocketnotifier + +// @snippet qtranslator-load +Py_ssize_t size; +uchar *ptr = reinterpret_cast<uchar*>(Shiboken::Buffer::getPointer(%PYARG_1, &size)); +%RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(const_cast<const uchar*>(ptr), size); +%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); +// @snippet qtranslator-load + +// @snippet qtimer-singleshot-1 +// %FUNCTION_NAME() - disable generation of c++ function call +(void) %2; // remove warning about unused variable +Shiboken::AutoDecRef emptyTuple(PyTuple_New(0)); +PyObject *pyTimer = reinterpret_cast<PyTypeObject *>(Shiboken::SbkType<QTimer>())->tp_new(Shiboken::SbkType<QTimer>(), emptyTuple, 0); +reinterpret_cast<PyTypeObject *>(Shiboken::SbkType<QTimer>())->tp_init(pyTimer, emptyTuple, 0); + +QTimer* timer = %CONVERTTOCPP[QTimer*](pyTimer); +Shiboken::AutoDecRef result( + PyObject_CallMethod(pyTimer, + const_cast<char*>("connect"), + const_cast<char*>("OsOs"), + pyTimer, + SIGNAL(timeout()), + %PYARG_2, + %3) +); +Shiboken::Object::releaseOwnership((SbkObject*)pyTimer); +Py_XDECREF(pyTimer); +timer->setSingleShot(true); +timer->connect(timer, SIGNAL(timeout()), timer, SLOT(deleteLater())); +timer->start(%1); +// @snippet qtimer-singleshot-1 + +// @snippet qtimer-singleshot-2 +// %FUNCTION_NAME() - disable generation of c++ function call +Shiboken::AutoDecRef emptyTuple(PyTuple_New(0)); +PyObject *pyTimer = reinterpret_cast<PyTypeObject *>(Shiboken::SbkType<QTimer>())->tp_new(Shiboken::SbkType<QTimer>(), emptyTuple, 0); +reinterpret_cast<PyTypeObject *>(Shiboken::SbkType<QTimer>())->tp_init(pyTimer, emptyTuple, 0); +QTimer* timer = %CONVERTTOCPP[QTimer*](pyTimer); +timer->setSingleShot(true); + +if (PyObject_TypeCheck(%2, PySideSignalInstanceTypeF())) { + PySideSignalInstance *signalInstance = reinterpret_cast<PySideSignalInstance*>(%2); + Shiboken::AutoDecRef signalSignature(Shiboken::String::fromFormat("2%s", PySide::Signal::getSignature(signalInstance))); + Shiboken::AutoDecRef result( + PyObject_CallMethod(pyTimer, + const_cast<char*>("connect"), + const_cast<char*>("OsOO"), + pyTimer, + SIGNAL(timeout()), + PySide::Signal::getObject(signalInstance), + signalSignature.object()) + ); +} else { + Shiboken::AutoDecRef result( + PyObject_CallMethod(pyTimer, + const_cast<char*>("connect"), + const_cast<char*>("OsO"), + pyTimer, + SIGNAL(timeout()), + %PYARG_2) + ); +} + +timer->connect(timer, SIGNAL(timeout()), timer, SLOT(deleteLater()), Qt::DirectConnection); +Shiboken::Object::releaseOwnership((SbkObject*)pyTimer); +Py_XDECREF(pyTimer); +timer->start(%1); +// @snippet qtimer-singleshot-2 + +// @snippet qprocess-startdetached +qint64 pid; +%RETURN_TYPE retval = %TYPE::%FUNCTION_NAME(%1, %2, %3, &pid); +%PYARG_0 = PyTuple_New(2); +PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval)); +PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[qint64](pid)); +// @snippet qprocess-startdetached + +// @snippet qprocess-pid +long result; +#ifdef WIN32 + _PROCESS_INFORMATION *procInfo = %CPPSELF.%FUNCTION_NAME(); + result = procInfo ? procInfo->dwProcessId : 0; +#else + result = %CPPSELF.%FUNCTION_NAME(); +#endif +%PYARG_0 = %CONVERTTOPYTHON[long](result); +// @snippet qprocess-pid + +// @snippet qcoreapplication-1 +QCoreApplicationConstructor(%PYSELF, args, &%0); +// @snippet qcoreapplication-1 + +// @snippet qcoreapplication-2 +PyObject *empty = PyTuple_New(2); +if (!PyTuple_SetItem(empty, 0, PyList_New(0))) { + QCoreApplicationConstructor(%PYSELF, empty, &%0); +} +// @snippet qcoreapplication-2 + +// @snippet qcoreapplication-instance +QCoreApplication *app = QCoreApplication::instance(); +PyObject *pyApp = Py_None; +if (app) { + pyApp = reinterpret_cast<PyObject*>( + Shiboken::BindingManager::instance().retrieveWrapper(app)); + if (!pyApp) + pyApp = %CONVERTTOPYTHON[QCoreApplication*](app); + // this will keep app live after python exit (extra ref) +} +// PYSIDE-571: make sure that we return the singleton "None" +if (pyApp == Py_None) + Py_DECREF(MakeSingletonQAppWrapper(0)); // here qApp and instance() diverge +%PYARG_0 = pyApp; +Py_XINCREF(%PYARG_0); +// @snippet qcoreapplication-instance + +// @snippet qdatastream-readrawdata +QByteArray data; +data.resize(%2); +int result = %CPPSELF.%FUNCTION_NAME(data.data(), data.size()); +if (result == -1) { + Py_INCREF(Py_None); + %PYARG_0 = Py_None; +} else { + %PYARG_0 = PyBytes_FromStringAndSize(data.data(), result); +} +// @snippet qdatastream-readrawdata + +// @snippet qdatastream-writerawdata +int r = %CPPSELF.%FUNCTION_NAME(%1, Shiboken::String::len(%PYARG_1)); +%PYARG_0 = %CONVERTTOPYTHON[int](r); +// @snippet qdatastream-writerawdata + +// @snippet releaseownership +Shiboken::Object::releaseOwnership(%PYARG_0); +// @snippet releaseownership + +// @snippet qanimationgroup-clear +for (int counter = 0, count = %CPPSELF.animationCount(); counter < count; ++counter ) { + QAbstractAnimation *animation = %CPPSELF.animationAt(counter); + PyObject *obj = %CONVERTTOPYTHON[QAbstractAnimation*](animation); + Shiboken::Object::setParent(nullptr, obj); + Py_DECREF(obj); +} +%CPPSELF.clear(); +// @snippet qanimationgroup-clear + +// @snippet qeasingcurve +PySideEasingCurveFunctor::init(); +// @snippet qeasingcurve + +// @snippet qeasingcurve-setcustomtype +QEasingCurve::EasingFunction func = PySideEasingCurveFunctor::createCustomFuntion(%PYSELF, %PYARG_1); +if (func) + %CPPSELF.%FUNCTION_NAME(func); +// @snippet qeasingcurve-setcustomtype + +// @snippet qeasingcurve-customtype +//%FUNCTION_NAME() +%PYARG_0 = PySideEasingCurveFunctor::callable(%PYSELF); +// @snippet qeasingcurve-customtype + +// @snippet qsignaltransition +if (PyObject_TypeCheck(%1, PySideSignalInstanceTypeF())) { + PyObject *dataSource = PySide::Signal::getObject((PySideSignalInstance*)%PYARG_1); + Shiboken::AutoDecRef obType(PyObject_Type(dataSource)); + QObject* sender = %CONVERTTOCPP[QObject*](dataSource); + if (sender) { + const char*dataSignature = PySide::Signal::getSignature((PySideSignalInstance*)%PYARG_1); + QByteArray signature(dataSignature); // Append SIGNAL flag (2) + signature.prepend('2'); + %0 = new QSignalTransitionWrapper(sender, signature, %2); + } +} +// @snippet qsignaltransition + +// @snippet qstate-addtransition-1 +QString signalName(%2); +if (PySide::SignalManager::registerMetaMethod(%1, signalName.mid(1).toLatin1().data(), QMetaMethod::Signal)) { + QSignalTransition *%0 = %CPPSELF->addTransition(%1, %2, %3); + %PYARG_0 = %CONVERTTOPYTHON[QSignalTransition*](%0); +} else { + Py_INCREF(Py_None); + %PYARG_0 = Py_None; +} +// @snippet qstate-addtransition-1 + +// @snippet qstate-addtransition-2 +// Obviously the label used by the following goto is a very awkward solution, +// since it refers to a name very tied to the generator implementation. +// Check bug #362 for more information on this +// http://bugs.openbossa.org/show_bug.cgi?id=362 +if (!PyObject_TypeCheck(%1, PySideSignalInstanceTypeF())) + goto Sbk_%TYPEFunc_%FUNCTION_NAME_TypeError; +PySideSignalInstance *signalInstance = reinterpret_cast<PySideSignalInstance*>(%1); +QObject* sender = %CONVERTTOCPP[QObject*](PySide::Signal::getObject(signalInstance)); +QSignalTransition *%0 = %CPPSELF->%FUNCTION_NAME(sender, PySide::Signal::getSignature(signalInstance),%2); +%PYARG_0 = %CONVERTTOPYTHON[QSignalTransition*](%0); +// @snippet qstate-addtransition-2 + +// @snippet qstatemachine-configuration +%PYARG_0 = PySet_New(0); +foreach (QAbstractState *abs_state, %CPPSELF.configuration()) { + Shiboken::AutoDecRef obj(%CONVERTTOPYTHON[QAbstractState*](abs_state)); + Shiboken::Object::setParent(self, obj); + PySet_Add(%PYARG_0, obj); +} +// @snippet qstatemachine-configuration + +// @snippet qstatemachine-defaultanimations +%PYARG_0 = PyList_New(0); +foreach (QAbstractAnimation *abs_anim, %CPPSELF.defaultAnimations()) { + Shiboken::AutoDecRef obj(%CONVERTTOPYTHON[QAbstractAnimation*](abs_anim)); + Shiboken::Object::setParent(self, obj); + PyList_Append(%PYARG_0, obj); +} +// @snippet qstatemachine-defaultanimations + +// @snippet qt-signal +%PYARG_0 = Shiboken::String::fromFormat("2%s",QMetaObject::normalizedSignature(%1).constData()); +// @snippet qt-signal + +// @snippet qt-slot +%PYARG_0 = Shiboken::String::fromFormat("1%s",QMetaObject::normalizedSignature(%1).constData()); +// @snippet qt-slot + +// @snippet qt-registerresourcedata +QT_BEGIN_NAMESPACE +extern bool +qRegisterResourceData(int, + const unsigned char *, + const unsigned char *, + const unsigned char *); + +extern bool +qUnregisterResourceData(int, + const unsigned char *, + const unsigned char *, + const unsigned char *); +QT_END_NAMESPACE +// @snippet qt-registerresourcedata + +// @snippet qt-qregisterresourcedata +%RETURN_TYPE %0 = %FUNCTION_NAME(%1, reinterpret_cast<uchar*>(PyBytes_AS_STRING(%PYARG_2)), + reinterpret_cast<uchar*>(PyBytes_AS_STRING(%PYARG_3)), + reinterpret_cast<uchar*>(PyBytes_AS_STRING(%PYARG_4))); +%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); +// @snippet qt-qregisterresourcedata + +// @snippet qt-qunregisterresourcedata +%RETURN_TYPE %0 = %FUNCTION_NAME(%1, reinterpret_cast<uchar*>(PyBytes_AS_STRING(%PYARG_2)), + reinterpret_cast<uchar*>(PyBytes_AS_STRING(%PYARG_3)), + reinterpret_cast<uchar*>(PyBytes_AS_STRING(%PYARG_4))); +%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); +// @snippet qt-qunregisterresourcedata diff --git a/sources/pyside2/PySide2/glue/qtdatavisualization.cpp b/sources/pyside2/PySide2/glue/qtdatavisualization.cpp new file mode 100644 index 000000000..119d79a40 --- /dev/null +++ b/sources/pyside2/PySide2/glue/qtdatavisualization.cpp @@ -0,0 +1,42 @@ +/**************************************************************************** +** +** Copyright (C) 2018 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qt for Python. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// @snippet releaseownership +Shiboken::Object::releaseOwnership(%PYARG_1); +// @snippet releaseownership diff --git a/sources/pyside2/PySide2/glue/qtgui.cpp b/sources/pyside2/PySide2/glue/qtgui.cpp new file mode 100644 index 000000000..7f638e5cd --- /dev/null +++ b/sources/pyside2/PySide2/glue/qtgui.cpp @@ -0,0 +1,494 @@ +/**************************************************************************** +** +** Copyright (C) 2018 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qt for Python. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// @snippet qtransform-quadtoquad +QTransform _result; +if (QTransform::quadToQuad(%1, %2, _result)) { + %PYARG_0 = %CONVERTTOPYTHON[QTransform](_result); +} else { + Py_INCREF(Py_None); + %PYARG_0 = Py_None; +} +// @snippet qtransform-quadtoquad + +// @snippet qtransform-quadtosquare +QTransform _result; +if (QTransform::quadToSquare(%1, _result)) { + %PYARG_0 = %CONVERTTOPYTHON[QTransform](_result); +} else { + Py_INCREF(Py_None); + %PYARG_0 = Py_None; +} +// @snippet qtransform-quadtosquare + +// @snippet qtransform-squaretoquad +QTransform _result; +if (QTransform::squareToQuad(%1, _result)) { + %PYARG_0 = %CONVERTTOPYTHON[QTransform](_result); +} else { + Py_INCREF(Py_None); + %PYARG_0 = Py_None; +} +// @snippet qtransform-squaretoquad + +// @snippet qbitmap-fromdata +uchar *buffer = reinterpret_cast<uchar*>(Shiboken::Buffer::getPointer(%PYARG_2)); +QBitmap %0 = QBitmap::fromData(%1, buffer, %3); +%PYARG_0 = %CONVERTTOPYTHON[QBitmap](%0); +// @snippet qbitmap-fromdata + +// @snippet qtextline-cursortox +%BEGIN_ALLOW_THREADS +%RETURN_TYPE %0 = %CPPSELF->::%TYPE::%FUNCTION_NAME(&%1, %2); +%END_ALLOW_THREADS +%PYARG_0 = PyTuple_New(2); +PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](%0)); +PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[%ARG1_TYPE](%1)); +// @snippet qtextline-cursortox + +// @snippet qkeysequence-getitem +if (_i < 0 || _i >= %CPPSELF.count()) { + PyErr_SetString(PyExc_IndexError, "index out of bounds"); + return 0; +} +int item = (*%CPPSELF)[_i]; +return %CONVERTTOPYTHON[int](item); +// @snippet qkeysequence-getitem + +// @snippet qpicture-data +%PYARG_0 = Shiboken::Buffer::newObject(%CPPSELF.data(), %CPPSELF.size()); +// @snippet qpicture-data + +// @snippet qtextblock-setuserdata +const QTextDocument *doc = %CPPSELF.document(); +if (doc) { + Shiboken::AutoDecRef pyDocument(%CONVERTTOPYTHON[QTextDocument*](doc)); + Shiboken::Object::setParent(pyDocument, %PYARG_1); +} +// @snippet qtextblock-setuserdata + +// @snippet qtextblock-userdata +const QTextDocument *doc = %CPPSELF.document(); +if (doc) { + Shiboken::AutoDecRef pyDocument(%CONVERTTOPYTHON[QTextDocument*](doc)); + Shiboken::Object::setParent(pyDocument, %PYARG_0); +} +// @snippet qtextblock-userdata + +// @snippet qpolygon-reduce +PyObject *points = PyList_New(%CPPSELF.count()); +for (int i = 0, max = %CPPSELF.count(); i < max; ++i){ + int x, y; + %CPPSELF.point(i, &x, &y); + QPoint pt = QPoint(x, y); + PyList_SET_ITEM(points, i, %CONVERTTOPYTHON[QPoint](pt)); +} +// @snippet qpolygon-reduce + +// @snippet qpolygon-operatorlowerlower +// %FUNCTION_NAME() +*%CPPSELF << %1; +%PYARG_0 = %CONVERTTOPYTHON[QPolygon*](%CPPSELF); +// @snippet qpolygon-operatorlowerlower + +// @snippet qpixmap +%0 = new %TYPE(QPixmap::fromImage(%1)); +// @snippet qpixmap + +// @snippet qimage-constbits +%PYARG_0 = Shiboken::Buffer::newObject(%CPPSELF.%FUNCTION_NAME(), %CPPSELF.byteCount()); +// @snippet qimage-constbits + +// @snippet qimage-bits +// byteCount() is only available on Qt4.7, so we use bytesPerLine * height +%PYARG_0 = Shiboken::Buffer::newObject(%CPPSELF.%FUNCTION_NAME(), %CPPSELF.bytesPerLine() * %CPPSELF.height(), Shiboken::Buffer::ReadWrite); +// @snippet qimage-bits + +// @snippet qimage-constscanline +%PYARG_0 = Shiboken::Buffer::newObject(%CPPSELF.%FUNCTION_NAME(%1), %CPPSELF.bytesPerLine()); +// @snippet qimage-constscanline + +// @snippet qimage-scanline +%PYARG_0 = Shiboken::Buffer::newObject(%CPPSELF.%FUNCTION_NAME(%1), %CPPSELF.bytesPerLine(), Shiboken::Buffer::ReadWrite); +// @snippet qimage-scanline + +// @snippet qcolor-setstate +Shiboken::AutoDecRef func(PyObject_GetAttr(%PYSELF, PyTuple_GET_ITEM(%1, 0))); +PyObject *args = PyTuple_GET_ITEM(%1, 1); +%PYARG_0 = PyObject_Call(func, args, NULL); +// @snippet qcolor-setstate + +// @snippet qcolor-reduce +switch (%CPPSELF.spec()) { + case QColor::Rgb: + { + qreal r, g, b, a; + %CPPSELF.getRgbF(&r, &g, &b, &a); + %PYARG_0 = Py_BuildValue("(ON(s(ffff)))", Py_TYPE(%PYSELF), PyTuple_New(0), + "setRgbF", float(r), float(g), float(b), float(a)); + break; + } + case QColor::Hsv: + { + qreal h, s, v, a; + %CPPSELF.getHsvF(&h, &s, &v, &a); + %PYARG_0 = Py_BuildValue("(ON(s(ffff)))", Py_TYPE(%PYSELF), PyTuple_New(0), + "setHsvF", float(h), float(s), float(v), float(a)); + break; + } + case QColor::Cmyk: + { + qreal c, m, y, k, a; + %CPPSELF.getCmykF(&c, &m, &y, &k, &a); + %PYARG_0 = Py_BuildValue("(ON(s(fffff)))", Py_TYPE(%PYSELF), PyTuple_New(0), + "setCmykF", float(c), float(m), float(y), float(k), float(a)); + break; + } + case QColor::Hsl: + { + qreal h, s, l, a; + %CPPSELF.getHslF(&h, &s, &l, &a); + %PYARG_0 = Py_BuildValue("(ON(s(ffff)))", Py_TYPE(%PYSELF), PyTuple_New(0), + "setHslF", float(h), float(s), float(l), float(a)); + break; + } + default: + { + %PYARG_0 = Py_BuildValue("(N(O))", PyObject_Type(%PYSELF), Py_None); + } +} +// @snippet qcolor-reduce + +// @snippet qcolor-totuple +switch (%CPPSELF.spec()) { + case QColor::Rgb: + { + int r, g, b, a; + %CPPSELF.getRgb(&r, &g, &b, &a); + %PYARG_0 = Py_BuildValue("iiii", r, g, b, a); + break; + } + case QColor::Hsv: + { + int h, s, v, a; + %CPPSELF.getHsv(&h, &s, &v, &a); + %PYARG_0 = Py_BuildValue("iiii", h, s, v, a); + break; + } + case QColor::Cmyk: + { + int c, m, y, k, a; + %CPPSELF.getCmyk(&c, &m, &y, &k, &a); + %PYARG_0 = Py_BuildValue("iiiii", c, m, y, k, a); + break; + } + case QColor::Hsl: + { + int h, s, l, a; + %CPPSELF.getHsl(&h, &s, &l, &a); + %PYARG_0 = Py_BuildValue("iiii", h, s, l, a); + break; + } + default: + { + %PYARG_0 = 0; + } +} +// @snippet qcolor-totuple + +// @snippet qcolor +if (%1.type() == QVariant::Color) + %0 = new %TYPE(%1.value<QColor>()); +else + PyErr_SetString(PyExc_TypeError, "QVariant must be holding a QColor"); +// @snippet qcolor + +// @snippet qfontmetricsf-boundingrect +int *array = nullptr; +bool errorOccurred = false; + +if (numArgs == 5) { + array = Shiboken::sequenceToIntArray(%PYARG_5, true); + if (PyErr_Occurred()) { + delete [] array; + errorOccurred = true; + } +} + +if (!errorOccurred) { + %RETURN_TYPE retval = %CPPSELF.%FUNCTION_NAME(%1, %2, %3, %4, array); + + delete [] array; + + %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](retval); +} +// @snippet qfontmetricsf-boundingrect + +// @snippet qfontmetricsf-size +int *array = nullptr; +bool errorOccurred = false; + +if (numArgs == 4) { + array = Shiboken::sequenceToIntArray(%PYARG_4, true); + if (PyErr_Occurred()) { + delete [] array; + errorOccurred = true; + } +} + +if (!errorOccurred) { + %RETURN_TYPE retval = %CPPSELF.%FUNCTION_NAME(%1, %2, %3, array); + + delete [] array; + + %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](retval); +} +// @snippet qfontmetricsf-size + +// @snippet qfontmetrics-boundingrect-1 +int *array = nullptr; +bool errorOccurred = false; + +if (numArgs == 8) { + array = Shiboken::sequenceToIntArray(%PYARG_8, true); + if (PyErr_Occurred()) { + delete [] array; + errorOccurred = true; + } +} + +if (!errorOccurred) { + %RETURN_TYPE retval = %CPPSELF.%FUNCTION_NAME(%1, %2, %3, %4, %5, %6, %7, array); + + delete [] array; + + %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](retval); +} +// @snippet qfontmetrics-boundingrect-1 + +// @snippet qfontmetrics-boundingrect-2 +int *array = nullptr; +bool errorOccurred = false; + +if (numArgs == 5) { + array = Shiboken::sequenceToIntArray(%PYARG_5, true); + if (PyErr_Occurred()) { + delete [] array; + errorOccurred = true; + } +} + +if (!errorOccurred) { + %RETURN_TYPE retval = %CPPSELF.%FUNCTION_NAME(%1, %2, %3, %4, array); + + delete [] array; + + %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](retval); +} +// @snippet qfontmetrics-boundingrect-2 + +// @snippet qfontmetrics-size +int *array = nullptr; +bool errorOccurred = false; + +if (numArgs == 4) { + array = Shiboken::sequenceToIntArray(%PYARG_4, true); + if (PyErr_Occurred()) { + delete [] array; + errorOccurred = true; + } +} + +if (!errorOccurred) { + %RETURN_TYPE retval = %CPPSELF.%FUNCTION_NAME(%1, %2, %3, array); + + delete [] array; + + %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](retval); +} +// @snippet qfontmetrics-size + +// @snippet qpixmapcache-find +QPixmap p; +if (%CPPSELF.%FUNCTION_NAME(%1, &p)) { + %PYARG_0 = %CONVERTTOPYTHON[QPixmap](p); +} else { + %PYARG_0 = Py_None; + Py_INCREF(%PYARG_0); +} +// @snippet qpixmapcache-find + +// @snippet qstandarditem-setchild-1 +// Clear parent from the old child +QStandardItem *_i = %CPPSELF->child(%1, %2); +if (_i) { + PyObject *_pyI = %CONVERTTOPYTHON[QStandardItem*](_i); + Shiboken::Object::setParent(nullptr, _pyI); +} +// @snippet qstandarditem-setchild-1 + +// @snippet qstandarditem-setchild-2 +// Clear parent from the old child +QStandardItem *_i = %CPPSELF->child(%1); +if (_i) { + PyObject *_pyI = %CONVERTTOPYTHON[QStandardItem*](_i); + Shiboken::Object::setParent(nullptr, _pyI); +} +// @snippet qstandarditem-setchild-2 + +// @snippet qkeyevent-operatornotequal +bool ret = !(&%CPPSELF == %1); +%PYARG_0 = %CONVERTTOPYTHON[bool](ret); +// @snippet qkeyevent-operatornotequal + +// @snippet qstandarditemmodel-setitem-1 +// Clear parent from the old child +QStandardItem *_i = %CPPSELF->item(%1, %2); +if (_i) { + PyObject *_pyI = %CONVERTTOPYTHON[QStandardItem*](_i); + Shiboken::Object::setParent(nullptr, _pyI); +} +// @snippet qstandarditemmodel-setitem-1 + +// @snippet qstandarditemmodel-setitem-2 +// Clear parent from the old child +QStandardItem *_i = %CPPSELF->item(%1); +if (_i) { + PyObject *_pyI = %CONVERTTOPYTHON[QStandardItem*](_i); + Shiboken::Object::setParent(nullptr, _pyI); +} +// @snippet qstandarditemmodel-setitem-2 + +// @snippet qstandarditemmodel-setverticalheaderitem +// Clear parent from the old child +QStandardItem *_i = %CPPSELF->verticalHeaderItem(%1); +if (_i) { + PyObject *_pyI = %CONVERTTOPYTHON[QStandardItem*](_i); + Shiboken::Object::setParent(nullptr, _pyI); +} +// @snippet qstandarditemmodel-setverticalheaderitem + +// @snippet qstandarditemmodel-clear +Shiboken::BindingManager &bm = Shiboken::BindingManager::instance(); +SbkObject *pyRoot = bm.retrieveWrapper(%CPPSELF.invisibleRootItem()); +if (pyRoot) { + Shiboken::Object::destroy(pyRoot, %CPPSELF.invisibleRootItem()); +} + +for (int r=0, r_max = %CPPSELF.rowCount(); r < r_max; r++) { + QList<QStandardItem *> ri = %CPPSELF.takeRow(0); + + PyObject *pyResult = %CONVERTTOPYTHON[QList<QStandardItem * >](ri); + Shiboken::Object::setParent(Py_None, pyResult); + Py_XDECREF(pyResult); +} +// @snippet qstandarditemmodel-clear + +// @snippet qclipboard-text +%BEGIN_ALLOW_THREADS +%RETURN_TYPE retval_ = %CPPSELF.%FUNCTION_NAME(%1, %2); +%END_ALLOW_THREADS +%PYARG_0 = PyTuple_New(2); +PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval_)); +PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[%ARG1_TYPE](%1)); +// @snippet qclipboard-text + +// @snippet qpainter-drawpolygon +%BEGIN_ALLOW_THREADS +%CPPSELF.%FUNCTION_NAME(%1.data(), %1.size(), %2); +%END_ALLOW_THREADS +// @snippet qpainter-drawpolygon + +// @snippet qmatrix4x4 +if (PySequence_Size(%PYARG_1) == 16) { + float values[16]; + for (int i=0; i < 16; ++i) { + PyObject *pv = PySequence_Fast_GET_ITEM(%PYARG_1, i); + values[i] = PyFloat_AsDouble(pv); + } + + %0 = new %TYPE(values[0], values[1], values[2], values[3], + values[4], values[5], values[6], values[7], + values[8], values[9], values[10], values[11], + values[12], values[13], values[14], values[15]); +} +// @snippet qmatrix4x4 + +// @snippet qmatrix4x4-copydatato +float values[16]; +%CPPSELF.%FUNCTION_NAME(values); +%PYARG_0 = PyTuple_New(16); +for (int i = 0; i < 16; ++i) { + PyObject *v = PyFloat_FromDouble(values[i]); + PyTuple_SET_ITEM(%PYARG_0, i, v); +} +// @snippet qmatrix4x4-copydatato + +// @snippet qmatrix4x4-mgetitem +if (PySequence_Check(_key)) { + Shiboken::AutoDecRef key(PySequence_Fast(_key, "Invalid matrix index.")); + if (PySequence_Fast_GET_SIZE(key.object()) == 2) { + PyObject *posx = PySequence_Fast_GET_ITEM(key.object(), 0); + PyObject *posy = PySequence_Fast_GET_ITEM(key.object(), 1); + Py_ssize_t x = PyInt_AsSsize_t(posx); + Py_ssize_t y = PyInt_AsSsize_t(posy); + float ret = (*%CPPSELF)(x,y); + return %CONVERTTOPYTHON[float](ret); + } +} +PyErr_SetString(PyExc_IndexError, "Invalid matrix index."); +return 0; +// @snippet qmatrix4x4-mgetitem + +// @snippet qguiapplication-1 +QGuiApplicationConstructor(%PYSELF, args, &%0); +// @snippet qguiapplication-1 + +// @snippet qguiapplication-2 +PyObject *empty = PyTuple_New(2); +if (!PyTuple_SetItem(empty, 0, PyList_New(0))) { + QGuiApplicationConstructor(%PYSELF, empty, &%0); +} +// @snippet qguiapplication-2 + +// @snippet qtransform-quadtoquad +// @snippet qtransform-quadtoquad + +// @snippet qtransform-quadtosquare +// @snippet qtransform-quadtosquare diff --git a/sources/pyside2/PySide2/glue/qtmultimedia.cpp b/sources/pyside2/PySide2/glue/qtmultimedia.cpp new file mode 100644 index 000000000..520b5c4fa --- /dev/null +++ b/sources/pyside2/PySide2/glue/qtmultimedia.cpp @@ -0,0 +1,45 @@ +/**************************************************************************** +** +** Copyright (C) 2018 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qt for Python. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// @snippet upcast +%BEGIN_ALLOW_THREADS +QObject* upcastedArg = %CONVERTTOCPP[QObject*](%PYARG_1); +%CPPSELF.%FUNCTION_NAME(reinterpret_cast< %ARG1_TYPE >(upcastedArg)); +%END_ALLOW_THREADS +// @snippet upcast diff --git a/sources/pyside2/PySide2/glue/qtnetwork.cpp b/sources/pyside2/PySide2/glue/qtnetwork.cpp new file mode 100644 index 000000000..cdb330c40 --- /dev/null +++ b/sources/pyside2/PySide2/glue/qtnetwork.cpp @@ -0,0 +1,80 @@ +/**************************************************************************** +** +** Copyright (C) 2018 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qt for Python. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// @snippet qudpsocket-readdatagram +Shiboken::AutoArrayPointer<char> data(%ARGUMENT_NAMES); +QHostAddress ha; +quint16 port; +%BEGIN_ALLOW_THREADS +%RETURN_TYPE retval = %CPPSELF.%FUNCTION_NAME(data, %ARGUMENT_NAMES, &ha, &port); +%END_ALLOW_THREADS +QByteArray ba(data, retval); +%PYARG_0 = PyTuple_New(3); +PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[QByteArray](ba)); +PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QHostAddress](ha)); +PyTuple_SET_ITEM(%PYARG_0, 2, %CONVERTTOPYTHON[quint16](port)); +// @snippet qudpsocket-readdatagram + +// @snippet qipv6address-len +return 16; +// @snippet qipv6address-len + +// @snippet qipv6address-getitem +if (_i >= 16) { + PyErr_SetString(PyExc_IndexError, "index out of bounds"); + return 0; +} +if (_i < 0) + _i = 16 - qAbs(_i); + +uint item = %CPPSELF.c[_i]; +return %CONVERTTOPYTHON[uint](item); +// @snippet qipv6address-getitem + +// @snippet qipv6address-setitem +if (_i >= 16) { + PyErr_SetString(PyExc_IndexError, "index out of bounds"); + return -1; +} +if (_i < 0) + _i = 16 - qAbs(_i); +quint8 item = %CONVERTTOCPP[quint8](_value); +%CPPSELF.c[_i] = item; +return 0; +// @snippet qipv6address-setitem diff --git a/sources/pyside2/PySide2/glue/qtopengl.cpp b/sources/pyside2/PySide2/glue/qtopengl.cpp new file mode 100644 index 000000000..6c106522c --- /dev/null +++ b/sources/pyside2/PySide2/glue/qtopengl.cpp @@ -0,0 +1,74 @@ +/**************************************************************************** +** +** Copyright (C) 2018 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qt for Python. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// @snippet qglbuffer-allocate +int size = (%2 < 0) ? %1.size() : %2; +%CPPSELF.allocate((const void*) %1.data(), size); +// @snippet qglbuffer-allocate + +// @snippet qglbuffer-read +char *data = new char[%3]; +bool result = %CPPSELF.read(%1, data, %3); +QByteArray ret; +if (result) + ret.append((const char*)data, %3); +%PYARG_0 = PyTuple_New(2); +PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[bool](result)); +PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QByteArray](ret)); +delete[] data; +// @snippet qglbuffer-read + +// @snippet qglbuffer-write +int size = (%3 < 0) ? %2.size() : %3; +%CPPSELF.write(%1, (const void*) %2.data(), size); +// @snippet qglbuffer-write + +// @snippet qglbuffer-map +Py_ssize_t dataSize = %CPPSELF.size(); +void* data = %CPPSELF.map(%1); + +if (!data) { + Py_INCREF(Py_None); + %PYARG_0 = Py_None; +} else if (%1 == QGLBuffer::ReadOnly) { + %PYARG_0 = Shiboken::Buffer::newObject(data, dataSize, Shiboken::Buffer::ReadOnly); +} else { + %PYARG_0 = Shiboken::Buffer::newObject(data, dataSize, Shiboken::Buffer::ReadWrite); +} +// @snippet qglbuffer-map diff --git a/sources/pyside2/PySide2/glue/qtqml.cpp b/sources/pyside2/PySide2/glue/qtqml.cpp new file mode 100644 index 000000000..1913204c3 --- /dev/null +++ b/sources/pyside2/PySide2/glue/qtqml.cpp @@ -0,0 +1,52 @@ +/**************************************************************************** +** +** Copyright (C) 2018 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qt for Python. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// @snippet qmlregistertype +int %0 = PySide::qmlRegisterType(%ARGUMENT_NAMES); +%PYARG_0 = %CONVERTTOPYTHON[int](%0); +// @snippet qmlregistertype + +// @snippet init +PySide::initQmlSupport(module); +// @snippet init + +// @snippet qjsengine-toscriptvalue +%RETURN_TYPE retval = %CPPSELF.%FUNCTION_NAME(%1); +return %CONVERTTOPYTHON[%RETURN_TYPE](retval); +// @snippet qjsengine-toscriptvalue diff --git a/sources/pyside2/PySide2/glue/qtquick.cpp b/sources/pyside2/PySide2/glue/qtquick.cpp new file mode 100644 index 000000000..b7c31aff3 --- /dev/null +++ b/sources/pyside2/PySide2/glue/qtquick.cpp @@ -0,0 +1,42 @@ +/**************************************************************************** +** +** Copyright (C) 2018 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qt for Python. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// @snippet qtquick +PySide::initQuickSupport(module); +// @snippet qtquick diff --git a/sources/pyside2/PySide2/glue/qtscript.cpp b/sources/pyside2/PySide2/glue/qtscript.cpp new file mode 100644 index 000000000..7efc26f3e --- /dev/null +++ b/sources/pyside2/PySide2/glue/qtscript.cpp @@ -0,0 +1,74 @@ +/**************************************************************************** +** +** Copyright (C) 2018 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qt for Python. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// @snippet qscriptvalue-repr +if (%CPPSELF.isVariant() || %CPPSELF.isString()) { + QString format = QString::asprintf("%s(\"%s\")", + Py_TYPE(%PYSELF)->tp_name, + qPrintable(%CPPSELF.toString())); + %PYARG_0 = Shiboken::String::fromCString(qPrintable(format)); + } else { + %PYARG_0 = Shiboken::String::fromCString(Py_TYPE(%PYSELF)->tp_name); +} +// @snippet qscriptvalue-repr + +// @snippet qscriptvalue-mgetitem +Shiboken::AutoDecRef key(PyObject_Str(_key)); +QVariant res = %CPPSELF.property(Shiboken::String::toCString(key.object())).toVariant(); +if (res.isValid()) { + return %CONVERTTOPYTHON[QVariant](res); +} else { + PyObject* errorType = PyInt_Check(_key) ? PyExc_IndexError : PyExc_KeyError; + PyErr_SetString(errorType, "Key not found."); + return 0; +} +// @snippet qscriptvalue-mgetitem + +// @snippet qscriptvalueiterator-next +if (%CPPSELF.hasNext()) { + %CPPSELF.next(); + QString name = %CPPSELF.name(); + QVariant value = %CPPSELF.value().toVariant(); + %PYARG_0 = PyTuple_New(2); + PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[QString](name)); + PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QVariant](value)); +} else { + PyErr_SetNone(PyExc_StopIteration); +} +// @snippet qscriptvalueiterator-next diff --git a/sources/pyside2/PySide2/glue/qtuitools.cpp b/sources/pyside2/PySide2/glue/qtuitools.cpp new file mode 100644 index 000000000..0a2feb262 --- /dev/null +++ b/sources/pyside2/PySide2/glue/qtuitools.cpp @@ -0,0 +1,57 @@ +/**************************************************************************** +** +** Copyright (C) 2018 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qt for Python. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// @snippet quiloader +Q_IMPORT_PLUGIN(PyCustomWidgets); +// @snippet quiloader + +// @snippet quiloader-registercustomwidget +registerCustomWidget(%PYARG_1); +%CPPSELF.addPluginPath(""); // force reload widgets +// @snippet quiloader-registercustomwidget + +// @snippet quiloader-load-1 +// Avoid calling the original function: %CPPSELF.%FUNCTION_NAME() +%PYARG_0 = QUiLoadedLoadUiFromDevice(%CPPSELF, %1, %2); +// @snippet quiloader-load-1 + +// @snippet quiloader-load-2 +// Avoid calling the original function: %CPPSELF.%FUNCTION_NAME() +%PYARG_0 = QUiLoaderLoadUiFromFileName(%CPPSELF, %1, %2); +// @snippet quiloader-load-2 diff --git a/sources/pyside2/PySide2/glue/qtwebkitwidgets.cpp b/sources/pyside2/PySide2/glue/qtwebkitwidgets.cpp new file mode 100644 index 000000000..6744c4be2 --- /dev/null +++ b/sources/pyside2/PySide2/glue/qtwebkitwidgets.cpp @@ -0,0 +1,77 @@ +/**************************************************************************** +** +** Copyright (C) 2018 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qt for Python. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// @snippet qwebview-page +SbkObject* _pyReturn = reinterpret_cast<SbkObject*>(%PYARG_0); +if (!Shiboken::Object::hasParentInfo(_pyReturn)) + Shiboken::Object::setParent(%PYSELF, %PYARG_0); +// @snippet qwebview-page + +// @snippet qwebelementcollection-len +return %CPPSELF.count(); +// @snippet qwebelementcollection-len + +// @snippet qwebelementcollection-getitem +if (_i < 0 || _i >= %CPPSELF.count()) { + PyErr_SetString(PyExc_IndexError, "index out of bounds"); + return 0; +} +QWebElement element = %CPPSELF.at(_i); +return %CONVERTTOPYTHON[QWebElement](element); +// @snippet qwebelementcollection-getitem + +// @snippet qwebpage-qt-metacall +static int _signalIndex = -1; +static QMetaMethod _m; + +if (_signalIndex == -1) { + _signalIndex = QWebPage::staticMetaObject.indexOfSlot("shouldInterruptJavaScript()") + _m = QWebPage::staticMetaObject.method(_signalIndex); +} + +if (_signalIndex == id) { + Shiboken::GilState gil; + PyObject* self = (PyObject*)Shiboken::BindingManager::instance().retrieveWrapper(this); + + if (self) { + Shiboken::AutoDecRef _pyMethod(PyObject_GetAttrString(self, "shouldInterruptJavaScript")); + return PySide::SignalManager::callPythonMetaMethod(_m, args, _pyMethod, false); + } +} +// @snippet qwebpage-qt-metacall diff --git a/sources/pyside2/PySide2/glue/qtwidgets.cpp b/sources/pyside2/PySide2/glue/qtwidgets.cpp new file mode 100644 index 000000000..f0e446f62 --- /dev/null +++ b/sources/pyside2/PySide2/glue/qtwidgets.cpp @@ -0,0 +1,365 @@ +/**************************************************************************** +** +** Copyright (C) 2018 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qt for Python. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// @snippet qtreewidgetitemiterator-next +if (**%CPPSELF) { + QTreeWidgetItemIterator *%0 = new QTreeWidgetItemIterator((*%CPPSELF)++); + %PYARG_0 = %CONVERTTOPYTHON[QTreeWidgetItemIterator*](%0); +} +// @snippet qtreewidgetitemiterator-next + +// @snippet qtreewidgetitemiterator-value +QTreeWidgetItem *%0 = %CPPSELF.operator*(); +%PYARG_0 = %CONVERTTOPYTHON[QTreeWidgetItem*](%0); +Shiboken::Object::releaseOwnership(%PYARG_0); +// @snippet qtreewidgetitemiterator-value + +// @snippet qgraphicsitem +PyObject *userTypeConstant = PyInt_FromLong(QGraphicsItem::UserType); +PyDict_SetItemString(reinterpret_cast<PyTypeObject *>(Sbk_QGraphicsItem_TypeF())->tp_dict, "UserType", userTypeConstant); +// @snippet qgraphicsitem + +// @snippet qgraphicsitem-scene-return-parenting +if (%0) { + QObject *parent = %0->parent(); + Shiboken::AutoDecRef pyParent(%CONVERTTOPYTHON[QObject*](parent)); + Shiboken::Object::setParent(pyParent, %PYARG_0); +} +// @snippet qgraphicsitem-scene-return-parenting + +// @snippet qgraphicsitem-isblockedbymodalpanel +QGraphicsItem *item_ = NULL; +%RETURN_TYPE retval_ = %CPPSELF.%FUNCTION_NAME(&item_); +%PYARG_0 = PyTuple_New(2); +PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval_)); +PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QGraphicsItem*](item_)); +// @snippet qgraphicsitem-isblockedbymodalpanel + +// @snippet qitemeditorfactory-registereditor +Shiboken::Object::releaseOwnership(%PYARG_2); +// @snippet qitemeditorfactory-registereditor + +// @snippet qitemeditorfactory-setdefaultfactory +//this function is static we need keep ref to default value, to be able to call python virtual functions +static PyObject* _defaultValue = 0; +%CPPSELF.%FUNCTION_NAME(%1); +Py_INCREF(%PYARG_1); +if (_defaultValue) + Py_DECREF(_defaultValue); + +_defaultValue = %PYARG_1; +// @snippet qitemeditorfactory-setdefaultfactory + +// @snippet qmenu-addaction-1 +%PYARG_0 = addActionWithPyObject(%CPPSELF, QIcon(), %1, %2, %3); +// @snippet qmenu-addaction-1 + +// @snippet qmenu-addaction-2 +%PYARG_0 = addActionWithPyObject(%CPPSELF, %1, %2, %3, %4); +// @snippet qmenu-addaction-2 + +// @snippet qmenu-addaction-3 +%CPPSELF.addAction(%1); +// @snippet qmenu-addaction-3 + +// @snippet qmenu-clear +Shiboken::BindingManager& bm = Shiboken::BindingManager::instance(); +const auto &actions = %CPPSELF.actions(); +for (QAction *act : actions) { + if (auto wrapper = bm.retrieveWrapper(act)) { + auto pyObj = reinterpret_cast<PyObject *>(wrapper); + Py_INCREF(pyObj); + Shiboken::Object::setParent(NULL, pyObj); + Shiboken::Object::invalidate(pyObj); + Py_DECREF(pyObj); + } +} +// @snippet qmenu-clear + +// @snippet qmenubar-clear +const auto &actions = %CPPSELF.actions(); +for (QAction *act : actions) { + Shiboken::AutoDecRef pyAct(%CONVERTTOPYTHON[QAction*](act)); + Shiboken::Object::setParent(NULL, pyAct); + Shiboken::Object::invalidate(pyAct); +} +// @snippet qmenubar-clear + +// @snippet qmenubar-addaction-1 +%PYARG_0 = addActionWithPyObject(%CPPSELF, %1, %2); +// @snippet qmenubar-addaction-1 + +// @snippet qmenubar-addaction-2 +%CPPSELF.addAction(%1); +// @snippet qmenubar-addaction-2 + +// @snippet qshortcut-1 +%0 = new %TYPE(%1, %2); +// @snippet qshortcut-1 + +// @snippet qshortcut-2 +Shiboken::AutoDecRef result(PyObject_CallMethod(%PYSELF, + const_cast<char *>("connect"), + const_cast<char *>("OsO"), + %PYSELF, SIGNAL(activated()), %PYARG_3) +); +if (!result.isNull()) + Shiboken::Object::setParent(%PYARG_2, %PYSELF); +// @snippet qshortcut-2 + +// @snippet qtoolbox-removeitem +QWidget *_widget = %CPPSELF.widget(%1); +if (_widget) { + Shiboken::AutoDecRef pyWidget(%CONVERTTOPYTHON[QWidget*](_widget)); + Shiboken::Object::setParent(0, pyWidget); +} +// @snippet qtoolbox-removeitem + +// @snippet qlayout-setalignment +%CPPSELF.setAlignment(%1); +// @snippet qlayout-setalignment + +// @snippet addownership-0 +addLayoutOwnership(%CPPSELF, %0); +// @snippet addownership-0 + +// @snippet addownership-1 +addLayoutOwnership(%CPPSELF, %1); +// @snippet addownership-1 + +// @snippet addownership-2 +addLayoutOwnership(%CPPSELF, %2); +// @snippet addownership-2 + +// @snippet removeownership-1 +removeLayoutOwnership(%CPPSELF, %1); +// @snippet removeownership-1 + +// @snippet qgridlayout-getitemposition +int a, b, c, d; +%CPPSELF.%FUNCTION_NAME(%1, &a, &b, &c, &d); +%PYARG_0 = PyTuple_New(4); +PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[int](a)); +PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[int](b)); +PyTuple_SET_ITEM(%PYARG_0, 2, %CONVERTTOPYTHON[int](c)); +PyTuple_SET_ITEM(%PYARG_0, 3, %CONVERTTOPYTHON[int](d)); +// @snippet qgridlayout-getitemposition + +// @snippet qgraphicsscene-destroyitemgroup +QGraphicsItem* parentItem = %1->parentItem(); +Shiboken::AutoDecRef parent(%CONVERTTOPYTHON[QGraphicsItem*](parentItem)); +const auto &childItems = %1->childItems(); +for (QGraphicsItem *item : childItems) + Shiboken::Object::setParent(parent, %CONVERTTOPYTHON[QGraphicsItem*](item)); +%BEGIN_ALLOW_THREADS +%CPPSELF.%FUNCTION_NAME(%1); +%END_ALLOW_THREADS +// the arg was destroyed by Qt. +Shiboken::Object::invalidate(%PYARG_1); +// @snippet qgraphicsscene-destroyitemgroup + +// @snippet qgraphicsscene-addwidget +%RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(%1, %2); +%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); +Shiboken::Object::keepReference((SbkObject*)%PYARG_0, "setWidget(QWidget*)1", %PYARG_1); +// @snippet qgraphicsscene-addwidget + +// @snippet qgraphicsscene-clear +const QList<QGraphicsItem*> items = %CPPSELF.items(); +Shiboken::BindingManager& bm = Shiboken::BindingManager::instance(); +for (QGraphicsItem *item : items) { + SbkObject* obj = bm.retrieveWrapper(item); + if (obj) { + if (reinterpret_cast<PyObject*>(obj)->ob_refcnt > 1) // If the refcnt is 1 the object will vannish anyway. + Shiboken::Object::invalidate(obj); + Shiboken::Object::removeParent(obj); + } +} +%CPPSELF.%FUNCTION_NAME(); +// @snippet qgraphicsscene-clear + +// @snippet qtreewidget-clear +QTreeWidgetItem *rootItem = %CPPSELF.invisibleRootItem(); +Shiboken::BindingManager &bm = Shiboken::BindingManager::instance(); +for (int i = 0; i < rootItem->childCount(); ++i) { + QTreeWidgetItem *item = rootItem->child(i); + SbkObject* wrapper = bm.retrieveWrapper(item); + if (wrapper) + Shiboken::Object::setParent(0, reinterpret_cast<PyObject*>(wrapper)); +} +// @snippet qtreewidget-clear + +// @snippet qtreewidgetitem +// Only call the parent function if this return some value +// the parent can be the TreeWidget +if (%0) + Shiboken::Object::setParent(%PYARG_0, %PYSELF); +// @snippet qtreewidgetitem + +// @snippet qlistwidget-clear +Shiboken::BindingManager &bm = Shiboken::BindingManager::instance(); +for (int i = 0, count = %CPPSELF.count(); i < count; ++i) { + QListWidgetItem *item = %CPPSELF.item(i); + if (auto wrapper = bm.retrieveWrapper(item)) { + auto pyObj = reinterpret_cast<PyObject*>(wrapper); + Py_INCREF(pyObj); + Shiboken::Object::setParent(NULL, pyObj); + Shiboken::Object::invalidate(pyObj); + Py_DECREF(pyObj); + } +} +%CPPSELF.%FUNCTION_NAME(); +// @snippet qlistwidget-clear + +// @snippet qwidget-setstyle +Shiboken::Object::keepReference(reinterpret_cast<SbkObject*>(%PYSELF), "__style__", %PYARG_1); +// @snippet qwidget-setstyle + +// @snippet qwidget-style +QStyle* myStyle = %CPPSELF->style(); +if (myStyle && qApp) { +%PYARG_0 = %CONVERTTOPYTHON[QStyle*](myStyle); + QStyle *appStyle = qApp->style(); + if (appStyle == myStyle) { + Shiboken::AutoDecRef pyApp(%CONVERTTOPYTHON[QApplication*](qApp)); + Shiboken::Object::setParent(pyApp, %PYARG_0); + Shiboken::Object::releaseOwnership(%PYARG_0); + } else { + Shiboken::Object::keepReference(reinterpret_cast<SbkObject*>(%PYSELF), "__style__", %PYARG_0); + } +} +// @snippet qwidget-style + +// @snippet qwidget-setlayout +qwidgetSetLayout(%CPPSELF, %1); +// %FUNCTION_NAME() - disable generation of function call. +// @snippet qwidget-setlayout + +// @snippet qtabwidget-removetab +QWidget* tab = %CPPSELF.widget(%1); +if (tab) { + Shiboken::AutoDecRef pyWidget(%CONVERTTOPYTHON[QWidget*](tab)); + %CPPSELF.%FUNCTION_NAME(%1); +} +// @snippet qtabwidget-removetab + +// @snippet qtabwidget-clear +Shiboken::BindingManager& bm = Shiboken::BindingManager::instance(); +for (int i = 0, count = %CPPSELF.count(); i < count; ++i) { + QWidget* widget = %CPPSELF.widget(i); + if (bm.hasWrapper(widget)) { + Shiboken::AutoDecRef pyWidget(%CONVERTTOPYTHON[QWidget*](widget)); + Shiboken::Object::releaseOwnership(pyWidget); + } +} +%CPPSELF.%FUNCTION_NAME(); +// @snippet qtabwidget-clear + +// @snippet qlineedit-addaction +%CPPSELF.addAction(%1); +// @snippet qlineedit-addaction + +// @snippet qtoolbar-addaction-1 +QAction *action = %CPPSELF.addAction(%1, %2); +%PYARG_0 = %CONVERTTOPYTHON[QAction*](action); +Shiboken::AutoDecRef result(PyObject_CallMethod(%PYARG_0, + const_cast<char *>("connect"), + const_cast<char *>("OsO"), + %PYARG_0, SIGNAL(triggered()), %PYARG_3) +); +// @snippet qtoolbar-addaction-1 + +// @snippet qtoolbar-addaction-2 +QAction *action = %CPPSELF.addAction(%1); +%PYARG_0 = %CONVERTTOPYTHON[QAction*](action); +Shiboken::AutoDecRef result(PyObject_CallMethod(%PYARG_0, + const_cast<char *>("connect"), + const_cast<char *>("OsO"), + %PYARG_0, SIGNAL(triggered()), %PYARG_2) +); +// @snippet qtoolbar-addaction-2 + +// @snippet qtoolbar-addaction-3 +%CPPSELF.addAction(%1); +// @snippet qtoolbar-addaction-3 + +// @snippet qtoolbar-clear +QList<PyObject* > lst; +Shiboken::BindingManager& bm = Shiboken::BindingManager::instance(); +const auto &toolButtonChildren = %CPPSELF.findChildren<QToolButton*>(); +for (QToolButton *child : toolButtonChildren) { + if (bm.hasWrapper(child)) { + PyObject* pyChild = %CONVERTTOPYTHON[QToolButton*](child); + Shiboken::Object::setParent(0, pyChild); + lst << pyChild; + } +} + +//Remove actions +const auto &actions = %CPPSELF.actions(); +for (QAction *act : actions) { + Shiboken::AutoDecRef pyAct(%CONVERTTOPYTHON[QAction*](act)); + Shiboken::Object::setParent(NULL, pyAct); + Shiboken::Object::invalidate(pyAct); +} + +%CPPSELF.clear(); +for (PyObject *obj : lst) { + Shiboken::Object::invalidate(reinterpret_cast<SbkObject* >(obj)); + Py_XDECREF(obj); +} +// @snippet qtoolbar-clear + +// @snippet qapplication-1 +QApplicationConstructor(%PYSELF, args, &%0); +// @snippet qapplication-1 + +// @snippet qapplication-2 +PyObject *empty = PyTuple_New(2); +if (!PyTuple_SetItem(empty, 0, PyList_New(0))) + QApplicationConstructor(%PYSELF, empty, &%0); +// @snippet qapplication-2 + +// @snippet qgraphicsproxywidget-setwidget +QWidget* _old = %CPPSELF.widget(); +if (_old) + Shiboken::Object::setParent(nullptr, %CONVERTTOPYTHON[QWidget*](_old)); +%CPPSELF.%FUNCTION_NAME(%1); +Shiboken::Object::setParent(%PYSELF, %PYARG_1); +// @snippet qgraphicsproxywidget-setwidget diff --git a/sources/pyside2/PySide2/glue/qtxml.cpp b/sources/pyside2/PySide2/glue/qtxml.cpp new file mode 100644 index 000000000..4c24c0c53 --- /dev/null +++ b/sources/pyside2/PySide2/glue/qtxml.cpp @@ -0,0 +1,48 @@ +/**************************************************************************** +** +** Copyright (C) 2018 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qt for Python. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// @snippet qxmlentityresolver-resolveentity +QXmlInputSource* _qxmlinputsource_arg_ = nullptr; +%BEGIN_ALLOW_THREADS +%RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(%1, %2, _qxmlinputsource_arg_); +%END_ALLOW_THREADS +%PYARG_0 = PyTuple_New(2); +PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](%0)); +PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QXmlInputSource*](_qxmlinputsource_arg_)); +// @snippet qxmlentityresolver-resolveentity diff --git a/sources/pyside2/PySide2/glue/qtxmlpatterns.cpp b/sources/pyside2/PySide2/glue/qtxmlpatterns.cpp new file mode 100644 index 000000000..b559ad1d4 --- /dev/null +++ b/sources/pyside2/PySide2/glue/qtxmlpatterns.cpp @@ -0,0 +1,43 @@ +/**************************************************************************** +** +** Copyright (C) 2018 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qt for Python. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// @snippet qxmlschemavalidator-schema +QXmlSchema* %0 = new QXmlSchema(%CPPSELF.schema()); +%PYARG_0 = %CONVERTTOPYTHON[QXmlSchema*](%0); +// @snippet qxmlschemavalidator-schema |