#include "PythonQt.h"

#include "PythonQtImporter.h"

#include "PythonQtClassInfo.h"

#include "PythonQtMethodInfo.h"

#include "PythonQtSignal.h"

#include "PythonQtSignalReceiver.h"

#include "PythonQtConversion.h"

#include "PythonQtProperty.h"

#include "PythonQtStdIn.h"

#include "PythonQtStdOut.h"

#include "PythonQtCppWrapperFactory.h"

#include "PythonQtVariants.h"

#include "PythonQtStdDecorators.h"

#include "PythonQtQFileImporter.h"

#include "PythonQtBoolResult.h"

#include "PythonQtSlotDecorator.h"

#include <QDir>

#if PY_VERSION_HEX >= 0x030A0000

#include <cpython/pydebug.h>

#else

#include <pydebug.h>

#endif

#if PY_VERSION_HEX < 0x030B0000

static inline PyObject *PyCode_GetVarnames(PyCodeObject *o) {

Py_XINCREF(o->co_varnames);

return o->co_varnames;

}

#endif

#include <vector>

PythonQt* PythonQt::_self = nullptr;

int PythonQt::_uniqueModuleCount = 0;

void PythonQt_init_QtGuiBuiltin(PyObject*);

void PythonQt_init_QtCoreBuiltin(PyObject*);

void PythonQt::init(int flags, const QByteArray& pythonQtModuleName)

}

void PythonQt::cleanup()

}

PythonQt* PythonQt::self() { return _self; }

PythonQt::PythonQt(int flags, const QByteArray& pythonQtModuleName)

}

PythonQt::~PythonQt() {

delete _p;

_p = nullptr;

}

PythonQtPrivate::~PythonQtPrivate() {

delete _defaultImporter;

_defaultImporter = nullptr;

{

qDeleteAll(_knownClassInfos);

}

PythonQtMethodInfo::cleanupCachedMethodInfos();

PythonQtArgumentFrame::cleanupFreeList();

}

void PythonQtPrivate::setTaskDoneCallback(const PythonQtObjectPtr & callable)

{

_pyTaskDoneCallback = callable;

}

PythonQtObjectPtr PythonQtPrivate::checkAndRunCoroutine(const PythonQtObjectPtr& object)

}

PythonQtObjectPtr PythonQtPrivate::createAsyncioFuture()

}

void PythonQt::setRedirectStdInCallback(PythonQtInputChangedCB* callback, void * callbackData)

}

void PythonQt::setRedirectStdInCallbackEnabled(bool enabled)

}

PythonQtImportFileInterface* PythonQt::importInterface()

{

return _self->_p->_importInterface?_self->_p->_importInterface:_self->_p->_defaultImporter;

}

void PythonQt::qObjectNoLongerWrappedCB(QObject* o)

}

void PythonQt::setQObjectMissingAttributeCallback(PythonQtQObjectMissingAttributeCB* cb)

{

_self->_p->_qObjectMissingAttribCB = cb;

}

QString PythonQt::qObjectMissingAttributeCallback(QObject* o, const QString& attribute)

}

void PythonQt::registerClass(const QMetaObject* metaobject, const char* package, PythonQtQObjectCreatorFunctionCB* wrapperCreator, PythonQtShellSetInstanceWrapperCB* shell)

{

_p->registerClass(metaobject, package, wrapperCreator, shell);

}

void PythonQtPrivate::registerClass(const QMetaObject* metaobject, const char* package, PythonQtQObjectCreatorFunctionCB* wrapperCreator, PythonQtShellSetInstanceWrapperCB* shell, PyObject* module, int typeSlots)

}

void PythonQtPrivate::createPythonQtClassWrapper(PythonQtClassInfo* info, const char* package, PyObject* module)

}

PyObject* PythonQtPrivate::wrapQObject(QObject* obj)

{

if (!obj) {

Py_INCREF(Py_None);

return Py_None;

}

PythonQtInstanceWrapper* wrap = findWrapperAndRemoveUnused(obj);

if (wrap && wrap->_wrappedPtr) {

// uh oh, we want to wrap a QObject, but have a C++ wrapper at that

// address, so probably that C++ wrapper has been deleted earlier and

// now we see a QObject with the same address.

// Do not use the old wrapper anymore.

wrap = nullptr;

}

if (!wrap) {

// smuggling it in...

PythonQtClassInfo* classInfo = _knownClassInfos.value(obj->metaObject()->className());

if (!classInfo || classInfo->pythonQtClassWrapper()==nullptr) {

registerClass(obj->metaObject());

classInfo = _knownClassInfos.value(obj->metaObject()->className());

}

wrap = createNewPythonQtInstanceWrapper(obj, classInfo);

// mlabDebugConst("MLABPython","new qobject wrapper added " << " " << wrap->_obj->className() << " " << wrap->classInfo()->wrappedClassName().latin1());

} else {

Py_INCREF(wrap);

// mlabDebugConst("MLABPython","qobject wrapper reused " << wrap->_obj->className() << " " << wrap->classInfo()->wrappedClassName().latin1());

}

return (PyObject*)wrap;

}

