#include "PythonQt.h"

#include "PythonQtImporter.h"

#include "PythonQtClassInfo.h"

#include "PythonQtMethodInfo.h"

#include "PythonQtSignalReceiver.h"

#include "PythonQtConversion.h"

#include "PythonQtStdOut.h"

#include "PythonQtCppWrapperFactory.h"

#include "PythonQtVariants.h"

#include "PythonQtStdDecorators.h"

#include "PythonQtQFileImporter.h"

#include <pydebug.h>

#include <vector>

PythonQt* PythonQt::_self = NULL;

int PythonQt::_uniqueModuleCount = 0;

void PythonQt_init_QtGuiBuiltin();

void PythonQt_init_QtCoreBuiltin();

void PythonQt::init(int flags)

}

void PythonQt::cleanup()

}

PythonQt::PythonQt(int flags)

}

PythonQt::~PythonQt() {

delete _p;

_p = NULL;

}

PythonQtPrivate::~PythonQtPrivate() {

delete _defaultImporter;

_defaultImporter = NULL;

{

QHashIterator<QByteArray, PythonQtClassInfo *> i(_knownClassInfos);

while (i.hasNext()) {

delete i.next().value();

}

}

PythonQtConv::global_valueStorage.clear();

PythonQtConv::global_ptrStorage.clear();

PythonQtConv::global_variantStorage.clear();

PythonQtMethodInfo::cleanupCachedMethodInfos();

}

PythonQtImportFileInterface* PythonQt::importInterface()

{

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

}

void PythonQt::qObjectNoLongerWrappedCB(QObject* o)

}

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)

}

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

}

PyObject* PythonQtPrivate::wrapQObject(QObject* obj)

{

if (!obj) {

Py_INCREF(Py_None);

return Py_None;

}

PythonQtInstanceWrapper* wrap = findWrapperAndRemoveUnused(obj);

if (!wrap) {

// smuggling it in...

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

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

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)

{

if (!ptr) {

Py_INCREF(Py_None);

return Py_None;

}

PythonQtInstanceWrapper* wrap = findWrapperAndRemoveUnused(ptr);

if (!wrap) {

PythonQtClassInfo* info = _knownClassInfos.value(name);

if (!info) {

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

if (name == "PyObject") {

PyObject* p = (PyObject*)ptr;

Py_INCREF(p);

return p;

}

// we do not know the metaobject yet, but we might know it by it's 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())) {

registerClass(qptr->metaObject());

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

}

wrap = createNewPythonQtInstanceWrapper(qptr, info);

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

return (PyObject*)wrap;

}

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

QObject* wrapper = NULL;

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 (!info || info->pythonQtClassWrapper()==NULL) {

// 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());

}

wrap = createNewPythonQtInstanceWrapper(wrapper, info, ptr);

// 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 = NULL;

if (dummyTuple==NULL) {

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(), NULL);

result->setQObject(obj);

result->_wrappedPtr = wrappedPtr;

result->_ownedByPythonQt = false;

result->_useQMetaTypeDestroy = false;

if (wrappedPtr) {

_wrappedObjects.insert(wrappedPtr, result);

} else {

_wrappedObjects.insert(obj, result);

if (obj->parent()== NULL && _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, const char* package) {

PythonQtClassWrapper* result;

PyObject* className = PyString_FromString(info->className());

PyObject* baseClasses = PyTuple_New(1);

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

PyObject* typeDict = PyDict_New();

QByteArray moduleName("PythonQt");

if (package && strcmp(package, "")!=0) {

moduleName += ".";

moduleName += package;

}

PyDict_SetItemString(typeDict, "__module__", PyString_FromString(moduleName.constData()));

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, NULL);

Py_DECREF(baseClasses);

Py_DECREF(typeDict);

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, NULL);

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);

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, NULL);

Py_DECREF(baseClasses);

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() {

}

QVariant PythonQt::evalCode(PyObject* object, PyObject* pycode) {

}

QVariant PythonQt::evalScript(PyObject* object, const QString& script, int start)

}

void PythonQt::evalFile(PyObject* module, const QString& filename)

}

PythonQtObjectPtr PythonQt::parseFile(const QString& filename)

}

PythonQtObjectPtr PythonQt::createModuleFromFile(const QString& name, const QString& filename)

}

PythonQtObjectPtr PythonQt::createModuleFromScript(const QString& name, const QString& script)

}

PythonQtObjectPtr PythonQt::createUniqueModule()

}

void PythonQt::addObject(PyObject* object, const QString& name, QObject* qObject)

}

void PythonQt::addVariable(PyObject* object, const QString& name, const QVariant& v)

}

void PythonQt::removeVariable(PyObject* object, const QString& name)

}

QVariant PythonQt::getVariable(PyObject* object, const QString& objectname)

}

QStringList PythonQt::introspection(PyObject* module, const QString& objectname, PythonQt::ObjectType type)

}

QVariant PythonQt::call(PyObject* object, const QString& name, const QVariantList& args)

}

QVariant PythonQt::call(PyObject* callable, const QVariantList& args)

}

PyObject* PythonQt::callAndReturnPyObject(PyObject* callable, const QVariantList& args)

{

PyObject* result = NULL;

if (callable) {

PythonQtObjectPtr pargs;

int count = args.size();

if (count>0) {

pargs.setNewRef(PyTuple_New(count));

}

bool err = false;

// transform QVariants to Python

for (int i = 0; i < count; i++) {

PyObject* arg = PythonQtConv::QVariantToPyObject(args.at(i));

if (arg) {

// steals reference, no unref

PyTuple_SetItem(pargs, i,arg);

} else {

err = true;

break;

}

}

if (!err) {

PyErr_Clear();

result = PyObject_CallObject(callable, pargs);

}

}

return result;

}

void PythonQt::addInstanceDecorators(QObject* o)

{

_p->addDecorators(o, PythonQtPrivate::InstanceDecorator);

}

void PythonQt::addClassDecorators(QObject* o)

{

_p->addDecorators(o, PythonQtPrivate::StaticDecorator | PythonQtPrivate::ConstructorDecorator | PythonQtPrivate::DestructorDecorator);

}

void PythonQt::addDecorators(QObject* o)

{

_p->addDecorators(o, PythonQtPrivate::AllDecorators);

}

void PythonQt::registerQObjectClassNames(const QStringList& names)

{

_p->registerQObjectClassNames(names);

}

void PythonQt::setImporter(PythonQtImportFileInterface* importInterface)

}

void PythonQt::setImporterIgnorePaths(const QStringList& paths)

{

_p->_importIgnorePaths = paths;

}

const QStringList& PythonQt::getImporterIgnorePaths()

{

return _p->_importIgnorePaths;

}

void PythonQt::addWrapperFactory(PythonQtCppWrapperFactory* factory)

{

_p->_cppWrapperFactories.append(factory);

}

PythonQtPrivate::PythonQtPrivate()

}

void PythonQtPrivate::setupSharedLibrarySuffixes()

}

PythonQtClassInfo* PythonQtPrivate::currentClassInfoForClassWrapperCreation()

{

PythonQtClassInfo* info = _currentClassInfoForClassWrapperCreation;

_currentClassInfoForClassWrapperCreation = NULL;

return info;

}

void PythonQtPrivate::addDecorators(QObject* o, int decoTypes)

}

void PythonQtPrivate::registerQObjectClassNames(const QStringList& names)

}

void PythonQtPrivate::removeSignalEmitter(QObject* obj)

{

_signalReceivers.remove(obj);

}

bool PythonQt::handleError()