#include "PythonQtConversion.h"

#include "PythonQtVariants.h"

#include "PythonQtBoolResult.h"

#include <QDateTime>

#include <QTime>

#include <QDate>

#include <climits>

#include <limits>

#if QT_VERSION < 0x060000

#include <QStringRef>

Q_DECLARE_METATYPE(QStringRef)

int PythonQtConv::stringRefTypeId = 0;

#else

#include <QStringView>

#include <QAnyStringView>

#include <QByteArrayView>

int PythonQtConv::stringViewTypeId = 0;

int PythonQtConv::anyStringViewTypeId = 0;

int PythonQtConv::byteArrayViewTypeId = 0;

#endif

QHash<int, PythonQtConvertMetaTypeToPythonCB*> PythonQtConv::_metaTypeToPythonConverters;

QHash<int, PythonQtConvertPythonToMetaTypeCB*> PythonQtConv::_pythonToMetaTypeConverters;

PythonQtConvertPythonSequenceToQVariantListCB* PythonQtConv::_pythonSequenceToQVariantListCB = nullptr;

PyObject* PythonQtConv::GetPyBool(bool val)

{

PyObject* r = val?Py_True:Py_False;

Py_INCREF(r);

return r;

}

PyObject* PythonQtConv::ConvertQtValueToPython(const PythonQtMethodInfo::ParameterInfo& info, const void* data) {

// is it an enum value?

if (info.enumWrapper) {

if (info.pointerCount==0) {

return PythonQtPrivate::createEnumValueInstance(info.enumWrapper, *((unsigned int*)data));

} else {

// we do not support pointers to enums (who needs them?)

Py_RETURN_NONE;

}

}

if (info.typeId == QMetaType::Void) {

Py_RETURN_NONE;

} else if ((info.pointerCount == 1) && (info.typeId == QMetaType::Char)) {

// a char ptr will probably be a null terminated string, so we support that:

char* charPtr = *((char**)data);

if (charPtr) {

return PyUnicode_FromString(charPtr);

} else {

Py_RETURN_NONE;

}

} else if ((info.typeId == PythonQtMethodInfo::Unknown || info.typeId >= QMetaType::User) &&

info.isQList && (info.innerNamePointerCount == 1)) {

// it is a QList<Obj*> template:

QList<void*>* listPtr = nullptr;

if (info.pointerCount == 1) {

listPtr = *((QList<void*>**)data);

} else if (info.pointerCount == 0) {

listPtr = (QList<void*>*)data;

}

if (listPtr) {

return ConvertQListOfPointerTypeToPythonList(listPtr, info);

} else {

return nullptr;

}

}

if (info.typeId >= QMetaType::User || info.typeId == QMetaType::QByteArrayList) {

// if a converter is registered, we use is:

PythonQtConvertMetaTypeToPythonCB* converter = _metaTypeToPythonConverters.value(info.typeId);

if (converter) {

return (*converter)(info.pointerCount==0?data:*((void**)data), info.typeId);

}

}

// special handling did not match, so we convert the usual way (either pointer or value version):

if (info.pointerCount == 1) {

// convert the pointer to a Python Object (we can handle ANY C++ object, in the worst case we just know the type and the pointer)

return PythonQt::priv()->wrapPtr(*((void**)data), info.name);

} else if (info.pointerCount == 0) {

if (info.isReference && !info.isConst) {

// if we have a non-const reference, we want to pass the direct pointer to Python.

// NOTE: The moc does not generate non-const & as return values, but we get these when

// we pass virtual methods to Python.

return PythonQt::priv()->wrapPtr((void*)data, info.name);

} else {

// if we have a by value or const&, we copy the object and wrap it:

if (info.typeId != PythonQtMethodInfo::Unknown) {

// handle values that are const& or by value and have a metatype

return convertQtValueToPythonInternal(info.typeId, data);

} else {

// the type does not have a typeid, we need to make a copy using the copy constructor

PythonQtClassInfo* classInfo = PythonQt::priv()->getClassInfo(info.name);

if (classInfo) {

PyObject* result = classInfo->copyObject((void*)data);

if (result) {

return result;

}

}

}

}

}

Py_RETURN_NONE;

}