PyObject* PythonQtPrivate::wrapPtr(void* ptr, const QByteArray& name, bool passOwnership)

{

if (!ptr) {

Py_INCREF(Py_None);

return Py_None;

}

PythonQtInstanceWrapper* wrap = findWrapperAndRemoveUnused(ptr);

PythonQtInstanceWrapper* possibleStillAliveWrapper = nullptr;

if (wrap && wrap->_wrappedPtr) {

// we have a previous C++ wrapper... if the wrapper is for a C++ object,

// we are not sure if it may have been deleted earlier and we just see the same C++

// pointer once again. To make sure that we do not reuse a wrapper of the wrong type,

// we compare the classInfo() pointer and only reuse the wrapper if it has the same

// info. This is only needed for non-QObjects, since we know it when a QObject gets deleted.

possibleStillAliveWrapper = wrap;

wrap = nullptr;

}

if (!wrap) {

PythonQtClassInfo* info = getClassInfo(name);

if (!info) {

// maybe it is a PyObject, which we can return directly

if (name == "PyObject") {

// do not increment its ref-count, it is the job of the slot returning the value

// to ensure an extra ref on return.

return (PyObject*)ptr;

}

// we do not know the metaobject yet, but we might know it by its name:

if (_knownQObjectClassNames.find(name)!=_knownQObjectClassNames.end()) {

// yes, we know it, so we can convert to QObject

QObject* qptr = (QObject*)ptr;

registerClass(qptr->metaObject());

info = _knownClassInfos.value(qptr->metaObject()->className());

}

}

if (info && info->isQObject()) {

QObject* qptr = (QObject*)ptr;

// if the object is a derived object, we want to switch the class info to the one of the derived class:

if (name!=(qptr->metaObject()->className())) {

info = _knownClassInfos.value(qptr->metaObject()->className());

if (!info || (info->pythonQtClassWrapper() == nullptr)) {

registerClass(qptr->metaObject());

info = _knownClassInfos.value(qptr->metaObject()->className());

}

}

wrap = createNewPythonQtInstanceWrapper(qptr, info);

wrap->_ownedByPythonQt = passOwnership;

// mlabDebugConst("MLABPython","new qobject wrapper added " << " " << wrap->_obj->className() << " " << wrap->classInfo()->wrappedClassName().latin1());

return (PyObject*)wrap;

}

// not a known QObject, try to wrap via foreign wrapper factories

PyObject* foreignWrapper = nullptr;

for (int i=0; i<_foreignWrapperFactories.size(); i++) {

foreignWrapper = _foreignWrapperFactories.at(i)->wrap(name, ptr);

if (foreignWrapper) {

return foreignWrapper;

}

}

// not a known QObject, so try our wrapper factory:

QObject* wrapper = nullptr;

for (int i=0; i<_cppWrapperFactories.size(); i++) {

wrapper = _cppWrapperFactories.at(i)->create(name, ptr);

if (wrapper) {

break;

}

}

if (info) {

// try to downcast in the class hierarchy, which will modify info and ptr if it is successfull

ptr = info->castDownIfPossible(ptr, &info);

// if downcasting found out that the object is a QObject,

// handle it like one:

if (info && info->isQObject()) {

QObject* qptr = (QObject*)ptr;

// if the object is a derived object, we want to switch the class info to the one of the derived class:

if (name!=(qptr->metaObject()->className())) {

registerClass(qptr->metaObject());

info = _knownClassInfos.value(qptr->metaObject()->className());

}

wrap = createNewPythonQtInstanceWrapper(qptr, info);

wrap->_ownedByPythonQt = passOwnership;

// mlabDebugConst("MLABPython","new qobject wrapper added " << " " << wrap->_obj->className() << " " << wrap->classInfo()->wrappedClassName().latin1());

return (PyObject*)wrap;

}

}

if (!info || info->pythonQtClassWrapper()==nullptr) {

// still unknown, register as CPP class

registerCPPClass(name.constData());

info = _knownClassInfos.value(name);

}

if (wrapper && (info->metaObject() != wrapper->metaObject())) {

// if we a have a QObject wrapper and the metaobjects do not match, set the metaobject again!

info->setMetaObject(wrapper->metaObject());

}

if (possibleStillAliveWrapper && possibleStillAliveWrapper->classInfo()->inherits(info)) {

wrap = possibleStillAliveWrapper;

Py_INCREF(wrap);

} else {

wrap = createNewPythonQtInstanceWrapper(wrapper, info, ptr);

wrap->_ownedByPythonQt = passOwnership;

}

// mlabDebugConst("MLABPython","new c++ wrapper added " << wrap->_wrappedPtr << " " << wrap->_obj->className() << " " << wrap->classInfo()->wrappedClassName().latin1());

} else {

Py_INCREF(wrap);

//mlabDebugConst("MLABPython","c++ wrapper reused " << wrap->_wrappedPtr << " " << wrap->_obj->className() << " " << wrap->classInfo()->wrappedClassName().latin1());

}

return (PyObject*)wrap;

}

