// 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"
}