PyObject* PythonQtConv::convertQtValueToPythonInternal(int type, const void* data) {

switch (type) {

case QMetaType::Void:

Py_RETURN_NONE;

case QMetaType::Char:

return PyLong_FromLong(*((char*)data));

case QMetaType::UChar:

return PyLong_FromLong(*((unsigned char*)data));

case QMetaType::Short:

return PyLong_FromLong(*((short*)data));

case QMetaType::UShort:

return PyLong_FromLong(*((unsigned short*)data));

case QMetaType::Long:

return PyLong_FromLong(*((long*)data));

case QMetaType::ULong:

// does not fit into simple int of python

return PyLong_FromUnsignedLong(*((unsigned long*)data));

case QMetaType::Bool:

return PythonQtConv::GetPyBool(*((bool*)data));

case QMetaType::Int:

return PyLong_FromLong(*((int*)data));

case QMetaType::UInt:

// does not fit into simple int of python

return PyLong_FromUnsignedLong(*((unsigned int*)data));

case QMetaType::QChar:

return PyLong_FromLong(*((unsigned short*)data));

case QMetaType::Float:

return PyFloat_FromDouble(*((float*)data));

case QMetaType::Double:

return PyFloat_FromDouble(*((double*)data));

case QMetaType::LongLong:

return PyLong_FromLongLong(*((qint64*)data));

case QMetaType::ULongLong:

return PyLong_FromUnsignedLongLong(*((quint64*)data));

// implicit conversion from QByteArray to str has been removed:

//case QMetaType::QByteArray: {

// QByteArray* v = (QByteArray*) data;

// return PyBytes_FromStringAndSize(*v, v->size());

// }

case QMetaType::QVariantHash:

return PythonQtConv::QVariantHashToPyObject(*((QVariantHash*)data));

case QMetaType::QVariantMap:

return PythonQtConv::QVariantMapToPyObject(*((QVariantMap*)data));

case QMetaType::QVariantList:

return PythonQtConv::QVariantListToPyObject(*((QVariantList*)data));

case QMetaType::QString:

return PythonQtConv::QStringToPyObject(*((QString*)data));

case QMetaType::QStringList:

return PythonQtConv::QStringListToPyObject(*((QStringList*)data));

case PythonQtMethodInfo::Variant:

#if QT_VERSION >= 0x040800

case QMetaType::QVariant:

#endif

return PythonQtConv::QVariantToPyObject(*((QVariant*)data));

case QMetaType::QObjectStar:

#if( QT_VERSION < QT_VERSION_CHECK(5,0,0) )

case QMetaType::QWidgetStar:

#endif

return PythonQt::priv()->wrapQObject(*((QObject**)data));

default:

if (PythonQt::priv()->isPythonQtAnyObjectPtrMetaId(type)) {

// special case, it is a PythonQtObjectPtr or PythonQtSafeObjectPtr which contains a PyObject, take it directly:

// in case of PythonQtSafeObjectPtr, the cast is wrong but the ptr layout is identical, so that is ok.

PyObject* o = ((PythonQtObjectPtr*)data)->object();

Py_INCREF(o);

return o;

} else {

if (type > 0) {

return createCopyFromMetaType(type, data);

} else {

std::cerr << "Unknown type that can not be converted to Python: " << type << ", in " << __FILE__ << ":" << __LINE__ << std::endl;

}

}

}

Py_RETURN_NONE;

}

