static PyObject *slot_QNetworkConfiguration_StateFlags___ixor__(PyObject *sipSelf,PyObject *sipArg)
{
if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QNetworkConfiguration_StateFlags)))
{
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
QNetworkConfiguration::StateFlags *sipCpp = reinterpret_cast<QNetworkConfiguration::StateFlags *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QNetworkConfiguration_StateFlags));
if (!sipCpp)
return 0;
PyObject *sipParseErr = NULL;
{
QNetworkConfiguration::StateFlags* a0;
int a0State = 0;
if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QNetworkConfiguration_StateFlags, &a0, &a0State))
{
Py_BEGIN_ALLOW_THREADS
sipCpp->QNetworkConfiguration::StateFlags::operator^=(*a0);
Py_END_ALLOW_THREADS
sipReleaseType(a0,sipType_QNetworkConfiguration_StateFlags,a0State);
Py_INCREF(sipSelf);
return sipSelf;
}
}
Py_XDECREF(sipParseErr);
if (sipParseErr == Py_None)
return NULL;
PyErr_Clear();
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
static PyObject *slot_QAbstractSocket_BindMode___ior__(PyObject *sipSelf,PyObject *sipArg)
{
if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QAbstractSocket_BindMode)))
{
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
QAbstractSocket::BindMode *sipCpp = reinterpret_cast<QAbstractSocket::BindMode *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QAbstractSocket_BindMode));
if (!sipCpp)
return 0;
PyObject *sipParseErr = NULL;
{
QAbstractSocket::BindMode* a0;
int a0State = 0;
if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QAbstractSocket_BindMode, &a0, &a0State))
{
Py_BEGIN_ALLOW_THREADS
sipCpp->QAbstractSocket::BindMode::operator|=(*a0);
Py_END_ALLOW_THREADS
sipReleaseType(a0,sipType_QAbstractSocket_BindMode,a0State);
Py_INCREF(sipSelf);
return sipSelf;
}
}
Py_XDECREF(sipParseErr);
if (sipParseErr == Py_None)
return NULL;
PyErr_Clear();
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
static PyObject *slot_QDesignerFormWindowInterface_Feature___ixor__(PyObject *sipSelf,PyObject *sipArg)
{
if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QDesignerFormWindowInterface_Feature)))
{
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
QDesignerFormWindowInterface::Feature *sipCpp = reinterpret_cast<QDesignerFormWindowInterface::Feature *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QDesignerFormWindowInterface_Feature));
if (!sipCpp)
return 0;
PyObject *sipParseErr = NULL;
{
QDesignerFormWindowInterface::Feature* a0;
int a0State = 0;
if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QDesignerFormWindowInterface_Feature, &a0, &a0State))
{
Py_BEGIN_ALLOW_THREADS
sipCpp->QDesignerFormWindowInterface::Feature::operator^=(*a0);
Py_END_ALLOW_THREADS
sipReleaseType(a0,sipType_QDesignerFormWindowInterface_Feature,a0State);
Py_INCREF(sipSelf);
return sipSelf;
}
}
Py_XDECREF(sipParseErr);
if (sipParseErr == Py_None)
return NULL;
PyErr_Clear();
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
static PyObject *slot_QPageSetupDialog_PageSetupDialogOptions___ior__(PyObject *sipSelf,PyObject *sipArg)
{
if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QPageSetupDialog_PageSetupDialogOptions)))
{
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
QPageSetupDialog::PageSetupDialogOptions *sipCpp = reinterpret_cast<QPageSetupDialog::PageSetupDialogOptions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QPageSetupDialog_PageSetupDialogOptions));
if (!sipCpp)
return 0;
PyObject *sipParseErr = NULL;
{
QPageSetupDialog::PageSetupDialogOptions* a0;
int a0State = 0;
if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QPageSetupDialog_PageSetupDialogOptions, &a0, &a0State))
{
Py_BEGIN_ALLOW_THREADS
sipCpp->QPageSetupDialog::PageSetupDialogOptions::operator|=(*a0);
Py_END_ALLOW_THREADS
sipReleaseType(a0,sipType_QPageSetupDialog_PageSetupDialogOptions,a0State);
Py_INCREF(sipSelf);
return sipSelf;
}
}
Py_XDECREF(sipParseErr);
if (sipParseErr == Py_None)
return NULL;
PyErr_Clear();
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
static PyObject *convertFrom_QMultiMap_0100QSsl_AlternateNameEntryType_0100QString(void *sipCppV,PyObject *sipTransferObj)
{
QMultiMap<QSsl::AlternateNameEntryType,QString> *sipCpp = reinterpret_cast<QMultiMap<QSsl::AlternateNameEntryType,QString> *>(sipCppV);
#line 95 "/home/tsheasha/GUC/Bachelors/android-python27/python-build/PyQt-x11-gpl-4.8/sip/QtNetwork/qsslcertificate.sip"
// Get the enum objects that are the dictionary keys.
static PyObject *email_entry = NULL;
static PyObject *dns_entry = NULL;
if (email_entry == NULL)
{
email_entry = PyObject_GetAttrString((PyObject *)sipTypeAsPyTypeObject(sipType_QSsl),
#if PY_VERSION_HEX >= 0x02050000
"EmailEntry");
#else
const_cast<char *>("EmailEntry"));
#endif
if (email_entry == NULL)
return NULL;
}
static PyObject *slot_QTextEdit_AutoFormatting___ior__(PyObject *sipSelf,PyObject *sipArg)
{
if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QTextEdit_AutoFormatting)))
{
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
QTextEdit::AutoFormatting *sipCpp = reinterpret_cast<QTextEdit::AutoFormatting *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QTextEdit_AutoFormatting));
if (!sipCpp)
return 0;
PyObject *sipParseErr = NULL;
{
QTextEdit::AutoFormatting* a0;
int a0State = 0;
if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QTextEdit_AutoFormatting, &a0, &a0State))
{
sipCpp->QTextEdit::AutoFormatting::operator|=(*a0);
sipReleaseType(a0,sipType_QTextEdit_AutoFormatting,a0State);
Py_INCREF(sipSelf);
return sipSelf;
}
}
Py_XDECREF(sipParseErr);
if (sipParseErr == Py_None)
return NULL;
PyErr_Clear();
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
static PyObject *slot_QBluetoothDeviceInfo_CoreConfigurations___ior__(PyObject *sipSelf,PyObject *sipArg)
{
if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QBluetoothDeviceInfo_CoreConfigurations)))
{
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
QBluetoothDeviceInfo::CoreConfigurations *sipCpp = reinterpret_cast<QBluetoothDeviceInfo::CoreConfigurations *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QBluetoothDeviceInfo_CoreConfigurations));
if (!sipCpp)
return 0;
PyObject *sipParseErr = NULL;
{
QBluetoothDeviceInfo::CoreConfigurations* a0;
int a0State = 0;
if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QBluetoothDeviceInfo_CoreConfigurations, &a0, &a0State))
{
sipCpp->QBluetoothDeviceInfo::CoreConfigurations::operator|=(*a0);
sipReleaseType(a0,sipType_QBluetoothDeviceInfo_CoreConfigurations,a0State);
Py_INCREF(sipSelf);
return sipSelf;
}
}
Py_XDECREF(sipParseErr);
if (sipParseErr == Py_None)
return NULL;
PyErr_Clear();
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
static PyObject *slot_QTextItem_RenderFlags___iand__(PyObject *sipSelf,PyObject *sipArg)
{
if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QTextItem_RenderFlags)))
{
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
QTextItem::RenderFlags *sipCpp = reinterpret_cast<QTextItem::RenderFlags *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QTextItem_RenderFlags));
if (!sipCpp)
return 0;
PyObject *sipParseErr = NULL;
{
int a0;
if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
{
Py_BEGIN_ALLOW_THREADS
sipCpp->QTextItem::RenderFlags::operator&=(a0);
Py_END_ALLOW_THREADS
Py_INCREF(sipSelf);
return sipSelf;
}
}
Py_XDECREF(sipParseErr);
if (sipParseErr == Py_None)
return NULL;
PyErr_Clear();
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
static PyObject *slot_QDesignerFormWindowInterface_Feature___ixor__(PyObject *sipSelf,PyObject *sipArg)
{
if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QDesignerFormWindowInterface_Feature)))
{
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
::QDesignerFormWindowInterface::Feature *sipCpp = reinterpret_cast< ::QDesignerFormWindowInterface::Feature *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QDesignerFormWindowInterface_Feature));
if (!sipCpp)
return 0;
PyObject *sipParseErr = NULL;
{
int a0;
if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
{
#line 357 "sip/QtCore/qglobal.sip"
*sipCpp = QDesignerFormWindowInterface::Feature(*sipCpp ^ a0);
#line 168 "/home/thais/Faculdade/TCC/NEW/PyQt4_gpl_x11-4.12/QtDesigner/sipQtDesignerQDesignerFormWindowInterfaceFeature.cpp"
Py_INCREF(sipSelf);
return sipSelf;
}
}
Py_XDECREF(sipParseErr);
if (sipParseErr == Py_None)
return NULL;
PyErr_Clear();
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
static PyObject *slot_QIODevice_OpenMode___ior__(PyObject *sipSelf,PyObject *sipArg)
{
if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QIODevice_OpenMode)))
{
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
QIODevice::OpenMode *sipCpp = reinterpret_cast<QIODevice::OpenMode *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QIODevice_OpenMode));
if (!sipCpp)
return 0;
PyObject *sipParseErr = NULL;
{
QIODevice::OpenMode* a0;
int a0State = 0;
if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QIODevice_OpenMode, &a0, &a0State))
{
sipCpp->QIODevice::OpenMode::operator|=(*a0);
sipReleaseType(a0,sipType_QIODevice_OpenMode,a0State);
Py_INCREF(sipSelf);
return sipSelf;
}
}
Py_XDECREF(sipParseErr);
if (sipParseErr == Py_None)
return NULL;
PyErr_Clear();
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
static PyObject *slot_QWebEnginePage_FindFlags___ior__(PyObject *sipSelf,PyObject *sipArg)
{
if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QWebEnginePage_FindFlags)))
{
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
QWebEnginePage::FindFlags *sipCpp = reinterpret_cast<QWebEnginePage::FindFlags *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QWebEnginePage_FindFlags));
if (!sipCpp)
return 0;
PyObject *sipParseErr = NULL;
{
QWebEnginePage::FindFlags* a0;
int a0State = 0;
if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QWebEnginePage_FindFlags, &a0, &a0State))
{
sipCpp->QWebEnginePage::FindFlags::operator|=(*a0);
sipReleaseType(a0,sipType_QWebEnginePage_FindFlags,a0State);
Py_INCREF(sipSelf);
return sipSelf;
}
}
Py_XDECREF(sipParseErr);
if (sipParseErr == Py_None)
return NULL;
PyErr_Clear();
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
static PyObject *slot_Qt_WindowStates___ior__(PyObject *sipSelf,PyObject *sipArg)
{
if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_Qt_WindowStates)))
{
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
::Qt::WindowStates *sipCpp = reinterpret_cast< ::Qt::WindowStates *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_Qt_WindowStates));
if (!sipCpp)
return 0;
PyObject *sipParseErr = NULL;
{
int a0;
if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
{
#line 351 "/home/thais/Faculdade/TCC/NEW/PyQt4_gpl_x11-4.12/sip/QtCore/qglobal.sip"
*sipCpp = Qt::WindowStates(*sipCpp | a0);
#line 242 "/home/thais/Faculdade/TCC/NEW/PyQt4_gpl_x11-4.12/QtCore/sipQtCoreQtWindowStates.cpp"
Py_INCREF(sipSelf);
return sipSelf;
}
}
Py_XDECREF(sipParseErr);
if (sipParseErr == Py_None)
return NULL;
PyErr_Clear();
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
static PyObject *slot_QNetworkConfigurationManager_Capabilities___iand__(PyObject *sipSelf,PyObject *sipArg)
{
if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QNetworkConfigurationManager_Capabilities)))
{
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
QNetworkConfigurationManager::Capabilities *sipCpp = reinterpret_cast<QNetworkConfigurationManager::Capabilities *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QNetworkConfigurationManager_Capabilities));
if (!sipCpp)
return 0;
PyObject *sipParseErr = NULL;
{
int a0;
if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
{
Py_BEGIN_ALLOW_THREADS
sipCpp->QNetworkConfigurationManager::Capabilities::operator&=(a0);
Py_END_ALLOW_THREADS
Py_INCREF(sipSelf);
return sipSelf;
}
}
Py_XDECREF(sipParseErr);
if (sipParseErr == Py_None)
return NULL;
PyErr_Clear();
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
static PyObject *slot_QFontComboBox_FontFilters___ixor__(PyObject *sipSelf,PyObject *sipArg)
{
if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QFontComboBox_FontFilters)))
{
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
QFontComboBox::FontFilters *sipCpp = reinterpret_cast<QFontComboBox::FontFilters *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QFontComboBox_FontFilters));
if (!sipCpp)
return 0;
PyObject *sipParseErr = NULL;
{
QFontComboBox::FontFilters* a0;
int a0State = 0;
if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QFontComboBox_FontFilters, &a0, &a0State))
{
sipCpp->QFontComboBox::FontFilters::operator^=(*a0);
sipReleaseType(a0,sipType_QFontComboBox_FontFilters,a0State);
Py_INCREF(sipSelf);
return sipSelf;
}
}
Py_XDECREF(sipParseErr);
if (sipParseErr == Py_None)
return NULL;
PyErr_Clear();
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
static PyObject *slot_QFileDialog_Options___ixor__(PyObject *sipSelf,PyObject *sipArg)
{
if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QFileDialog_Options)))
{
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
::QFileDialog::Options *sipCpp = reinterpret_cast< ::QFileDialog::Options *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QFileDialog_Options));
if (!sipCpp)
return 0;
PyObject *sipParseErr = NULL;
{
int a0;
if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
{
#line 357 "sip/QtCore/qglobal.sip"
*sipCpp = QFileDialog::Options(*sipCpp ^ a0);
#line 168 "/home/thais/Faculdade/TCC/NEW/PyQt4_gpl_x11-4.12/QtGui/sipQtGuiQFileDialogOptions.cpp"
Py_INCREF(sipSelf);
return sipSelf;
}
}
Py_XDECREF(sipParseErr);
if (sipParseErr == Py_None)
return NULL;
PyErr_Clear();
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
/*
* Convert a new C/C++ pointer to a Python instance.
*/
PyObject *sipWrapSimpleInstance(void *cppPtr, const sipTypeDef *td,
sipWrapper *owner, int flags)
{
static PyObject *nullargs = NULL;
pendingDef old_pending, *pd;
PyObject *self;
if (nullargs == NULL && (nullargs = PyTuple_New(0)) == NULL)
return NULL;
if (cppPtr == NULL)
{
Py_INCREF(Py_None);
return Py_None;
}
/*
* Object creation can trigger the Python garbage collector which in turn
* can execute arbitrary Python code which can then call this function
* recursively. Therefore we save any existing pending object before
* setting the new one.
*/
if ((pd = get_pending(TRUE)) == NULL)
return NULL;
old_pending = *pd;
pd->cpp = cppPtr;
pd->owner = owner;
pd->flags = flags;
self = PyObject_Call((PyObject *)sipTypeAsPyTypeObject(td), nullargs, NULL);
*pd = old_pending;
return self;
}
static PyObject *slot_QAbstractSocket_BindMode___iand__(PyObject *sipSelf,PyObject *sipArg)
{
if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QAbstractSocket_BindMode)))
{
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
QAbstractSocket::BindMode *sipCpp = reinterpret_cast<QAbstractSocket::BindMode *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QAbstractSocket_BindMode));
if (!sipCpp)
return 0;
PyObject *sipParseErr = NULL;
{
int a0;
if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
{
sipCpp->QAbstractSocket::BindMode::operator&=(a0);
Py_INCREF(sipSelf);
return sipSelf;
}
}
Py_XDECREF(sipParseErr);
if (sipParseErr == Py_None)
return NULL;
PyErr_Clear();
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
static PyObject *slot_QSGEngine_CreateTextureOptions___iand__(PyObject *sipSelf,PyObject *sipArg)
{
if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QSGEngine_CreateTextureOptions)))
{
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
QSGEngine::CreateTextureOptions *sipCpp = reinterpret_cast<QSGEngine::CreateTextureOptions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSGEngine_CreateTextureOptions));
if (!sipCpp)
return 0;
PyObject *sipParseErr = NULL;
{
int a0;
if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
{
sipCpp->QSGEngine::CreateTextureOptions::operator&=(a0);
Py_INCREF(sipSelf);
return sipSelf;
}
}
Py_XDECREF(sipParseErr);
if (sipParseErr == Py_None)
return NULL;
PyErr_Clear();
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
static PyObject *slot_QSizeF___iadd__(PyObject *sipSelf,PyObject *sipArg)
{
if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QSizeF)))
{
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
QSizeF *sipCpp = reinterpret_cast<QSizeF *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSizeF));
if (!sipCpp)
return 0;
PyObject *sipParseErr = NULL;
{
const QSizeF* a0;
if (sipParseArgs(&sipParseErr, sipArg, "1J9", sipType_QSizeF, &a0))
{
sipCpp->QSizeF::operator+=(*a0);
Py_INCREF(sipSelf);
return sipSelf;
}
}
Py_XDECREF(sipParseErr);
if (sipParseErr == Py_None)
return NULL;
PyErr_Clear();
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
static PyObject *slot_QNetworkSession_UsagePolicies___iand__(PyObject *sipSelf,PyObject *sipArg)
{
if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QNetworkSession_UsagePolicies)))
{
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
QNetworkSession::UsagePolicies *sipCpp = reinterpret_cast<QNetworkSession::UsagePolicies *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QNetworkSession_UsagePolicies));
if (!sipCpp)
return 0;
PyObject *sipParseErr = NULL;
{
int a0;
if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
{
sipCpp->QNetworkSession::UsagePolicies::operator&=(a0);
Py_INCREF(sipSelf);
return sipSelf;
}
}
Py_XDECREF(sipParseErr);
if (sipParseErr == Py_None)
return NULL;
PyErr_Clear();
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
static PyObject *slot_QVector3D___idiv__(PyObject *sipSelf,PyObject *sipArg)
{
if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QVector3D)))
{
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
QVector3D *sipCpp = reinterpret_cast<QVector3D *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QVector3D));
if (!sipCpp)
return 0;
PyObject *sipParseErr = NULL;
{
float a0;
if (sipParseArgs(&sipParseErr, sipArg, "1f", &a0))
{
sipCpp->QVector3D::operator/=(a0);
Py_INCREF(sipSelf);
return sipSelf;
}
}
Py_XDECREF(sipParseErr);
if (sipParseErr == Py_None)
return NULL;
PyErr_Clear();
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
bool null_from_qvariant_converter( const QVariant *varp, PyObject **objp )
{
static bool sWatchDog = false;
if ( sWatchDog )
return false;
// If we deal with a NULL QVariant (and it's not a QByteArray which properly
// maps NULL values)
// If there are more cases like QByteArray, we should consider using a whitelist
// instead of a blacklist.
if ( varp->isNull() && varp->type() != QVariant::ByteArray )
{
sWatchDog = true;
PyObject* vartype = sipConvertFromEnum( varp->type(), sipType_QVariant_Type );
*objp = PyObject_Call(( PyObject * )sipTypeAsPyTypeObject( sipType_QVariant ), PyTuple_Pack( 1, vartype ), nullptr );
sWatchDog = false;
return true;
}
else
{
return false;
}
}
// This does the real work for all implementations of QObject::qt_metacall().
static int qt_metacall_worker(sipSimpleWrapper *pySelf, PyTypeObject *pytype,
sipTypeDef *base, QMetaObject::Call _c, int _id, void **_a)
{
// See if this is a wrapped C++ type rather than a Python sub-type.
if (pytype == sipTypeAsPyTypeObject(base))
return _id;
_id = qt_metacall_worker(pySelf, pytype->tp_base, base, _c, _id, _a);
if (_id < 0)
return _id;
pyqtWrapperType *pyqt_wt = (pyqtWrapperType *)pytype;
qpycore_metaobject *qo = pyqt_wt->metaobject;
bool ok = true;
if (_c == QMetaObject::InvokeMetaMethod)
{
if (_id < qo->nr_signals + qo->pslots.count())
{
if (_id < qo->nr_signals)
{
QObject *qthis = reinterpret_cast<QObject *>(sipGetCppPtr(pySelf, sipType_QObject));
Py_BEGIN_ALLOW_THREADS
QMetaObject::activate(qthis, qo->mo, _id, _a);
Py_END_ALLOW_THREADS
}
else
{
PyQtSlot *slot = qo->pslots.at(_id - qo->nr_signals);
ok = slot->invoke(_a, (PyObject *)pySelf, _a[0]);
}
}
// 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;
}
/*
* Convert a new C/C++ pointer to a Python instance.
*/
PyObject *sipWrapSimpleInstance(void *cppPtr, const sipTypeDef *td,
sipWrapper *owner, int flags)
{
static PyObject *nullargs = NULL;
pendingDef old_pending;
PyObject *self;
#ifdef WITH_THREAD
threadDef *thread;
#endif
if (nullargs == NULL && (nullargs = PyTuple_New(0)) == NULL)
return NULL;
if (cppPtr == NULL)
{
Py_INCREF(Py_None);
return Py_None;
}
/*
* Object creation can trigger the Python garbage collector which in turn
* can execute arbitrary Python code which can then call this function
* recursively. Therefore we save any existing pending object before
* setting the new one.
*/
#ifdef WITH_THREAD
if ((thread = currentThreadDef()) != NULL)
{
old_pending = thread->pending;
thread->pending.cpp = cppPtr;
thread->pending.owner = owner;
thread->pending.flags = flags;
}
else
{
old_pending = pending;
pending.cpp = cppPtr;
pending.owner = owner;
pending.flags = flags;
}
#else
old_pending = pending;
pending.cpp = cppPtr;
pending.owner = owner;
pending.flags = flags;
#endif
self = PyObject_Call((PyObject *)sipTypeAsPyTypeObject(td), nullargs, NULL);
#ifdef WITH_THREAD
if (thread != NULL)
thread->pending = old_pending;
else
pending = old_pending;
#else
pending = old_pending;
#endif
return self;
}
// Parse the given C++ type name.
bool Chimera::parse_cpp_type(const QByteArray &type)
{
_name = type;
// Resolve any types.
QByteArray resolved = resolve_types(type);
if (resolved.isEmpty())
return false;
// See if the type is known to Qt.
_metatype = QMetaType::type(resolved.constData());
// If not then use the PyQt_PyObject wrapper.
if (_metatype == QMetaType::Void)
_metatype = PyQt_PyObject::metatype;
// See if the type (without a pointer) is known to SIP.
bool is_ptr = resolved.endsWith('*');
if (is_ptr)
{
resolved.chop(1);
if (resolved.endsWith('*'))
return false;
}
_type = sipFindType(resolved.constData());
if (!_type)
{
// This is the only fundamental pointer type recognised by Qt.
if (_metatype == QMetaType::VoidStar)
return true;
// This is 'int', 'bool', etc.
if (_metatype != PyQt_PyObject::metatype && !is_ptr)
return true;
if ((resolved == "char" || resolved == "const char") && is_ptr)
{
// This is a special value meaning a (hopefully) '\0' terminated
// string.
_metatype = -1;
return true;
}
// This is an explicit 'PyQt_PyObject'.
if (resolved == "PyQt_PyObject" && !is_ptr)
return true;
return false;
}
if (sipTypeIsNamespace(_type))
return false;
if (sipTypeIsClass(_type))
{
set_flag();
if (is_ptr)
{
PyTypeObject *type_obj = sipTypeAsPyTypeObject(_type);
if (sipType_QWidget && PyType_IsSubtype(type_obj, sipTypeAsPyTypeObject(sipType_QWidget)))
{
_metatype = QMetaType::QWidgetStar;
}
else if (PyType_IsSubtype(type_obj, sipTypeAsPyTypeObject(sipType_QObject)))
{
_metatype = QMetaType::QObjectStar;
}
}
}
// We don't support pointers to enums.
if (sipTypeIsEnum(_type) && is_ptr)
_type = 0;
if (sipTypeIsEnum(_type) || isFlag())
_metatype = QMetaType::Int;
return true;
}
// 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;
}
// Return true if the given type (which must be a class) was wrapped for PyQt4.
bool qpycore_is_pyqt4_class(const sipTypeDef *td)
{
return PyType_IsSubtype(Py_TYPE(sipTypeAsPyTypeObject(td)),
&qpycore_pyqtWrapperType_Type);
}
// Parse the given Python type object.
bool Chimera::parse_py_type(PyTypeObject *type_obj)
{
const sipTypeDef *td = sipTypeFromPyTypeObject(type_obj);
if (td)
{
if (sipTypeIsNamespace(td))
return false;
_type = td;
_name = sipTypeName(td);
if (sipTypeIsClass(td))
set_flag();
if (sipTypeIsEnum(td) || isFlag())
{
_metatype = QMetaType::Int;
}
else
{
bool is_a_QObject = PyType_IsSubtype(type_obj, sipTypeAsPyTypeObject(sipType_QObject));
// If there is no assignment helper then assume it is a
// pointer-type.
if (!get_assign_helper())
_name.append('*');
_metatype = QMetaType::type(_name.constData());
// This will deal with cases where the registered type is a
// super-class and specifically allows for multiple inheritance.
// The problem we are solving is that we want a QGraphicsWidget to
// be handled as a QGraphicsItem (which Qt registers) rather than a
// QObject, specifically in the value passed as a QVariant to
// QGraphicsItem::itemChange(). This solution means that it will
// always be passed as a QGraphicsItem, even if there are
// circumstances where it should be passed as a QObject. If we
// come across such a circumstance then we may need to remove this
// and implement a more specific solution in %MethodCode for the
// various itemChange() implementations.
if (_metatype == 0 && is_a_QObject)
{
PyObject *mro = type_obj->tp_mro;
Q_ASSERT(PyTuple_Check(mro));
Q_ASSERT(PyTuple_GET_SIZE(mro) >= 3);
for (SIP_SSIZE_T i = 1; i < PyTuple_GET_SIZE(mro) - 1; ++i)
{
PyTypeObject *sc = (PyTypeObject *)PyTuple_GET_ITEM(mro, i);
if (sc == sipSimpleWrapper_Type || sc == sipWrapper_Type)
continue;
QByteArray sc_name(sc->tp_name);
// QObjects are always pointers.
sc_name.append('*');
_metatype = QMetaType::type(sc_name.constData());
if (_metatype >= QMetaType::User)
{
_type = sipTypeFromPyTypeObject(sc);
_name = sc_name;
_py_type = (PyObject *)sc;
Py_INCREF(_py_type);
return true;
}
}
}
// If it is a user type then it must be a type that SIP knows
// about but was registered by Qt.
if (_metatype < QMetaType::User)
{
if (sipType_QWidget && PyType_IsSubtype(type_obj, sipTypeAsPyTypeObject(sipType_QWidget)))
{
_metatype = QMetaType::QWidgetStar;
}
else if (is_a_QObject)
{
_metatype = QMetaType::QObjectStar;
}
else if (!sipIsExactWrappedType((sipWrapperType *)type_obj))
{
// It must be a (non-QObject, non-QWidget) Python
// sub-class so make sure it gets wrapped in a
// PyQt_PyObject.
_type = 0;
_metatype = PyQt_PyObject::metatype;
_name.clear();
}
}
}
}
#if PY_MAJOR_VERSION >= 3
else if (type_obj == &PyUnicode_Type)
{
_type = sipType_QString;
_metatype = QMetaType::QString;
}
#else
else if (type_obj == &PyString_Type || type_obj == &PyUnicode_Type)
{
// In this case we accept that the reverse conversion will result in an
// object of a different type (i.e. a QString rather than a Python
// string).
_type = sipType_QString;
_metatype = QMetaType::QString;
}
#endif
else if (type_obj == &PyBool_Type)
{
_metatype = QMetaType::Bool;
}
#if PY_MAJOR_VERSION < 3
else if (type_obj == &PyInt_Type)
{
// We choose to map to a C++ int, even though a Python int is
// potentially much larger, as it represents the most common usage in
// Qt. However we will allow a larger type to be used if the context
// is right.
_metatype = QMetaType::Int;
_inexact = true;
}
#endif
else if (type_obj == &PyLong_Type)
{
// We choose to map to a C++ int for the same reasons as above and to
// be consistent with Python3 where everything is a long object. If
// this isn't appropriate the user can always use a string to specify
// the exact C++ type they want.
_metatype = QMetaType::Int;
_inexact = true;
}
else if (type_obj == &PyFloat_Type)
{
_metatype = QMetaType::Double;
}
// Fallback to using a PyQt_PyObject.
if (_metatype == QMetaType::Void)
_metatype = PyQt_PyObject::metatype;
// If there is no name so far then use the meta-type name.
if (_name.isEmpty())
_name = QMetaType::typeName(_metatype);
_py_type = (PyObject *)type_obj;
Py_INCREF(_py_type);
return true;
}
// Convert a Python object to a QJSValue.
int qpyqml_convertTo_QJSValue(PyObject *py, PyObject *transferObj,
QJSValue **cpp, int *isErr)
{
if (PyObject_TypeCheck(py, sipTypeAsPyTypeObject(sipType_QJSValue_SpecialValue)))
{
*cpp = new QJSValue((QJSValue::SpecialValue)SIPLong_AsLong(py));
return sipGetState(transferObj);
}
if (PyBool_Check(py))
{
*cpp = new QJSValue(py == Py_True);
return sipGetState(transferObj);
}
#if PY_MAJOR_VERSION >= 3
if (PyLong_Check(py))
{
*cpp = new QJSValue((int)PyLong_AS_LONG(py));
return sipGetState(transferObj);
}
#else
if (PyInt_Check(py))
{
*cpp = new QJSValue((int)PyInt_AS_LONG(py));
return sipGetState(transferObj);
}
#endif
if (PyFloat_Check(py))
{
*cpp = new QJSValue((double)PyFloat_AS_DOUBLE(py));
return sipGetState(transferObj);
}
if (sipCanConvertToType(py, sipType_QString, 0))
{
int state;
QString *qs = reinterpret_cast<QString *>(sipConvertToType(py,
sipType_QString, 0, 0, &state, isErr));
if (*isErr)
{
sipReleaseType(qs, sipType_QString, state);
return 0;
}
*cpp = new QJSValue(*qs);
sipReleaseType(qs, sipType_QString, state);
return sipGetState(transferObj);
}
*cpp = reinterpret_cast<QJSValue *>(sipConvertToType(py, sipType_QJSValue,
transferObj, SIP_NO_CONVERTORS, 0, isErr));
return 0;
}