PyObject* PythonQtPrivate::dummyTuple() {

static PyObject* dummyTuple = nullptr;

if (dummyTuple==nullptr) {

dummyTuple = PyTuple_New(1);

PyTuple_SET_ITEM(dummyTuple, 0 , PyString_FromString("dummy"));

}

return dummyTuple;

}

PythonQtInstanceWrapper* PythonQtPrivate::createNewPythonQtInstanceWrapper(QObject* obj, PythonQtClassInfo* info, void* wrappedPtr) {

// call the associated class type to create a new instance...

PythonQtInstanceWrapper* result = (PythonQtInstanceWrapper*)PyObject_Call(info->pythonQtClassWrapper(), dummyTuple(), nullptr);

result->setQObject(obj);

result->_wrappedPtr = wrappedPtr;

result->_ownedByPythonQt = false;

result->_useQMetaTypeDestroy = false;

if (wrappedPtr || obj) {

// if this object is reference counted, we ref it:

PythonQtVoidPtrCB* refCB = info->referenceCountingRefCB();

if (refCB) {

(*refCB)(wrappedPtr);

}

if (wrappedPtr) {

_wrappedObjects.insert(wrappedPtr, result);

} else {

_wrappedObjects.insert(obj, result);

if (obj->parent()== nullptr && _wrappedCB) {

// tell someone who is interested that the qobject is wrapped the first time, if it has no parent

(*_wrappedCB)(obj);

}

}

}

return result;

}

PythonQtClassWrapper* PythonQtPrivate::createNewPythonQtClassWrapper(PythonQtClassInfo* info, PyObject* parentModule, const QByteArray& pythonClassName) {

PythonQtClassWrapper* result;

PyObject* className = PyString_FromString(pythonClassName.constData());

PyObject* baseClasses = PyTuple_New(1);

Py_INCREF((PyObject*)&PythonQtInstanceWrapper_Type);

PyTuple_SET_ITEM(baseClasses, 0, (PyObject*)&PythonQtInstanceWrapper_Type);

PyObject* typeDict = PyDict_New();

PyObject* moduleName = PyObject_GetAttrString(parentModule, "__name__");

PyDict_SetItemString(typeDict, "__module__", moduleName);

PyObject* args = Py_BuildValue("OOO", className, baseClasses, typeDict);

// set the class info so that PythonQtClassWrapper_new can read it

_currentClassInfoForClassWrapperCreation = info;

// create the new type object by calling the type

result = (PythonQtClassWrapper *)PyObject_Call((PyObject *)&PythonQtClassWrapper_Type, args, nullptr);

Py_DECREF(baseClasses);

Py_DECREF(typeDict);

Py_DECREF(moduleName);

Py_DECREF(args);

Py_DECREF(className);

return result;

}

PyObject* PythonQtPrivate::createEnumValueInstance(PyObject* enumType, unsigned int enumValue)

{

PyObject* args = Py_BuildValue("(i)", enumValue);

PyObject* result = PyObject_Call(enumType, args, nullptr);

Py_DECREF(args);

return result;

}

PyObject* PythonQtPrivate::createNewPythonQtEnumWrapper(const char* enumName, PyObject* parentObject) {

PyObject* result;

PyObject* className = PyString_FromString(enumName);

PyObject* baseClasses = PyTuple_New(1);

Py_INCREF(&PyInt_Type);

PyTuple_SET_ITEM(baseClasses, 0, (PyObject*)&PyInt_Type);

PyObject* module = PyObject_GetAttrString(parentObject, "__module__");

PyObject* typeDict = PyDict_New();

PyDict_SetItemString(typeDict, "__module__", module);

PyObject* args = Py_BuildValue("OOO", className, baseClasses, typeDict);

// create the new int derived type object by calling the core type

result = PyObject_Call((PyObject *)&PyType_Type, args, nullptr);

Py_DECREF(baseClasses);

Py_DECREF(module);

Py_DECREF(typeDict);

Py_DECREF(args);

Py_DECREF(className);

return result;

}

PythonQtSignalReceiver* PythonQt::getSignalReceiver(QObject* obj)

{

PythonQtSignalReceiver* r = _p->_signalReceivers[obj];

if (!r) {

r = new PythonQtSignalReceiver(obj);

_p->_signalReceivers.insert(obj, r);

}

return r;

}

bool PythonQt::addSignalHandler(QObject* obj, const char* signal, PyObject* module, const QString& objectname)

}

bool PythonQt::addSignalHandler(QObject* obj, const char* signal, PyObject* receiver)

}

bool PythonQt::removeSignalHandler(QObject* obj, const char* signal, PyObject* module, const QString& objectname)

}

bool PythonQt::removeSignalHandler(QObject* obj, const char* signal, PyObject* receiver)

}

PythonQtObjectPtr PythonQt::lookupCallable(PyObject* module, const QString& name)

}

PythonQtObjectPtr PythonQt::lookupObject(PyObject* module, const QString& name)

}

PythonQtObjectPtr PythonQt::getMainModule() {

}

PythonQtObjectPtr PythonQt::importModule(const QString& name)

}