void* PythonQtConv::CreateQtReturnValue(const PythonQtMethodInfo::ParameterInfo& info, PythonQtArgumentFrame* frame) {

void* ptr = nullptr;

if (info.pointerCount>1) {

return nullptr;

} else if (info.pointerCount==1) {

PythonQtArgumentFrame_ADD_VALUE(frame, void*, nullptr, ptr);

} else if (info.enumWrapper) {

// create enum return value

PythonQtArgumentFrame_ADD_VALUE(frame, long, 0, ptr);

} else {

switch (info.typeId) {

case QMetaType::Char:

case QMetaType::UChar:

case QMetaType::Short:

case QMetaType::UShort:

case QMetaType::Long:

case QMetaType::ULong:

case QMetaType::Bool:

case QMetaType::Int:

case QMetaType::UInt:

case QMetaType::QChar:

case QMetaType::Float:

case QMetaType::Double:

case QMetaType::LongLong:

case QMetaType::ULongLong:

PythonQtArgumentFrame_ADD_VALUE(frame, qint64, 0, ptr);

break;

case PythonQtMethodInfo::Variant:

PythonQtArgumentFrame_ADD_VARIANT_VALUE(frame, 0, ptr);

// return the ptr to the variant

break;

default:

// check if we have a QList of pointers, which we can circumvent with a QList<void*>

if (info.isQList && (info.innerNamePointerCount == 1)) {

static int id = PythonQtUtils::metaTypeIdFromTypeName("QList<void*>");

PythonQtArgumentFrame_ADD_VARIANT_VALUE_BY_ID(frame, id, ptr);

// return the constData pointer that will be filled with the result value later on

ptr = (void*)((QVariant*)ptr)->constData();

}

if (!ptr && info.typeId != PythonQtMethodInfo::Unknown) {

// everything else is stored in a QVariant, if we know the meta type...

PythonQtArgumentFrame_ADD_VARIANT_VALUE_BY_ID(frame, info.typeId, ptr);

// return the constData pointer that will be filled with the result value later on

ptr = (void*)((QVariant*)ptr)->constData();

}

}

}

return ptr;

}

void* PythonQtConv::castWrapperTo(PythonQtInstanceWrapper* wrapper, const QByteArray& className, bool& ok)

{

void* object;

if (wrapper->classInfo()->isCPPWrapper()) {

object = wrapper->_wrappedPtr;

} else {

QObject* tmp = wrapper->_obj;

object = tmp;

}

if (object) {

// if we can be upcasted to the given name, we pass the casted pointer in:

object = wrapper->classInfo()->castTo(object, className);

ok = object!=nullptr;

} else {

// if it is a NULL ptr, we need to check if it inherits, so that we might pass the NULL ptr

ok = wrapper->classInfo()->inherits(className);

}

return object;

}

void* PythonQtConv::handlePythonToQtAutoConversion(int typeId, PyObject* obj, void* alreadyAllocatedCPPObject, PythonQtArgumentFrame* frame)

