// Convert a Python object to a QVariantHash and return true if there was no // error. bool Chimera::to_QVariantHash(PyObject *py, QVariantHash &cpp) const { Q_ASSERT(PyDict_CheckExact(py)); PyObject *key_obj, *val_obj; SIP_SSIZE_T i; i = 0; while (PyDict_Next(py, &i, &key_obj, &val_obj)) { int key_state, val_state, iserr = 0; QString *key = reinterpret_cast<QString *>(sipForceConvertToType( key_obj, sipType_QString, NULL, SIP_NOT_NONE, &key_state, &iserr)); QVariant *val = reinterpret_cast<QVariant *>(sipForceConvertToType( val_obj, sipType_QVariant, NULL, SIP_NOT_NONE, &val_state, &iserr)); if (iserr) return false; cpp.insert(*key, *val); sipReleaseType(key, sipType_QString, key_state); sipReleaseType(val, sipType_QVariant, val_state); } return true; }
static int convertTo_QJsonObject(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj) { QJsonObject **sipCppPtr = reinterpret_cast<QJsonObject **>(sipCppPtrV); #line 82 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\sip/QtCore/qjsonobject.sip" if (!sipIsErr) return PyDict_Check(sipPy); QJsonObject *jo = new QJsonObject; SIP_SSIZE_T pos = 0; PyObject *kobj, *vobj; while (PyDict_Next(sipPy, &pos, &kobj, &vobj)) { int kstate; QString *k = reinterpret_cast<QString *>( sipForceConvertToType(kobj, sipType_QString, sipTransferObj, SIP_NOT_NONE, &kstate, sipIsErr)); if (*sipIsErr) { PyErr_Format(PyExc_TypeError, "a key has type '%s' but 'str' is expected", Py_TYPE(kobj)->tp_name); delete jo; return 0; } int vstate; QJsonValue *v = reinterpret_cast<QJsonValue *>( sipForceConvertToType(vobj, sipType_QJsonValue, sipTransferObj, SIP_NOT_NONE, &vstate, sipIsErr)); if (*sipIsErr) { PyErr_Format(PyExc_TypeError, "a value has type '%s' but 'QJsonValue' is expected", Py_TYPE(vobj)->tp_name); sipReleaseType(k, sipType_QString, kstate); delete jo; return 0; } jo->insert(*k, *v); sipReleaseType(v, sipType_QJsonValue, vstate); sipReleaseType(k, sipType_QString, kstate); } *sipCppPtr = jo; return sipGetState(sipTransferObj); #line 121 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\QtCore/sipQtCoreQJsonObject.cpp" }
static int convertTo_QMap_0100QString_0100QVariant(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj) { QMap<QString,QVariant> **sipCppPtr = reinterpret_cast<QMap<QString,QVariant> **>(sipCppPtrV); #line 84 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\sip/QtCore/qpycore_qmap.sip" if (!sipIsErr) return PyDict_Check(sipPy); QMap<QString, QVariant> *qm = new QMap<QString, QVariant>; SIP_SSIZE_T pos = 0; PyObject *kobj, *vobj; while (PyDict_Next(sipPy, &pos, &kobj, &vobj)) { int kstate; QString *k = reinterpret_cast<QString *>( sipForceConvertToType(kobj, sipType_QString, sipTransferObj, SIP_NOT_NONE, &kstate, sipIsErr)); if (*sipIsErr) { PyErr_Format(PyExc_TypeError, "a key has type '%s' but 'QString' is expected", Py_TYPE(kobj)->tp_name); delete qm; return 0; } int vstate; QVariant *v = reinterpret_cast<QVariant *>( sipForceConvertToType(vobj, sipType_QVariant, sipTransferObj, SIP_NOT_NONE, &vstate, sipIsErr)); if (*sipIsErr) { PyErr_Format(PyExc_TypeError, "a value has type '%s' but 'QVariant' is expected", Py_TYPE(vobj)->tp_name); sipReleaseType(k, sipType_QString, kstate); delete qm; return 0; } qm->insert(*k, *v); sipReleaseType(v, sipType_QVariant, vstate); sipReleaseType(k, sipType_QString, kstate); } *sipCppPtr = qm; return sipGetState(sipTransferObj); #line 127 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\QtCore/sipQtCoreQMap0100QString0100QVariant.cpp" }
static int convertTo_QHash_0100QString_0101QObject(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj) { QHash<QString,QObject*> **sipCppPtr = reinterpret_cast<QHash<QString,QObject*> **>(sipCppPtrV); #line 206 "sip/QtCore/qpycore_qhash.sip" if (!sipIsErr) return PyDict_Check(sipPy); QHash<QString, QObject *> *qh = new QHash<QString, QObject *>; SIP_SSIZE_T pos = 0; PyObject *kobj, *vobj; while (PyDict_Next(sipPy, &pos, &kobj, &vobj)) { int kstate; QString *k = reinterpret_cast<QString *>( sipForceConvertToType(kobj, sipType_QString, sipTransferObj, SIP_NOT_NONE, &kstate, sipIsErr)); if (*sipIsErr) { PyErr_Format(PyExc_TypeError, "a key has type '%s' but 'QString' is expected", Py_TYPE(kobj)->tp_name); delete qh; return 0; } QObject *v = reinterpret_cast<QObject *>( sipForceConvertToType(vobj, sipType_QObject, sipTransferObj, 0, 0, sipIsErr)); if (*sipIsErr) { PyErr_Format(PyExc_TypeError, "a value has type '%s' but 'QObject' is expected", Py_TYPE(vobj)->tp_name); sipReleaseType(k, sipType_QString, kstate); delete qh; return 0; } qh->insert(*k, v); sipReleaseType(k, sipType_QString, kstate); } *sipCppPtr = qh; return sipGetState(sipTransferObj); #line 125 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\QtWebChannel/sipQtWebChannelQHash0100QString0101QObject.cpp" }
// Convert a Python list object to a QVariantList and return true if there was // no error. bool Chimera::to_QVariantList(PyObject *py, QVariantList &cpp) const { Q_ASSERT(PyList_CheckExact(py)); for (SIP_SSIZE_T i = 0; i < PyList_GET_SIZE(py); ++i) { PyObject *val_obj = PyList_GET_ITEM(py, i); if (!val_obj) return false; int val_state, iserr = 0; QVariant *val = reinterpret_cast<QVariant *>(sipForceConvertToType( val_obj, sipType_QVariant, 0, SIP_NOT_NONE, &val_state, &iserr)); if (iserr) return false; cpp.append(*val); sipReleaseType(val, sipType_QVariant, val_state); } return true; }
// Convert a Python list object to a QList<QObject*> and return true if the // conversion was successful. An empty list is never converted and left to the // QtCore module to handle. static bool to_QList_QObject(PyObject *obj, QList<QObject *>&cpp) { if (!PyList_CheckExact(obj) || PyList_GET_SIZE(obj) == 0) return false; for (SIP_SSIZE_T i = 0; i < PyList_GET_SIZE(obj); ++i) { PyObject *val_obj = PyList_GET_ITEM(obj, i); if (!val_obj) return false; int iserr = 0; QObject *val = reinterpret_cast<QObject *>(sipForceConvertToType( val_obj, sipType_QObject, 0, SIP_NO_CONVERTORS, 0, &iserr)); if (iserr) return false; cpp.append(val); } return true; }
// The type descriptor get slot. static PyObject *pyqtSignal_descr_get(PyObject *self, PyObject *obj, PyObject *) { qpycore_pyqtSignal *ps = (qpycore_pyqtSignal *)self; // Return the unbound signal if there is nothing to bind it to. if (obj == NULL || obj == Py_None) { Py_INCREF(self); return self; } // Get the QObject. int is_err = 0; void *qobject = sipForceConvertToType(obj, sipType_QObject, 0, SIP_NO_CONVERTORS, 0, &is_err); if (is_err) { PyErr_Format(PyExc_TypeError, "pyqtSignal must be bound to a QObject, not '%s'", Py_TYPE(obj)->tp_name); return 0; } // Return the bound signal. return qpycore_pyqtBoundSignal_New(self, obj, reinterpret_cast<QObject *>(qobject), ps->overloads->first()); }
static int varset_Defect_p(void *sipSelf, PyObject *sipPy, PyObject *) { Path2d *sipVal; Defect *sipCpp = reinterpret_cast<Defect *>(sipSelf); int sipIsErr = 0; sipVal = reinterpret_cast<Path2d *>(sipForceConvertToType(sipPy,sipType_Path2d,NULL,SIP_NOT_NONE,NULL,&sipIsErr)); if (sipIsErr) return -1; sipCpp->p = *sipVal; return 0; }
static int varset_QStyleOptionHeader_icon(void *sipSelf, PyObject *sipPy, PyObject *) { QIcon*sipVal; QStyleOptionHeader *sipCpp = reinterpret_cast<QStyleOptionHeader *>(sipSelf); int sipIsErr = 0; sipVal = reinterpret_cast<QIcon *>(sipForceConvertToType(sipPy,sipType_QIcon,NULL,SIP_NOT_NONE,NULL,&sipIsErr)); if (sipIsErr) return -1; sipCpp->icon = *sipVal; return 0; }
static int varset_QQuickItem_ItemChangeData_window(void *sipSelf, PyObject *sipPy, PyObject *) { QQuickWindow*sipVal; QQuickItem::ItemChangeData *sipCpp = reinterpret_cast<QQuickItem::ItemChangeData *>(sipSelf); int sipIsErr = 0; sipVal = reinterpret_cast<QQuickWindow *>(sipForceConvertToType(sipPy,sipType_QQuickWindow,NULL,0,NULL,&sipIsErr)); if (sipIsErr) return -1; sipCpp->window = sipVal; return 0; }
static int varset_QWebPage_ErrorPageExtensionReturn_baseUrl(void *sipSelf, PyObject *sipPy, PyObject *) { QUrl*sipVal; QWebPage::ErrorPageExtensionReturn *sipCpp = reinterpret_cast<QWebPage::ErrorPageExtensionReturn *>(sipSelf); int sipIsErr = 0; sipVal = reinterpret_cast<QUrl *>(sipForceConvertToType(sipPy,sipType_QUrl,NULL,SIP_NOT_NONE,NULL,&sipIsErr)); if (sipIsErr) return -1; sipCpp->baseUrl = *sipVal; return 0; }
static int varset_QTextEdit_ExtraSelection_format(void *sipSelf, PyObject *sipPy, PyObject *) { QTextCharFormat*sipVal; QTextEdit::ExtraSelection *sipCpp = reinterpret_cast<QTextEdit::ExtraSelection *>(sipSelf); int sipIsErr = 0; sipVal = reinterpret_cast<QTextCharFormat *>(sipForceConvertToType(sipPy,sipType_QTextCharFormat,NULL,SIP_NOT_NONE,NULL,&sipIsErr)); if (sipIsErr) return -1; sipCpp->format = *sipVal; return 0; }
static int varset_tlp_SelfLoops_old(void *sipSelf, PyObject *sipPy, PyObject *) { tlp::edge *sipVal; tlp::SelfLoops *sipCpp = reinterpret_cast<tlp::SelfLoops *>(sipSelf); int sipIsErr = 0; sipVal = reinterpret_cast<tlp::edge *>(sipForceConvertToType(sipPy,sipType_tlp_edge,NULL,SIP_NOT_NONE,NULL,&sipIsErr)); if (sipIsErr) return -1; sipCpp->old = *sipVal; return 0; }
// Get the bound QObject and slot signature from a callable (which should be a // decorated method). QByteArray qpycore_pyqtslot_get_parts(PyObject *callable, QObject **qrx) { PyObject *qobj_obj, *decorations; int is_err = 0; void *qobj; Chimera::Signature *sig; QByteArray slot; // Get the QObject. qobj_obj = PyMethod_Self(callable); if (!qobj_obj) goto bad_callable; qobj = sipForceConvertToType(qobj_obj, sipType_QObject, 0, SIP_NO_CONVERTORS, 0, &is_err); if (is_err) goto bad_callable; *qrx = reinterpret_cast<QObject *>(qobj); // Get the decoration. decorations = PyObject_GetAttr(callable, qpycore_signature_attr_name); if (!decorations) goto bad_callable; // Use the first one ignoring any others. sig = Chimera::Signature::fromPyObject(PyList_GET_ITEM(decorations, 0)); Py_DECREF(decorations); slot = sig->signature; slot.prepend('1'); return slot; bad_callable: PyErr_SetString(PyExc_TypeError, "callable must be a method of a QtCore.QObject instance decorated " "by QtCore.pyqtSlot"); return QByteArray(); }
static int varset_QWebPage_ErrorPageExtensionReturn_encoding(void *sipSelf, PyObject *sipPy, PyObject *) { QString*sipVal; QWebPage::ErrorPageExtensionReturn *sipCpp = reinterpret_cast<QWebPage::ErrorPageExtensionReturn *>(sipSelf); int sipValState; int sipIsErr = 0; sipVal = reinterpret_cast<QString *>(sipForceConvertToType(sipPy,sipType_QString,NULL,SIP_NOT_NONE,&sipValState,&sipIsErr)); if (sipIsErr) return -1; sipCpp->encoding = *sipVal; sipReleaseType(sipVal, sipType_QString, sipValState); return 0; }
static int varset_QStyleOptionHeader_text(void *sipSelf, PyObject *sipPy, PyObject *) { QString*sipVal; QStyleOptionHeader *sipCpp = reinterpret_cast<QStyleOptionHeader *>(sipSelf); int sipValState; int sipIsErr = 0; sipVal = reinterpret_cast<QString *>(sipForceConvertToType(sipPy,sipType_QString,NULL,SIP_NOT_NONE,&sipValState,&sipIsErr)); if (sipIsErr) return -1; sipCpp->text = *sipVal; sipReleaseType(sipVal, sipType_QString, sipValState); return 0; }
static int varset_QStyleOptionGroupBox_textAlignment(void *sipSelf, PyObject *sipPy, PyObject *) { Qt::Alignment*sipVal; QStyleOptionGroupBox *sipCpp = reinterpret_cast<QStyleOptionGroupBox *>(sipSelf); int sipValState; int sipIsErr = 0; sipVal = reinterpret_cast<Qt::Alignment *>(sipForceConvertToType(sipPy,sipType_Qt_Alignment,NULL,SIP_NOT_NONE,&sipValState,&sipIsErr)); if (sipIsErr) return -1; sipCpp->textAlignment = *sipVal; sipReleaseType(sipVal, sipType_Qt_Alignment, sipValState); return 0; }
static int varset_QStyleOptionGroupBox_features(void *sipSelf, PyObject *sipPy, PyObject *) { QStyleOptionFrame::FrameFeatures*sipVal; QStyleOptionGroupBox *sipCpp = reinterpret_cast<QStyleOptionGroupBox *>(sipSelf); int sipValState; int sipIsErr = 0; sipVal = reinterpret_cast<QStyleOptionFrame::FrameFeatures *>(sipForceConvertToType(sipPy,sipType_QStyleOptionFrame_FrameFeatures,NULL,SIP_NOT_NONE,&sipValState,&sipIsErr)); if (sipIsErr) return -1; sipCpp->features = *sipVal; sipReleaseType(sipVal, sipType_QStyleOptionFrame_FrameFeatures, sipValState); return 0; }
static int varset_QStyleOptionFocusRect_backgroundColor(void *sipSelf, PyObject *sipPy, PyObject *) { QColor*sipVal; QStyleOptionFocusRect *sipCpp = reinterpret_cast<QStyleOptionFocusRect *>(sipSelf); int sipValState; int sipIsErr = 0; sipVal = reinterpret_cast<QColor *>(sipForceConvertToType(sipPy,sipType_QColor,NULL,SIP_NOT_NONE,&sipValState,&sipIsErr)); if (sipIsErr) return -1; sipCpp->backgroundColor = *sipVal; sipReleaseType(sipVal, sipType_QColor, sipValState); return 0; }
static int varset_QWebPluginFactory_Plugin_mimeTypes(void *sipSelf, PyObject *sipPy, PyObject *) { QList<QWebPluginFactory::MimeType>*sipVal; QWebPluginFactory::Plugin *sipCpp = reinterpret_cast<QWebPluginFactory::Plugin *>(sipSelf); int sipValState; int sipIsErr = 0; sipVal = reinterpret_cast<QList<QWebPluginFactory::MimeType> *>(sipForceConvertToType(sipPy,sipType_QList_0100QWebPluginFactory_MimeType,NULL,SIP_NOT_NONE,&sipValState,&sipIsErr)); if (sipIsErr) return -1; sipCpp->mimeTypes = *sipVal; sipReleaseType(sipVal, sipType_QList_0100QWebPluginFactory_MimeType, sipValState); return 0; }
static int varset_QWebPluginFactory_Plugin_name(void *sipSelf, PyObject *sipPy, PyObject *) { QString*sipVal; QWebPluginFactory::Plugin *sipCpp = reinterpret_cast<QWebPluginFactory::Plugin *>(sipSelf); int sipValState; int sipIsErr = 0; sipVal = reinterpret_cast<QString *>(sipForceConvertToType(sipPy,sipType_QString,NULL,SIP_NOT_NONE,&sipValState,&sipIsErr)); if (sipIsErr) return -1; sipCpp->name = *sipVal; sipReleaseType(sipVal, sipType_QString, sipValState); return 0; }
// Create a new storage instance containing a converted Python object. Chimera::Storage::Storage(const Chimera *ct, PyObject *py) : _parsed_type(ct), _ptr_storage(0), _tmp_state(0) { // We convert to a QVariant even for pointer types because this has the // side-effect of ensuring the object doesn't get garbage collected. _valid = _parsed_type->fromPyObject(py, &_value_storage); if (isPointerType()) { int is_err = 0; _ptr_storage = sipForceConvertToType(py, _parsed_type->typeDef(), 0, 0, &_tmp_state, &is_err); if (is_err) { _value_storage = QVariant(); _valid = false; } } }
// Get a wrapper after validating any list elements. ListWrapper *ListWrapper::wrapper(PyObject *py_list, QObject *parent) { ListWrapper *lw; // A wrapper might be created every time the property getter is called, so // try and reuse an existing one. const QObjectList &children = parent->children(); for (int i = 0; i < children.count(); ++i) { lw = qobject_cast<ListWrapper *>(children.at(i)); if (lw && lw->_py_list == py_list) return lw; } // Create a new one. lw = new ListWrapper(py_list, parent); for (SIP_SSIZE_T i = 0; i < PyList_GET_SIZE(py_list); ++i) { int iserr = 0; void *cpp = sipForceConvertToType(PyList_GET_ITEM(py_list, i), sipType_QObject, 0, SIP_NO_CONVERTORS, 0, &iserr); if (iserr) { delete lw; return 0; } lw->qobject_list.append(reinterpret_cast<QObject *>(cpp)); } return lw; }
// The type descriptor get slot. static PyObject *pyqtSignal_descr_get(PyObject *self, PyObject *obj, PyObject *) { qpycore_pyqtSignal *ps = (qpycore_pyqtSignal *)self; // Return the unbound signal if there is nothing to bind it to. if (obj == NULL || obj == Py_None) { Py_INCREF(self); return self; } // Get the QObject. int is_err = 0; void *qobject = sipForceConvertToType(obj, sipType_QObject, 0, SIP_NO_CONVERTORS, 0, &is_err); if (is_err) return 0; // Return the bound signal. return qpycore_pyqtBoundSignal_New(ps, obj, reinterpret_cast<QObject *>(qobject)); }
// Parse a Python object as a sequence of either QVector[234]D or // QMatrix[234]x[234] instances, or a sequence of sequence of floats and return // an array that can be passed to QOpenGLShaderProgram::setUniformValueArray(). // The array is destroyed only when the shader is garbage collected or when // replaced by another array. const void *qpyopengl_uniform_value_array(PyObject *values, PyObject *shader, PyObject *key, const sipTypeDef **array_type, int *array_len, int *tsize, sipErrorState *estate) { // Check the key was created correctly. if (!key) { *estate = sipErrorFail; return 0; } // Get the dict that holds the converted arrays. PyObject *dict = ((sipSimpleWrapper *)shader)->user; if (!dict) { dict = PyDict_New(); if (!dict) { Py_DECREF(key); *estate = sipErrorFail; return 0; } ((sipSimpleWrapper *)shader)->user = dict; } // Check that values is a non-empty sequence. values = PySequence_Fast(values, "a uniform value array must be a sequence"); if (!values) { Py_DECREF(key); *estate = sipErrorContinue; return 0; } SIP_SSIZE_T nr_items = PySequence_Fast_GET_SIZE(values); if (nr_items < 1) { PyErr_SetString(PyExc_TypeError, "a uniform value array must have at least one element"); Py_DECREF(key); Py_DECREF(values); *estate = sipErrorFail; return 0; } // The first element determines the type expected. PyObject *itm = PySequence_Fast_GET_ITEM(values, 0); const sipTypeDef *td; SIP_SSIZE_T nr_dim = 0; void *array; if (sipCanConvertToType(itm, sipType_QVector2D, SIP_NOT_NONE)) { td = sipType_QVector2D; array = new QVector2D[nr_items]; } else if (sipCanConvertToType(itm, sipType_QVector3D, SIP_NOT_NONE)) { td = sipType_QVector3D; array = new QVector3D[nr_items]; } else if (sipCanConvertToType(itm, sipType_QVector4D, SIP_NOT_NONE)) { td = sipType_QVector4D; array = new QVector4D[nr_items]; } else if (sipCanConvertToType(itm, sipType_QMatrix2x2, SIP_NOT_NONE)) { td = sipType_QMatrix2x2; array = new QMatrix2x2[nr_items]; } else if (sipCanConvertToType(itm, sipType_QMatrix2x3, SIP_NOT_NONE)) { td = sipType_QMatrix2x3; array = new QMatrix2x3[nr_items]; } else if (sipCanConvertToType(itm, sipType_QMatrix2x4, SIP_NOT_NONE)) { td = sipType_QMatrix2x4; array = new QMatrix2x4[nr_items]; } else if (sipCanConvertToType(itm, sipType_QMatrix3x2, SIP_NOT_NONE)) { td = sipType_QMatrix3x2; array = new QMatrix3x2[nr_items]; } else if (sipCanConvertToType(itm, sipType_QMatrix3x3, SIP_NOT_NONE)) { td = sipType_QMatrix3x3; array = new QMatrix3x3[nr_items]; } else if (sipCanConvertToType(itm, sipType_QMatrix3x4, SIP_NOT_NONE)) { td = sipType_QMatrix3x4; array = new QMatrix3x4[nr_items]; } else if (sipCanConvertToType(itm, sipType_QMatrix4x2, SIP_NOT_NONE)) { td = sipType_QMatrix4x2; array = new QMatrix4x2[nr_items]; } else if (sipCanConvertToType(itm, sipType_QMatrix4x3, SIP_NOT_NONE)) { td = sipType_QMatrix4x3; array = new QMatrix4x3[nr_items]; } else if (sipCanConvertToType(itm, sipType_QMatrix4x4, SIP_NOT_NONE)) { td = sipType_QMatrix4x4; array = new QMatrix4x4[nr_items]; } else if (PySequence_Check(itm) && (nr_dim = PySequence_Size(itm)) >= 1) { td = 0; array = new GLfloat[nr_items * nr_dim]; } else { PyErr_SetString(PyExc_TypeError, "a uniform value array must be a sequence of QVector2D, " "QVector3D, QVector4D, QMatrix2x2, QMatrix2x3, QMatrix2x4, " "QMatrix3x2, QMatrix3x3, QMatrix3x4, QMatrix4x2, QMatrix4x3, " "QMatrix4x4, or a sequence of sequences of floats"); Py_DECREF(key); Py_DECREF(values); *estate = sipErrorFail; return 0; } // Convert the values. for (SIP_SSIZE_T i = 0; i < nr_items; ++i) { int iserr = 0; itm = PySequence_Fast_GET_ITEM(values, i); if (td) { void *cpp; cpp = sipForceConvertToType(itm, td, 0, SIP_NOT_NONE | SIP_NO_CONVERTORS, 0, &iserr); if (iserr) { PyErr_Format(PyExc_TypeError, "uniform value array elements should all be '%s', not " "'%s'", sipTypeAsPyTypeObject(td)->tp_name, Py_TYPE(itm)->tp_name); } else if (td == sipType_QVector2D) { QVector2D *a = reinterpret_cast<QVector2D *>(array); a[i] = *reinterpret_cast<QVector2D *>(cpp); } else if (td == sipType_QVector3D) { QVector3D *a = reinterpret_cast<QVector3D *>(array); a[i] = *reinterpret_cast<QVector3D *>(cpp); } else if (td == sipType_QVector4D) { QVector4D *a = reinterpret_cast<QVector4D *>(array); a[i] = *reinterpret_cast<QVector4D *>(cpp); } else if (td == sipType_QMatrix2x2) { QMatrix2x2 *a = reinterpret_cast<QMatrix2x2 *>(array); a[i] = *reinterpret_cast<QMatrix2x2 *>(cpp); } else if (td == sipType_QMatrix2x3) { QMatrix2x3 *a = reinterpret_cast<QMatrix2x3 *>(array); a[i] = *reinterpret_cast<QMatrix2x3 *>(cpp); } else if (td == sipType_QMatrix2x4) { QMatrix2x4 *a = reinterpret_cast<QMatrix2x4 *>(array); a[i] = *reinterpret_cast<QMatrix2x4 *>(cpp); } else if (td == sipType_QMatrix3x2) { QMatrix3x2 *a = reinterpret_cast<QMatrix3x2 *>(array); a[i] = *reinterpret_cast<QMatrix3x2 *>(cpp); } else if (td == sipType_QMatrix3x3) { QMatrix3x3 *a = reinterpret_cast<QMatrix3x3 *>(array); a[i] = *reinterpret_cast<QMatrix3x3 *>(cpp); } else if (td == sipType_QMatrix3x4) { QMatrix3x4 *a = reinterpret_cast<QMatrix3x4 *>(array); a[i] = *reinterpret_cast<QMatrix3x4 *>(cpp); } else if (td == sipType_QMatrix4x2) { QMatrix4x2 *a = reinterpret_cast<QMatrix4x2 *>(array); a[i] = *reinterpret_cast<QMatrix4x2 *>(cpp); } else if (td == sipType_QMatrix4x3) { QMatrix4x3 *a = reinterpret_cast<QMatrix4x3 *>(array); a[i] = *reinterpret_cast<QMatrix4x3 *>(cpp); } else if (td == sipType_QMatrix4x4) { QMatrix4x4 *a = reinterpret_cast<QMatrix4x4 *>(array); a[i] = *reinterpret_cast<QMatrix4x4 *>(cpp); } } else { itm = PySequence_Fast(itm, "uniform value array elements should all be sequences"); if (itm) { if (PySequence_Fast_GET_SIZE(itm) != nr_dim) { PyErr_Format(PyExc_TypeError, "uniform value array elements should all be " "sequences of length " #if PY_VERSION_HEX >= 0x02050000 "%zd", #else "%d", #endif nr_dim); Py_DECREF(itm); iserr = 1; } else { GLfloat *ap = reinterpret_cast<GLfloat *>(array); PyErr_Clear(); for (SIP_SSIZE_T j = 0; j < nr_dim; ++j) *ap++ = PyFloat_AsDouble( PySequence_Fast_GET_ITEM(itm, j)); if (PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, "uniform value array elements should all be " "sequences of floats"); Py_DECREF(itm); iserr = 1; } } } else { iserr = 1; } } if (iserr) { Py_DECREF(key); Py_DECREF(values); delete_array(array, td); *estate = sipErrorFail; return 0; } } Py_DECREF(values); // Wrap the array in a Python object so that it won't leak. #if defined(SIP_USE_PYCAPSULE) PyObject *array_obj = PyCapsule_New(array, 0, array_dtor); if (array_obj && PyCapsule_SetContext(array_obj, const_cast<sipTypeDef *>(td)) != 0) { Py_DECREF(array_obj); array_obj = 0; } #else PyObject *array_obj = PyCObject_FromVoidPtrAndDesc(array, const_cast<sipTypeDef *>(td), array_dtor); #endif if (!array_obj) { Py_DECREF(key); delete_array(array, td); *estate = sipErrorFail; return 0; } int rc = PyDict_SetItem(dict, key, array_obj); Py_DECREF(key); Py_DECREF(array_obj); if (rc < 0) { *estate = sipErrorFail; return 0; } *array_type = td; *array_len = nr_items; *tsize = nr_dim; return array; }
// Parse a Python object as a sequence of either QVector[234]D instances or a // sequence of sequence of floats and return an array that can be passed to // QGLShaderProgram::setAttributeArray(). The array is destroyed only when the // shader is garbage collected or when replaced by another array. const GLfloat *qpyopengl_attribute_array(PyObject *values, PyObject *shader, PyObject *key, int *tsize, sipErrorState *estate) { // Check the key was created correctly. if (!key) { *estate = sipErrorFail; return 0; } // Get the dict that holds the converted arrays. PyObject *dict = ((sipSimpleWrapper *)shader)->user; if (!dict) { dict = PyDict_New(); if (!dict) { Py_DECREF(key); *estate = sipErrorFail; return 0; } ((sipSimpleWrapper *)shader)->user = dict; } // Check that values is a non-empty sequence. values = PySequence_Fast(values, "an attribute array must be a sequence"); if (!values) { Py_DECREF(key); *estate = sipErrorContinue; return 0; } SIP_SSIZE_T nr_items = PySequence_Fast_GET_SIZE(values); if (nr_items < 1) { PyErr_SetString(PyExc_TypeError, "an attribute array must have at least one element"); Py_DECREF(key); Py_DECREF(values); *estate = sipErrorFail; return 0; } // The first element determines the type expected. PyObject *itm = PySequence_Fast_GET_ITEM(values, 0); const sipTypeDef *td; SIP_SSIZE_T nr_dim; if (sipCanConvertToType(itm, sipType_QVector2D, SIP_NOT_NONE)) { td = sipType_QVector2D; nr_dim = 2; } else if (sipCanConvertToType(itm, sipType_QVector3D, SIP_NOT_NONE)) { td = sipType_QVector3D; nr_dim = 3; } else if (sipCanConvertToType(itm, sipType_QVector4D, SIP_NOT_NONE)) { td = sipType_QVector4D; nr_dim = 4; } else if (PySequence_Check(itm) && (nr_dim = PySequence_Size(itm)) >= 1) { td = 0; } else { PyErr_SetString(PyExc_TypeError, "an attribute array must be a sequence of QVector2D, " "QVector3D, QVector4D, or a sequence of sequences of floats"); Py_DECREF(key); Py_DECREF(values); *estate = sipErrorFail; return 0; } // Create the array that will be returned. GLfloat *array = new GLfloat[nr_items * nr_dim]; // Convert the values. GLfloat *ap = array; for (SIP_SSIZE_T i = 0; i < nr_items; ++i) { int iserr = 0; itm = PySequence_Fast_GET_ITEM(values, i); if (td) { void *cpp; cpp = sipForceConvertToType(itm, td, 0, SIP_NOT_NONE | SIP_NO_CONVERTORS, 0, &iserr); if (iserr) { PyErr_Format(PyExc_TypeError, "attribute array elements should all be '%s', not '%s'", sipTypeAsPyTypeObject(td)->tp_name, Py_TYPE(itm)->tp_name); } else if (td == sipType_QVector2D) { QVector2D *v = reinterpret_cast<QVector2D *>(cpp); *ap++ = v->x(); *ap++ = v->y(); } else if (td == sipType_QVector3D) { QVector3D *v = reinterpret_cast<QVector3D *>(cpp); *ap++ = v->x(); *ap++ = v->y(); *ap++ = v->z(); } else if (td == sipType_QVector4D) { QVector4D *v = reinterpret_cast<QVector4D *>(cpp); *ap++ = v->x(); *ap++ = v->y(); *ap++ = v->z(); *ap++ = v->w(); } } else { itm = PySequence_Fast(itm, "attribute array elements should all be sequences"); if (itm) { if (PySequence_Fast_GET_SIZE(itm) != nr_dim) { PyErr_Format(PyExc_TypeError, "attribute array elements should all be sequences " #if PY_VERSION_HEX >= 0x02050000 "of length %zd", #else "of length %d", #endif nr_dim); Py_DECREF(itm); iserr = 1; } else { PyErr_Clear(); for (SIP_SSIZE_T j = 0; j < nr_dim; ++j) *ap++ = PyFloat_AsDouble( PySequence_Fast_GET_ITEM(itm, j)); if (PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, "attribute array elements should all be " "sequences of floats"); Py_DECREF(itm); iserr = 1; } } } else { iserr = 1; } } if (iserr) { Py_DECREF(key); Py_DECREF(values); delete[] array; *estate = sipErrorFail; return 0; } } Py_DECREF(values); *tsize = nr_dim; // Wrap the array in a Python object so that it won't leak. #if defined(SIP_USE_PYCAPSULE) PyObject *array_obj = PyCapsule_New(array, 0, array_dtor); #else PyObject *array_obj = PyCObject_FromVoidPtr(array, array_dtor); #endif if (!array_obj) { Py_DECREF(key); delete[] array; *estate = sipErrorFail; return 0; } int rc = PyDict_SetItem(dict, key, array_obj); Py_DECREF(key); Py_DECREF(array_obj); if (rc < 0) { *estate = sipErrorFail; return 0; } return array; }
static int convertTo_QList_0101QWinJumpListItem(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj) { QList<QWinJumpListItem*> **sipCppPtr = reinterpret_cast<QList<QWinJumpListItem*> **>(sipCppPtrV); #line 175 "sip/QtCore/qpycore_qlist.sip" PyObject *iter = PyObject_GetIter(sipPy); if (!sipIsErr) { Py_XDECREF(iter); return (iter #if PY_MAJOR_VERSION < 3 && !PyString_Check(sipPy) #endif && !PyUnicode_Check(sipPy)); } if (!iter) { *sipIsErr = 1; return 0; } QList<QWinJumpListItem *> *ql = new QList<QWinJumpListItem *>; for (SIP_SSIZE_T i = 0; ; ++i) { PyErr_Clear(); PyObject *itm = PyIter_Next(iter); if (!itm) { if (PyErr_Occurred()) { delete ql; Py_DECREF(iter); *sipIsErr = 1; return 0; } break; } QWinJumpListItem *t = reinterpret_cast<QWinJumpListItem *>( sipForceConvertToType(itm, sipType_QWinJumpListItem, sipTransferObj, 0, 0, sipIsErr)); if (*sipIsErr) { PyErr_Format(PyExc_TypeError, "index " SIP_SSIZE_T_FORMAT " has type '%s' but 'QWinJumpListItem' is expected", i, Py_TYPE(itm)->tp_name); Py_DECREF(itm); delete ql; Py_DECREF(iter); return 0; } ql->append(t); Py_DECREF(itm); } Py_DECREF(iter); *sipCppPtr = ql; return sipGetState(sipTransferObj); #line 140 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\QtWinExtras/sipQtWinExtrasQList0101QWinJumpListItem.cpp" }
// Handle a single keyword argument. static ArgStatus handle_argument(PyObject *self, QObject *qobj, PyObject *name_obj, PyObject *value_obj) { const QMetaObject *mo = qobj->metaObject(); // Get the name encoded name. PyObject *enc_name_obj = name_obj; const char *name = sipString_AsASCIIString(&enc_name_obj); if (!name) return AsError; QByteArray enc_name(name); Py_DECREF(enc_name_obj); // See if it is a property. int idx = mo->indexOfProperty(enc_name.constData()); if (idx >= 0) { QMetaProperty prop = mo->property(idx); // A negative type means a QVariant property. if (prop.userType() >= 0) { const Chimera *ct = Chimera::parse(prop); if (!ct) { PyErr_Format(PyExc_TypeError, "'%s' keyword argument has an invalid type", enc_name.constData()); return AsError; } QVariant value; bool valid = ct->fromPyObject(value_obj, &value); delete ct; if (!valid) return AsError; qobj->setProperty(enc_name.constData(), value); } else { int value_state, iserr = 0; QVariant *value = reinterpret_cast<QVariant *>( sipForceConvertToType(value_obj, sipType_QVariant, 0, SIP_NOT_NONE, &value_state, &iserr)); if (iserr) return AsError; qobj->setProperty(enc_name.constData(), *value); sipReleaseType(value, sipType_QVariant, value_state); } } else { bool unknown = true; // See if it is a signal. PyObject *sig = PyObject_GetAttr(self, name_obj); if (sig) { if (PyObject_TypeCheck(sig, &qpycore_pyqtBoundSignal_Type)) { static PyObject *connect_obj = NULL; if (!connect_obj) { #if PY_MAJOR_VERSION >= 3 connect_obj = PyUnicode_FromString("connect"); #else connect_obj = PyString_FromString("connect"); #endif if (!connect_obj) { Py_DECREF(sig); return AsError; } } // Connect the slot. PyObject *res = PyObject_CallMethodObjArgs(sig, connect_obj, value_obj, 0); if (!res) { Py_DECREF(sig); return AsError; } Py_DECREF(res); unknown = false; } Py_DECREF(sig); } if (unknown) { PyErr_Clear(); return AsUnknown; } } return AsHandled; }
static int convertTo_QList_0100QCameraInfo(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj) { QList<QCameraInfo> **sipCppPtr = reinterpret_cast<QList<QCameraInfo> **>(sipCppPtrV); #line 66 "sip/QtCore/qpycore_qlist.sip" PyObject *iter = PyObject_GetIter(sipPy); if (!sipIsErr) { Py_XDECREF(iter); return (iter #if PY_MAJOR_VERSION < 3 && !PyString_Check(sipPy) #endif && !PyUnicode_Check(sipPy)); } if (!iter) { *sipIsErr = 1; return 0; } QList<QCameraInfo> *ql = new QList<QCameraInfo>; for (SIP_SSIZE_T i = 0; ; ++i) { PyErr_Clear(); PyObject *itm = PyIter_Next(iter); if (!itm) { if (PyErr_Occurred()) { delete ql; Py_DECREF(iter); *sipIsErr = 1; return 0; } break; } int state; QCameraInfo *t = reinterpret_cast<QCameraInfo *>( sipForceConvertToType(itm, sipType_QCameraInfo, sipTransferObj, SIP_NOT_NONE, &state, sipIsErr)); if (*sipIsErr) { PyErr_Format(PyExc_TypeError, "index " SIP_SSIZE_T_FORMAT " has type '%s' but 'QCameraInfo' is expected", i, Py_TYPE(itm)->tp_name); Py_DECREF(itm); delete ql; Py_DECREF(iter); return 0; } ql->append(*t); sipReleaseType(t, sipType_QCameraInfo, state); Py_DECREF(itm); } Py_DECREF(iter); *sipCppPtr = ql; return sipGetState(sipTransferObj); #line 142 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\QtMultimedia/sipQtMultimediaQList0100QCameraInfo.cpp" }
static int convertTo_QList_0600QPair_0100QByteArray_0100QByteArray(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj) { QList<QPair<QByteArray,QByteArray> > **sipCppPtr = reinterpret_cast<QList<QPair<QByteArray,QByteArray> > **>(sipCppPtrV); #line 286 "sip/QtCore/qpycore_qlist.sip" PyObject *iter = PyObject_GetIter(sipPy); if (!sipIsErr) { Py_XDECREF(iter); return (iter #if PY_MAJOR_VERSION < 3 && !PyString_Check(sipPy) #endif && !PyUnicode_Check(sipPy)); } if (!iter) { *sipIsErr = 1; return 0; } QList<QPair<QByteArray, QByteArray> > *ql = new QList<QPair<QByteArray, QByteArray> >; for (SIP_SSIZE_T i = 0; ; ++i) { PyErr_Clear(); PyObject *seq = PyIter_Next(iter); if (!seq) { if (PyErr_Occurred()) { delete ql; Py_DECREF(iter); *sipIsErr = 1; return 0; } break; } SIP_SSIZE_T sub_len; if (PySequence_Check(seq) #if PY_MAJOR_VERSION < 3 && !PyString_Check(seq) #endif && !PyUnicode_Check(seq)) sub_len = PySequence_Size(seq); else sub_len = -1; if (sub_len != 2) { if (sub_len < 0) PyErr_Format(PyExc_TypeError, "index " SIP_SSIZE_T_FORMAT " has type '%s' but a 2 element non-string sequence is expected", i, Py_TYPE(seq)->tp_name); else PyErr_Format(PyExc_TypeError, "index " SIP_SSIZE_T_FORMAT " is a sequence of " SIP_SSIZE_T_FORMAT " sub-elements but 2 sub-elements are expected", i, sub_len); Py_DECREF(seq); delete ql; Py_DECREF(iter); *sipIsErr = 1; return 0; } PyObject *itm1 = PySequence_ITEM(seq, 0); if (!itm1) { Py_DECREF(seq); delete ql; Py_DECREF(iter); *sipIsErr = 1; return 0; } int state1; QByteArray *s1 = reinterpret_cast<QByteArray *>( sipForceConvertToType(itm1, sipType_QByteArray, sipTransferObj, SIP_NOT_NONE, &state1, sipIsErr)); if (*sipIsErr) { PyErr_Format(PyExc_TypeError, "the first sub-element of index " SIP_SSIZE_T_FORMAT " has type '%s' but 'QByteArray' is expected", i, Py_TYPE(itm1)->tp_name); Py_DECREF(itm1); Py_DECREF(seq); delete ql; Py_DECREF(iter); return 0; } PyObject *itm2 = PySequence_ITEM(seq, 1); if (!itm2) { sipReleaseType(s1, sipType_QByteArray, state1); Py_DECREF(itm1); Py_DECREF(seq); delete ql; Py_DECREF(iter); *sipIsErr = 1; return 0; } int state2; QByteArray *s2 = reinterpret_cast<QByteArray *>( sipForceConvertToType(itm2, sipType_QByteArray, sipTransferObj, SIP_NOT_NONE, &state2, sipIsErr)); if (*sipIsErr) { PyErr_Format(PyExc_TypeError, "the second sub-element of index " SIP_SSIZE_T_FORMAT " has type '%s' but 'QByteArray' is expected", i, Py_TYPE(itm2)->tp_name); Py_DECREF(itm2); sipReleaseType(s1, sipType_QByteArray, state1); Py_DECREF(itm1); Py_DECREF(seq); delete ql; Py_DECREF(iter); return 0; } ql->append(QPair<QByteArray, QByteArray>(*s1, *s2)); sipReleaseType(s2, sipType_QByteArray, state2); Py_DECREF(itm2); sipReleaseType(s1, sipType_QByteArray, state1); Py_DECREF(itm1); Py_DECREF(seq); } Py_DECREF(iter); *sipCppPtr = ql; return sipGetState(sipTransferObj); #line 224 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\QtNetwork/sipQtNetworkQList0600QPair0100QByteArray0100QByteArray.cpp" }