{

void* ptr = alreadyAllocatedCPPObject;

static int penId = PythonQtUtils::metaTypeIdFromTypeName("QPen");

static int brushId = PythonQtUtils::metaTypeIdFromTypeName("QBrush");

static int cursorId = PythonQtUtils::metaTypeIdFromTypeName("QCursor");

static int colorId = PythonQtUtils::metaTypeIdFromTypeName("QColor");

static PyObject* qtGlobalColorEnum = PythonQtClassInfo::findEnumWrapper("Qt::GlobalColor", nullptr);

if (typeId == cursorId) {

static PyObject* qtCursorShapeEnum = PythonQtClassInfo::findEnumWrapper("Qt::CursorShape", nullptr);

if ((PyObject*)obj->ob_type == qtCursorShapeEnum) {

Qt::CursorShape val = (Qt::CursorShape)PyLong_AsLong(obj);

if (!ptr) {

PythonQtArgumentFrame_ADD_VARIANT_VALUE(frame, QCursor(), ptr);

ptr = (void*)((QVariant*)ptr)->constData();

}

*((QCursor*)ptr) = QCursor(val);

return ptr;

}

} else if (typeId == penId) {

// brushes can be created from QColor and from Qt::GlobalColor (and from brushes, but that's the default)

static PyObject* qtColorClass = PythonQt::priv()->getClassInfo("QColor")->pythonQtClassWrapper();

if ((PyObject*)obj->ob_type == qtGlobalColorEnum) {

Qt::GlobalColor val = (Qt::GlobalColor)PyLong_AsLong(obj);

if (!ptr) {

PythonQtArgumentFrame_ADD_VARIANT_VALUE(frame, QPen(), ptr);

ptr = (void*)((QVariant*)ptr)->constData();

}

*((QPen*)ptr) = QPen(QColor(val));

return ptr;

} else if ((PyObject*)obj->ob_type == qtColorClass) {

if (!ptr) {

PythonQtArgumentFrame_ADD_VARIANT_VALUE(frame, QPen(), ptr);

ptr = (void*)((QVariant*)ptr)->constData();

}

*((QPen*)ptr) = QPen(*((QColor*)((PythonQtInstanceWrapper*)obj)->_wrappedPtr));

return ptr;

}

} else if (typeId == brushId) {

// brushes can be created from QColor and from Qt::GlobalColor (and from brushes, but that's the default)

static PyObject* qtColorClass = PythonQt::priv()->getClassInfo("QColor")->pythonQtClassWrapper();

if ((PyObject*)obj->ob_type == qtGlobalColorEnum) {

Qt::GlobalColor val = (Qt::GlobalColor)PyLong_AsLong(obj);

if (!ptr) {

PythonQtArgumentFrame_ADD_VARIANT_VALUE(frame, QBrush(), ptr);

ptr = (void*)((QVariant*)ptr)->constData();

}

*((QBrush*)ptr) = QBrush(QColor(val));

return ptr;

} else if ((PyObject*)obj->ob_type == qtColorClass) {

if (!ptr) {

PythonQtArgumentFrame_ADD_VARIANT_VALUE(frame, QBrush(), ptr);

ptr = (void*)((QVariant*)ptr)->constData();

}

*((QBrush*)ptr) = QBrush(*((QColor*)((PythonQtInstanceWrapper*)obj)->_wrappedPtr));

return ptr;

}

} else if (typeId == colorId) {

// colors can be created from Qt::GlobalColor (and from colors, but that's the default)

if ((PyObject*)obj->ob_type == qtGlobalColorEnum) {

Qt::GlobalColor val = (Qt::GlobalColor)PyLong_AsLong(obj);

if (!ptr) {

PythonQtArgumentFrame_ADD_VARIANT_VALUE(frame, QColor(), ptr);

ptr = (void*)((QVariant*)ptr)->constData();

}

*((QColor*)ptr) = QColor(val);

return ptr;

}

}

return nullptr;

}

void* PythonQtConv::ConvertPythonToQt(const PythonQtMethodInfo::ParameterInfo& info, PyObject* obj, bool strict, PythonQtClassInfo* /*classInfo*/, void* alreadyAllocatedCPPObject, PythonQtArgumentFrame* frame)

{

bool ok = false;

void* ptr = nullptr;

// autoconversion of QPen/QBrush/QCursor/QColor from different type

if (info.pointerCount==0 && !strict) {

ptr = handlePythonToQtAutoConversion(info.typeId, obj, alreadyAllocatedCPPObject, frame);

if (ptr) {

return ptr;

}

}

if (info.pointerCount==1 && PythonQtBoolResult_Check(obj) && info.typeId == QMetaType::Bool) {

PythonQtBoolResultObject* boolResul = (PythonQtBoolResultObject*)obj;

// store the wrapped pointer in an extra pointer and let ptr point to the extra pointer

PythonQtArgumentFrame_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,frame, void*, &boolResul->_value, ptr);

return ptr;

}

if (PyObject_TypeCheck(obj, &PythonQtInstanceWrapper_Type) &&

info.typeId != PythonQtMethodInfo::Variant &&

#if QT_VERSION >= 0x060000

info.typeId != byteArrayViewTypeId && // this case is handled later on

#endif

!PythonQt::priv()->isPythonQtAnyObjectPtrMetaId(info.typeId)) {

// if we have a Qt wrapper object and if we do not need a QVariant, we do the following:

// (the Variant case is handled below in a switch)

// a C++ wrapper (can be passed as pointer or reference)

PythonQtInstanceWrapper* wrap = (PythonQtInstanceWrapper*)obj;

void* object = castWrapperTo(wrap, info.name, ok);

if (ok) {

if (info.passOwnershipToCPP) {

// Example: QLayout::addWidget(QWidget*)

wrap->passOwnershipToCPP();

} else if (info.passOwnershipToPython) {

// Example: QLayout::removeWidget(QWidget*)

wrap->passOwnershipToPython();

}

if (info.pointerCount==1) {

// store the wrapped pointer in an extra pointer and let ptr point to the extra pointer

PythonQtArgumentFrame_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,frame, void*, object, ptr);

} else if (info.pointerCount==0) {

// store the wrapped pointer directly, since we are a reference

ptr = object;

}

} else {

// not matching, maybe a PyObject*?

if (info.name == "PyObject" && info.pointerCount==1) {

// handle low level PyObject directly

PythonQtArgumentFrame_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject, frame, void*, obj, ptr);

}

}

} else if (info.pointerCount == 1) {

// a pointer

if (info.typeId == QMetaType::Char || info.typeId == QMetaType::UChar)

{

if (obj->ob_type == &PyBytes_Type) {

// take direct reference to string data

const char* data = PyBytes_AS_STRING(obj);

PythonQtArgumentFrame_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject, frame, void*, (void*)data, ptr);

} else {

// convert to string

QString str = PyObjGetString(obj, strict, ok);

if (ok) {

QByteArray bytes;

bytes = str.toUtf8();

if (ok) {

void* ptr2 = nullptr;

PythonQtArgumentFrame_ADD_VARIANT_VALUE_IF_NEEDED(nullptr,frame, QVariant(bytes), ptr2);

PythonQtArgumentFrame_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,frame, void*, (((QByteArray*)((QVariant*)ptr2)->constData())->data()), ptr);

}

}

}

} else if (info.typeId == QMetaType::QString) {

// TODO: this is a special case for bad Qt APIs which take a QString*, like QtGui.QFileDialog.getSaveFileName

// In general we would need to decide to either support * args for all basic types (ignoring the fact that the

// result value is not useable in Python), or if all these APIs need to be wrapped manually/differently, like PyQt/PySide do.

QString str = PyObjGetString(obj, strict, ok);

if (ok) {

void* ptr2 = nullptr;

PythonQtArgumentFrame_ADD_VARIANT_VALUE_IF_NEEDED(nullptr,frame, QVariant(str), ptr2);

PythonQtArgumentFrame_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,frame, void*, (void*)((QVariant*)ptr2)->constData(), ptr);

}

} else if (info.name == "PyObject") {

// handle low level PyObject directly

PythonQtArgumentFrame_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject, frame, void*, obj, ptr);

} else if (obj == Py_None) {

// None is treated as a NULL ptr

PythonQtArgumentFrame_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject, frame, void*, nullptr, ptr);

} else {

void* foreignWrapper = PythonQt::priv()->unwrapForeignWrapper(info.name, obj);

if (foreignWrapper) {

PythonQtArgumentFrame_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject, frame, void*, foreignWrapper, ptr);

} else {

// if we are not strict, we try if we are passed a 0 integer

if (!strict) {

bool ok;

int value = PyObjGetInt(obj, true, ok);

if (ok && value==0) {

PythonQtArgumentFrame_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject, frame, void*, nullptr, ptr);

}

}

}

}

} else if (info.pointerCount == 0) {

// not a pointer

switch (info.typeId) {

case QMetaType::Char:

{

int val = PyObjGetInt(obj, strict, ok);

if (ok && (val >= CHAR_MIN && val <= CHAR_MAX)) {

PythonQtArgumentFrame_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject, frame, char, val, ptr);

}

}

break;

case QMetaType::UChar:

{

int val = PyObjGetInt(obj, strict, ok);

if (ok && (val >= 0 && val <= UCHAR_MAX)) {

PythonQtArgumentFrame_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject, frame, unsigned char, val, ptr);

}

}

break;

case QMetaType::Short:

{

int val = PyObjGetInt(obj, strict, ok);

if (ok && (val >= SHRT_MIN && val <= SHRT_MAX)) {

PythonQtArgumentFrame_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject, frame, short, val, ptr);

}

}

break;

case QMetaType::UShort:

{

int val = PyObjGetInt(obj, strict, ok);

if (ok && (val >= 0 && val <= USHRT_MAX)) {

PythonQtArgumentFrame_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject, frame, unsigned short, val, ptr);

}

}

break;

case QMetaType::Long:

{

auto val = PyObjGetLongLong(obj, strict, ok);

if (ok && (val >= LONG_MIN && val <= LONG_MAX)) {

PythonQtArgumentFrame_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject, frame, long, val, ptr);

}

}

break;

case QMetaType::ULong:

{

auto val = PyObjGetULongLong(obj, strict, ok);

if (ok && val <= ULONG_MAX) {

PythonQtArgumentFrame_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject, frame, unsigned long, val, ptr);

}

}

break;

case QMetaType::Bool:

{

bool val = PyObjGetBool(obj, strict, ok);

if (ok) {

PythonQtArgumentFrame_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject, frame, bool, val, ptr);

}

}

break;

case QMetaType::Int:

{

qint64 val = PyObjGetLongLong(obj, strict, ok);

if (ok && (val >= INT_MIN && val <= INT_MAX)) {

PythonQtArgumentFrame_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject, frame, int, val, ptr);

}

}

break;

case QMetaType::UInt:

{

auto val = PyObjGetLongLong(obj, strict, ok);

if (ok && (val >= 0 && val <= UINT_MAX)) {

PythonQtArgumentFrame_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject, frame, unsigned int, val, ptr);

}

}

break;

case QMetaType::QChar:

{

int val = PyObjGetInt(obj, strict, ok);

if (ok && (val >= 0 && val <= USHRT_MAX)) {

PythonQtArgumentFrame_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject, frame, unsigned short, val, ptr);

}

}

break;

case QMetaType::Float:

{

float val = (float)PyObjGetDouble(obj, strict, ok);

if (ok) {

PythonQtArgumentFrame_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject, frame, float, val, ptr);

}

}

break;

case QMetaType::Double:

{

double val = PyObjGetDouble(obj, strict, ok);

if (ok) {

PythonQtArgumentFrame_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject, frame, double, val, ptr);

}

}

break;

case QMetaType::LongLong:

{

qint64 val = PyObjGetLongLong(obj, strict, ok);

if (ok) {

PythonQtArgumentFrame_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject, frame, qint64, val, ptr);

}

}

break;

case QMetaType::ULongLong:

{

quint64 val = PyObjGetULongLong(obj, strict, ok);

if (ok) {

PythonQtArgumentFrame_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject, frame, quint64, val, ptr);

}

}

break;

case QMetaType::QByteArray:

{

QByteArray bytes = PyObjGetBytesAllowString(obj, strict, ok);

if (ok) {

PythonQtArgumentFrame_ADD_VARIANT_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,frame, QVariant(bytes), ptr);

ptr = (void*)((QVariant*)ptr)->constData();

}

}

break;

case QMetaType::QString:

{

QString str = PyObjGetString(obj, strict, ok);

if (ok) {

PythonQtArgumentFrame_ADD_VARIANT_VALUE_IF_NEEDED(alreadyAllocatedCPPObject, frame, QVariant(str), ptr);

ptr = (void*)((QVariant*)ptr)->constData();

}

}

break;

case QMetaType::QStringList:

{

QStringList l = PyObjToStringList(obj, strict, ok);

if (ok) {

PythonQtArgumentFrame_ADD_VARIANT_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,frame, QVariant(l), ptr);

ptr = (void*)((QVariant*)ptr)->constData();

}

}

break;

case PythonQtMethodInfo::Variant:

{

QVariant v = PyObjToQVariant(obj);

// the only case where conversion can fail it None and we want to pass that to, e.g. setProperty(),

// so we do not check v.isValid() here

PythonQtArgumentFrame_ADD_VARIANT_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,frame, v, ptr);

}

break;

default:

{

// check for enum case

if (info.enumWrapper) {

unsigned int val = 0;

ok = false;

if ((PyObject*)obj->ob_type == info.enumWrapper) {

// we have a exact enum type match:

val = PyLong_AS_LONG(obj);

ok = true;

}

else if (!strict) {

// we try to get any integer, when not being strict. If we are strict, integers are not wanted because

// we want an integer overload to be taken first!

val = (unsigned int)PyObjGetLongLong(obj, false, ok);

}

if (ok) {

PythonQtArgumentFrame_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject, frame, unsigned int, val, ptr);

return ptr;

}

else {

return nullptr;

}

}

// Handle QStringView et al, which need a reference to a persistent QString

#if QT_VERSION < 0x060000

if (info.typeId == stringRefTypeId) {

QString str = PyObjGetString(obj, strict, ok);

if (ok) {

void* ptr2 = nullptr;

PythonQtArgumentFrame_ADD_VARIANT_VALUE_IF_NEEDED(nullptr, frame, QVariant(str), ptr2);

PythonQtArgumentFrame_ADD_VARIANT_VALUE_IF_NEEDED(alreadyAllocatedCPPObject, frame,

QVariant::fromValue(QStringRef((const QString*)((QVariant*)ptr2)->constData())), ptr);

ptr = (void*)((QVariant*)ptr)->constData();

return ptr;

}

else {

return nullptr;

}

}

#else

if (info.typeId == stringViewTypeId) {

// Handle QStringView, which needs a reference to a persistent QString

QString str = PyObjGetString(obj, strict, ok);

if (ok) {

void* ptr2 = nullptr;

PythonQtArgumentFrame_ADD_VARIANT_VALUE_IF_NEEDED(nullptr, frame, QVariant(str), ptr2);

PythonQtArgumentFrame_ADD_VARIANT_VALUE_IF_NEEDED(alreadyAllocatedCPPObject, frame,

QVariant::fromValue(QStringView(*((const QString*)((QVariant*)ptr2)->constData()))), ptr);

ptr = (void*)((QVariant*)ptr)->constData();

return ptr;

}

else {

return nullptr;

}

}

else if (info.typeId == anyStringViewTypeId) {

// Handle QAnyStringView, which needs a reference to a persistent QString

QString str = PyObjGetString(obj, strict, ok);

if (ok) {

void* ptr2 = nullptr;

PythonQtArgumentFrame_ADD_VARIANT_VALUE_IF_NEEDED(nullptr, frame, QVariant(str), ptr2);

PythonQtArgumentFrame_ADD_VARIANT_VALUE_IF_NEEDED(alreadyAllocatedCPPObject, frame,

QVariant::fromValue(QAnyStringView(*((const QString*)((QVariant*)ptr2)->constData()))), ptr);

ptr = (void*)((QVariant*)ptr)->constData();

return ptr;

}

else {

return nullptr;

}

}

else if (info.typeId == byteArrayViewTypeId) {

// Handle QByteArrayView, which needs a reference to a persistent QByteArray

QByteArray ba = PyObjGetBytesAllowString(obj, strict, ok);

if (ok) {

void* ptr2 = nullptr;

PythonQtArgumentFrame_ADD_VARIANT_VALUE_IF_NEEDED(nullptr, frame, QVariant(ba), ptr2);

PythonQtArgumentFrame_ADD_VARIANT_VALUE_IF_NEEDED(alreadyAllocatedCPPObject, frame,

QVariant::fromValue(QByteArrayView(*((const QByteArray*)((QVariant*)ptr2)->constData()))), ptr);

ptr = (void*)((QVariant*)ptr)->constData();

return ptr;

}

else {

return nullptr;

}

}

#endif

if (info.typeId == PythonQtMethodInfo::Unknown || info.typeId >= QMetaType::User) {

// check for QList<AnyPtr*> case, where we will use a QList<void*> QVariant

if (info.isQList && (info.innerNamePointerCount == 1)) {

static int id = PythonQtUtils::metaTypeIdFromTypeName("QList<void*>");

if (!alreadyAllocatedCPPObject) {

PythonQtArgumentFrame_ADD_VARIANT_VALUE_BY_ID_IF_NEEDED(alreadyAllocatedCPPObject, frame, id, ptr);

ptr = (void*)((QVariant*)ptr)->constData();

} else {

ptr = alreadyAllocatedCPPObject;

}

ok = ConvertPythonListToQListOfPointerType(obj, (QList<void*>*)ptr, info, strict);

if (ok) {

return ptr;

} else {

return nullptr;

}

}

}

// We only do this for registered type > QMetaType::User for performance reasons.

if (info.typeId >= QMetaType::User || info.typeId == QMetaType::QByteArrayList) {

// Maybe we have a special converter that is registered for that type:

PythonQtConvertPythonToMetaTypeCB* converter = _pythonToMetaTypeConverters.value(info.typeId);

if (converter) {

if (!alreadyAllocatedCPPObject) {

// create a new empty variant of concrete type:

PythonQtArgumentFrame_ADD_VARIANT_VALUE_BY_ID_IF_NEEDED(alreadyAllocatedCPPObject,frame, info.typeId, ptr);

ptr = (void*)((QVariant*)ptr)->constData();

} else {

ptr = alreadyAllocatedCPPObject;

}

// now call the converter, passing the internal object of the variant

ok = (*converter)(obj, ptr, info.typeId, strict);

if (ok) {

return ptr;

} else {

return nullptr;

}

}

}

// if no type id is available, conversion to a QVariant makes no sense/is not possible

if (info.typeId != PythonQtMethodInfo::Unknown) {

// for all other types, we use the same qvariant conversion and pass out the constData of the variant:

QVariant v = PyObjToQVariant(obj, info.typeId);

if (v.isValid()) {

PythonQtArgumentFrame_ADD_VARIANT_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,frame, v, ptr);

ptr = (void*)((QVariant*)ptr)->constData();

}

}

}

}

}

return ptr;

}

QStringList PythonQtConv::PyObjToStringList(PyObject* val, bool strict, bool& ok) {

}

QString PythonQtConv::PyObjGetRepresentation(PyObject* val)

}

QString PythonQtConv::PyObjGetString(PyObject* val, bool strict, bool& ok) {

}

QByteArray PythonQtConv::PyObjGetBytes(PyObject* val, bool /*strict*/, bool& ok) {

}

QByteArray PythonQtConv::PyObjGetBytesAllowString(PyObject* val, bool strict, bool& ok)

}

bool PythonQtConv::PyObjGetBool(PyObject* val, bool strict, bool &ok) {

}

int PythonQtConv::PyObjGetInt(PyObject* val, bool strict, bool &ok) {

}

qint64 PythonQtConv::PyObjGetLongLong(PyObject* val, bool strict, bool &ok) {

}

quint64 PythonQtConv::PyObjGetULongLong(PyObject* val, bool strict, bool &ok) {

}

double PythonQtConv::PyObjGetDouble(PyObject* val, bool strict, bool &ok) {