/*

*

* Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.

*

* This library is free software; you can redistribute it and/or

* modify it under the terms of the GNU Lesser General Public

* License as published by the Free Software Foundation; either

* version 2.1 of the License, or (at your option) any later version.

*

* This library is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

* Lesser General Public License for more details.

*

* Further, this software is distributed without any warranty that it is

* free of the rightful claim of any third person regarding infringement

* or the like. Any license provided herein, whether implied or

* otherwise, applies only to this software file. Patent licenses, if

* any, provided herein do not apply to combinations of this program with

* other software, or any other product whatsoever.

*

* You should have received a copy of the GNU Lesser General Public

* License along with this library; if not, write to the Free Software

* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

*

* Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,

* 28359 Bremen, Germany or:

*

* http://www.mevis.de

*

*/

//----------------------------------------------------------------------------------

/*!

// \file PythonQt.cpp

// \author Florian Link

// \author Last changed by $Author: florian $

// \date 2006-05

*/

//----------------------------------------------------------------------------------

#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

// .co_varnames was removed in 3.11, but the helper function was added

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

{

if (!_self) {

_self = new PythonQt(flags, pythonQtModuleName);

_self->_p->_PythonQtObjectPtr_metaId = qRegisterMetaType<PythonQtObjectPtr>("PythonQtObjectPtr");

PythonQtConv::registerMetaTypeToPythonConverter(_self->_p->_PythonQtObjectPtr_metaId, PythonQtConv::convertFromPythonQtObjectPtr);

PythonQtConv::registerPythonToMetaTypeConverter(_self->_p->_PythonQtObjectPtr_metaId, PythonQtConv::convertToPythonQtObjectPtr);

_self->_p->_PythonQtSafeObjectPtr_metaId = qRegisterMetaType<PythonQtSafeObjectPtr>("PythonQtSafeObjectPtr");

PythonQtConv::registerMetaTypeToPythonConverter(_self->_p->_PythonQtSafeObjectPtr_metaId, PythonQtConv::convertFromPythonQtSafeObjectPtr);

PythonQtConv::registerPythonToMetaTypeConverter(_self->_p->_PythonQtSafeObjectPtr_metaId, PythonQtConv::convertToPythonQtSafeObjectPtr);

PythonQtObjectPtr importlib;

importlib.setNewRef(PyImport_ImportModule("importlib.machinery"));

if (importlib) {

_self->_p->_pySourceFileLoader = importlib.getVariable("SourceFileLoader");

_self->_p->_pySourcelessFileLoader = importlib.getVariable("SourcelessFileLoader");

}

#ifdef PY3K

PythonQtObjectPtr asyncio;

asyncio.setNewRef(PyImport_ImportModule("asyncio"));

if (asyncio)

{

_self->_p->_pyEnsureFuture = asyncio.getVariable("ensure_future");

_self->_p->_pyFutureClass = asyncio.getVariable("Future");

}

#endif

PythonQt::priv()->setupSharedLibrarySuffixes();

PythonQtMethodInfo::addParameterTypeAlias("QObjectList", "QList<QObject*>");

qRegisterMetaType<QList<QObject*> >("QList<void*>");

qRegisterMetaType<QObjectList>("QObjectList");

qRegisterMetaType<QList<QObject*> >("QList<QObject*>");

if (QT_POINTER_SIZE == 8) {

qRegisterMetaType<quint64>("size_t");

} else {

qRegisterMetaType<quint32>("size_t");

}

PythonQtConv::registerStringViewTypes();

int objectPtrListId = qRegisterMetaType<QList<PythonQtObjectPtr> >("QList<PythonQtObjectPtr>");

PythonQtConv::registerMetaTypeToPythonConverter(objectPtrListId, PythonQtConv::convertFromQListOfPythonQtObjectPtr);

PythonQtConv::registerPythonToMetaTypeConverter(objectPtrListId, PythonQtConv::convertToQListOfPythonQtObjectPtr);

PythonQtRegisterToolClassesTemplateConverter(int);

PythonQtRegisterToolClassesTemplateConverter(bool);

PythonQtRegisterToolClassesTemplateConverter(float);

PythonQtRegisterToolClassesTemplateConverter(double);

PythonQtRegisterToolClassesTemplateConverter(qint32);

PythonQtRegisterToolClassesTemplateConverter(quint32);

PythonQtRegisterToolClassesTemplateConverter(qint64);

PythonQtRegisterToolClassesTemplateConverter(quint64);

#ifdef PYTHONQT_SUPPORT_ML_TYPES

PythonQtMethodInfo::addParameterTypeAlias("QList<MLfloat>", "QList<float>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<MLfloat>", "QVector<float>");

PythonQtMethodInfo::addParameterTypeAlias("QList<MLdouble>", "QList<double>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<MLdouble>", "QVector<double>");

PythonQtMethodInfo::addParameterTypeAlias("QList<MLuint32>", "QList<quint32>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<MLuint32>", "QVector<quint32>");

PythonQtMethodInfo::addParameterTypeAlias("QList<MLint32>", "QList<qint32>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<MLint32>", "QVector<qint32>");

PythonQtMethodInfo::addParameterTypeAlias("QList<MLuint64>", "QList<quint64>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<MLuint64>", "QVector<quint64>");

PythonQtMethodInfo::addParameterTypeAlias("QList<MLint64>", "QList<qint64>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<MLint64>", "QVector<qint64>");

PythonQtMethodInfo::addParameterTypeAlias("QList<MLuint>", "QList<quint64>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<MLuint>", "QVector<quint64>");

PythonQtMethodInfo::addParameterTypeAlias("QList<MLint>", "QList<qint64>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<MLint>", "QVector<qint64>");

#endif

PythonQtMethodInfo::addParameterTypeAlias("QList<qreal>", "QList<double>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<qreal>", "QVector<double>");

PythonQtMethodInfo::addParameterTypeAlias("QList<unsigned int>", "QList<quint32>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<unsigned int>", "QVector<quint32>");

// Qt 4 uses uint, while Qt 5 uses unsigned int, seems to be a moc change...

PythonQtMethodInfo::addParameterTypeAlias("QList<uint>", "QList<quint32>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<uint>", "QVector<quint32>");

PythonQtMethodInfo::addParameterTypeAlias("QList<int>", "QList<qint32>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<int>", "QVector<qint32>");

PythonQtMethodInfo::addParameterTypeAlias("QList<GLint>", "QList<qint32>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<GLint>", "QVector<qint32>");

PythonQtMethodInfo::addParameterTypeAlias("QList<GLuint>", "QList<qint32>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<GLuint>", "QVector<quint32>");

PythonQtMethodInfo::addParameterTypeAlias("QList<GLuint64>", "QList<quint64>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<GLuint64>", "QVector<quint64>");

PythonQtMethodInfo::addParameterTypeAlias("QList<GLint64>", "QList<qint64>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<GLint64>", "QVector<qint64>");

PythonQtMethodInfo::addParameterTypeAlias("QList<QLocale::Country>", "QList<int>");

PythonQtMethodInfo::addParameterTypeAlias("QList<Qt::DayOfWeek>", "QList<int>");

// register some QPairs that are used in the Qt interfaces:

PythonQtRegisterQPairConverter(int, int);

PythonQtRegisterQPairConverter(float, float);

PythonQtRegisterQPairConverter(double, double);

PythonQtRegisterQPairConverter(QString, QString);

PythonQtRegisterQPairConverter(QByteArray, QByteArray);

PythonQtRegisterQPairConverter(double, QColor);

PythonQtRegisterQPairConverter(double, QPointF);

PythonQtRegisterQPairConverter(double, QVariant);

PythonQtRegisterQPairConverter(QString, QSizeF);

PythonQtMethodInfo::addParameterTypeAlias("QPair<qreal,qreal>", "QPair<double,double>");

PythonQtMethodInfo::addParameterTypeAlias("QPair<qreal,QColor>", "QPair<double,QColor>");

PythonQtMethodInfo::addParameterTypeAlias("QPair<qreal,QPointF>", "QPair<double,QPointF>");

PythonQtMethodInfo::addParameterTypeAlias("QPair<qreal,QVariant>", "QPair<double,QVariant>");

PythonQtMethodInfo::addParameterTypeAlias("QPair<QOpenGLTexture::Filter,QOpenGLTexture::Filter>", "QPair<int,int>");

// register some QList/QVector of QPairs that are used in the Qt interfaces:

PythonQtRegisterListTemplateQPairConverter(QVector, double, QVariant);

PythonQtRegisterListTemplateQPairConverter(QVector, double, QColor);

// NOTE: the extra space between the > is needed (and added by the moc)

PythonQtMethodInfo::addParameterTypeAlias("QVector<QPair<qreal,QVariant> >", "QVector<QPair<double,QVariant> >");

PythonQtMethodInfo::addParameterTypeAlias("QVector<QPair<qreal,QColor> >", "QVector<QPair<double,QColor> >");

PythonQtRegisterListTemplateQPairConverter(QList, QByteArray, QByteArray);

PythonQtRegisterListTemplateQPairConverter(QList, QString, QString);

PythonQtRegisterListTemplateQPairConverter(QList, QString, QSizeF);

PythonQtRegisterListTemplateQPairConverter(QList, double, QPointF);

PythonQtRegisterListTemplateQPairConverter(QList, double, double);

// NOTE: the extra space between the > is needed (and added by the moc)

PythonQtMethodInfo::addParameterTypeAlias("QList<QPair<qreal,QPointF> >", "QList<QPair<double,QPointF> >");

PythonQtMethodInfo::addParameterTypeAlias("QList<QPair<qreal,qreal> >", "QList<QPair<double,double> >");

PythonQtRegisterIntegerMapConverter(QMap, QByteArray);

PythonQtRegisterIntegerMapConverter(QMap, QVariant);

PythonQtRegisterIntegerMapConverter(QMap, QString);

PythonQtRegisterIntegerMapConverter(QHash, QByteArray);

PythonQtRegisterIntegerMapConverter(QHash, QVariant);

PythonQtRegisterIntegerMapConverter(QHash, QString);

PythonQtMethodInfo::addParameterTypeAlias("QHash<QNetworkRequest::Attribute,QVariant>", "QHash<int,QVariant>");

PythonQt_init_QtCoreBuiltin(nullptr);

PythonQt_init_QtGuiBuiltin(nullptr);

PythonQt::self()->addDecorators(new PythonQtStdDecorators());

PythonQt::self()->registerCPPClass("QMetaObject",nullptr, "QtCore", PythonQtCreateObject<PythonQtWrapper_QMetaObject>);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QByteArray);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QDate);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QTime);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QDateTime);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QUrl);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QLocale);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QRect);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QRectF);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QSize);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QSizeF);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QLine);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QLineF);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QPoint);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QPointF);

#if QT_VERSION < 0x060000

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QRegExp);

#endif

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QRegularExpression);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QFont);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QPixmap);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QBrush);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QColor);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QPalette);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QIcon);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QImage);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QPolygon);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QRegion);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QBitmap);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QCursor);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QSizePolicy);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QKeySequence);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QPen);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QTextLength);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QTextFormat);

PyObject* pack = PythonQt::priv()->packageByName("QtCore");

PyObject* pack2 = PythonQt::priv()->packageByName("Qt");

PyObject* qtNamespace = PythonQt::priv()->getClassInfo("Qt")->pythonQtClassWrapper();

const char* names[16] = {"SIGNAL", "SLOT", "qAbs", "qBound","qDebug","qWarning","qCritical","qFatal"

,"qFuzzyCompare", "qMax","qMin","qRound","qRound64","qVersion","qrand","qsrand"};

for (unsigned int i = 0; i < sizeof(names) / sizeof(names[0]); i++) {

PyObject* obj = PyObject_GetAttrString(qtNamespace, names[i]);

if (obj) {

if (PyModule_AddObject(pack, names[i], obj) < 0) {

std::cerr << "failed to add " << names[i] << " to QtCore\n";

} else {

Py_INCREF(obj);

}

if(PyModule_AddObject(pack2, names[i], obj) < 0) {

Py_DECREF(obj);

std::cerr << "failed to add " << names[i] << " to Qt\n";

}

} else {

std::cerr << "method not found " << names[i] << std::endl;

}

}

int enumValues[] = {

QtDebugMsg,

QtWarningMsg,

QtCriticalMsg,

QtFatalMsg,

QtSystemMsg

};

const char* enumNames[] = {

"QtDebugMsg",

"QtWarningMsg",

"QtCriticalMsg",

"QtFatalMsg",

"QtSystemMsg"

};

for (auto i = 0u; i < sizeof(enumValues)/sizeof(int); i++) {

PyObject* obj = PyInt_FromLong(enumValues[i]);

if (PyModule_AddObject(pack, enumNames[i], obj) == 0) {

Py_INCREF(obj);

}

if (PyModule_AddObject(pack2, enumNames[i], obj) < 0) {

Py_DECREF(obj);

}

}

_self->priv()->pythonQtModule().addObject("Debug", _self->priv()->_debugAPI);

_self->priv()->pythonQtModule().addObject("Config", _self->priv()->_configAPI);

Py_INCREF((PyObject*)&PythonQtSlotDecorator_Type);

Py_INCREF((PyObject*)&PythonQtSignalFunction_Type);

Py_INCREF((PyObject*)&PythonQtProperty_Type);

PyModule_AddObject(pack, "Slot", (PyObject*)&PythonQtSlotDecorator_Type);

PyModule_AddObject(pack, "Signal", (PyObject*)&PythonQtSignalFunction_Type);

PyModule_AddObject(pack, "Property", (PyObject*)&PythonQtProperty_Type);

}

}

void PythonQt::cleanup()

{

if (_self) {

delete _self;

_self = nullptr;

}

}

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

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

{

_p = new PythonQtPrivate;

_p->_initFlags = flags;

if ((flags & PythonAlreadyInitialized) == 0) {

#ifdef PY3K

Py_SetProgramName(const_cast<wchar_t*>(L"PythonQt"));

#else

Py_SetProgramName(const_cast<char*>("PythonQt"));

#endif

if (flags & IgnoreSiteModule) {

// this prevents the automatic importing of Python site files

Py_NoSiteFlag = 1;

}

Py_Initialize();

}

#ifdef PYTHONQT_FULL_THREAD_SUPPORT

if (!PyEval_ThreadsInitialized()) {

PyEval_InitThreads();

}

#endif

// add our own python object types for qt object slots

if (PyType_Ready(&PythonQtSlotFunction_Type) < 0) {

std::cerr << "could not initialize PythonQtSlotFunction_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;

}

Py_INCREF(&PythonQtSlotFunction_Type);

if (PyType_Ready(&PythonQtSignalFunction_Type) < 0) {

std::cerr << "could not initialize PythonQtSignalFunction_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;

}

Py_INCREF(&PythonQtSignalFunction_Type);

if (PyType_Ready(&PythonQtSlotDecorator_Type) < 0) {

std::cerr << "could not initialize PythonQtSlotDecorator_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;

}

Py_INCREF(&PythonQtSlotDecorator_Type);

if (PyType_Ready(&PythonQtProperty_Type) < 0) {

std::cerr << "could not initialize PythonQtProperty_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;

}

Py_INCREF(&PythonQtProperty_Type);

PythonQtBoolResult_Type.tp_new = PyType_GenericNew;

if (PyType_Ready(&PythonQtBoolResult_Type) < 0) {

std::cerr << "could not initialize PythonQtBoolResult_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;

}

Py_INCREF(&PythonQtBoolResult_Type);

// according to Python docs, set the type late here, since it can not safely be stored in the struct when declaring it

PythonQtClassWrapper_Type.tp_base = &PyType_Type;

// add our own python object types for classes

if (PyType_Ready(&PythonQtClassWrapper_Type) < 0) {

std::cerr << "could not initialize PythonQtClassWrapper_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;

}

Py_INCREF(&PythonQtClassWrapper_Type);

// add our own python object types for CPP instances

if (PyType_Ready(&PythonQtInstanceWrapper_Type) < 0) {

PythonQt::handleError();

std::cerr << "could not initialize PythonQtInstanceWrapper_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;

}

Py_INCREF(&PythonQtInstanceWrapper_Type);

// add our own python object types for redirection of stdout

if (PyType_Ready(&PythonQtStdOutRedirectType) < 0) {

std::cerr << "could not initialize PythonQtStdOutRedirectType" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;

}

Py_INCREF(&PythonQtStdOutRedirectType);

// add our own python object types for redirection of stdin

if (PyType_Ready(&PythonQtStdInRedirectType) < 0) {

std::cerr << "could not initialize PythonQtStdInRedirectType" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;

}

Py_INCREF(&PythonQtStdInRedirectType);

initPythonQtModule(flags & RedirectStdOut, 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 result;

#ifdef PY3K

if (!PyCoro_CheckExact(object))

{

return result;

}

if (!_pyEnsureFuture)

{

std::cerr << "PythonQt: ensure_future not initialized" << std::endl;

return PythonQtObjectPtr();

}

PyObject* args = PyTuple_New(1);

PyObject* coro = object.object();

Py_INCREF(coro);

PyTuple_SetItem(args, 0, coro);

PyObject* r = PyObject_CallObject(_pyEnsureFuture, args);

result.setNewRef(r);

if (_pyTaskDoneCallback) {

PyObject* methodName = PyUnicode_FromString("add_done_callback");

PyObject_CallMethodObjArgs(r, methodName, _pyTaskDoneCallback.object(), nullptr);

Py_XDECREF(methodName);

}

Py_XDECREF(args);

#else

Q_UNUSED(object)

#endif

return result;

}

PythonQtObjectPtr PythonQtPrivate::createAsyncioFuture()

{

if (!_pyFutureClass)

{

std::cerr << "PythonQt: _pyFutureClass not initialized" << std::endl;

return nullptr;

}

return _pyFutureClass.call();

}

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

{

if (!callback) {

std::cerr << "PythonQt::setRedirectStdInCallback - callback parameter is NULL !" << std::endl;

return;

}

PythonQtObjectPtr sys;

PythonQtObjectPtr in;

sys.setNewRef(PyImport_ImportModule("sys"));

// Backup original 'sys.stdin' if not yet done

if( !PyObject_HasAttrString(sys.object(), "pythonqt_original_stdin") ) {

PyObject_SetAttrString(sys.object(), "pythonqt_original_stdin", PyObject_GetAttrString(sys.object(), "stdin"));

}

in = PythonQtStdInRedirectType.tp_new(&PythonQtStdInRedirectType, nullptr, nullptr);

((PythonQtStdInRedirect*)in.object())->_cb = callback;

((PythonQtStdInRedirect*)in.object())->_callData = callbackData;

// replace the built in file objects with our own objects

PyModule_AddObject(sys.object(), "stdin", in);

// Backup custom 'stdin' into 'pythonqt_stdin'

Py_INCREF(in); // AddObject steals the reference, so increment it

PyModule_AddObject(sys.object(), "pythonqt_stdin", in);

}

void PythonQt::setRedirectStdInCallbackEnabled(bool enabled)

{

PythonQtObjectPtr sys;

sys.setNewRef(PyImport_ImportModule("sys"));

if (enabled) {

if( !PyObject_HasAttrString(sys.object(), "pythonqt_stdin") ) {

PyObject_SetAttrString(sys.object(), "stdin", PyObject_GetAttrString(sys.object(), "pythonqt_stdin"));

}

} else {

if( !PyObject_HasAttrString(sys.object(), "pythonqt_original_stdin") ) {

PyObject_SetAttrString(sys.object(), "stdin", PyObject_GetAttrString(sys.object(), "pythonqt_original_stdin"));

}

}

}

PythonQtImportFileInterface* PythonQt::importInterface()

{

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

}

void PythonQt::qObjectNoLongerWrappedCB(QObject* o)

{

if (_self->_p->_noLongerWrappedCB) {

(*_self->_p->_noLongerWrappedCB)(o);

}

}

void PythonQt::setQObjectMissingAttributeCallback(PythonQtQObjectMissingAttributeCB* cb)

{

_self->_p->_qObjectMissingAttribCB = cb;

}

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

{

if (_self && _self->_p && _self->_p->_qObjectMissingAttribCB) {

return _self->_p->_qObjectMissingAttribCB(o, attribute);

} else {

return QString();

}

}

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)

{

// we register all classes in the hierarchy

const QMetaObject* m = metaobject;

bool first = true;

while (m) {

PythonQtClassInfo* info = lookupClassInfoAndCreateIfNotPresent(m->className());

if (!info->pythonQtClassWrapper()) {

info->setTypeSlots(typeSlots);

info->setupQObject(m);

createPythonQtClassWrapper(info, package, module);

if (m->superClass()) {

PythonQtClassInfo* parentInfo = lookupClassInfoAndCreateIfNotPresent(m->superClass()->className());

info->addParentClass(PythonQtClassInfo::ParentClassInfo(parentInfo));

}

} else if (first && module) {

// There is a wrapper already, but if we got a module, we want to place the wrapper into that module as well,

// since it might have been placed into "private" earlier on.

// If the wrapper was already added to module before, it is just readded, which does no harm.

PyObject* classWrapper = info->pythonQtClassWrapper();

// AddObject steals a reference, so we need to INCREF

Py_INCREF(classWrapper);

if (PyModule_AddObject(module, info->className(), classWrapper) < 0) {

Py_DECREF(classWrapper);

}

}

if (first) {

first = false;

if (wrapperCreator) {

info->setDecoratorProvider(wrapperCreator);

}

if (shell) {

info->setShellSetInstanceWrapperCB(shell);

}

}

m = m->superClass();

}

}

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

{

QByteArray pythonClassName = info->className();

int nestedClassIndex = pythonClassName.indexOf("::");

bool isNested = false;

if (nestedClassIndex>0) {

pythonClassName = pythonClassName.mid(nestedClassIndex + 2);

isNested = true;

}

PyObject* pack = module?module:packageByName(package);

PyObject* pyobj = (PyObject*)createNewPythonQtClassWrapper(info, pack, pythonClassName);

if (isNested) {

QByteArray outerClass = QByteArray(info->className()).mid(0, nestedClassIndex);

PythonQtClassInfo* outerClassInfo = lookupClassInfoAndCreateIfNotPresent(outerClass);

outerClassInfo->addNestedClass(info);

} else {

if (PyModule_AddObject(pack, info->className(), pyobj) == 0) {

// since PyModule_AddObject steals the reference, we need a incref once more...

Py_INCREF(pyobj);

}

}

if (!module && package && strncmp(package, "Qt", 2) == 0) {

// put all qt objects into Qt as well

if (PyModule_AddObject(packageByName("Qt"), info->className(), pyobj) == 0) {

// since PyModule_AddObject steals the reference, we need a incref once more...

Py_INCREF(pyobj);

}

}

info->setPythonQtClassWrapper(pyobj);

}

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 flag = false;

PythonQtObjectPtr callable = lookupCallable(module, objectname);

if (callable) {

PythonQtSignalReceiver* r = getSignalReceiver(obj);

flag = r->addSignalHandler(signal, callable);

if (!flag) {

// signal not found

}

} else {

// callable not found

}

return flag;

}

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

{

bool flag = false;

PythonQtSignalReceiver* r = getSignalReceiver(obj);

if (r) {

flag = r->addSignalHandler(signal, receiver);

}

return flag;

}

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

{

bool flag = false;

PythonQtObjectPtr callable = lookupCallable(module, objectname);

if (callable) {

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

if (r) {

flag = r->removeSignalHandler(signal, callable);

}

} else {

// callable not found

}

return flag;

}

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

{

bool flag = false;

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

if (r) {

flag = r->removeSignalHandler(signal, receiver);

}

return flag;

}

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

{

PythonQtObjectPtr p = lookupObject(module, name);

if (p) {

if (PyCallable_Check(p)) {

return p;

}

}

PyErr_Clear();

return nullptr;

}

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

{

QStringList l = name.split('.');

PythonQtObjectPtr p = module;

PythonQtObjectPtr prev;

QByteArray b;

for (QStringList::ConstIterator i = l.begin(); i!=l.end() && p; ++i) {

prev = p;

b = QStringToPythonEncoding(*i);

if (PyDict_Check(p)) {

p = PyDict_GetItemString(p, b.data());

} else {

p.setNewRef(PyObject_GetAttrString(p, b.data()));

}

}

PyErr_Clear();

return p;

}

PythonQtObjectPtr PythonQt::getMainModule() {

//both borrowed

PythonQtObjectPtr dict = PyImport_GetModuleDict();

return PyDict_GetItemString(dict, "__main__");

}

PythonQtObjectPtr PythonQt::importModule(const QString& name)

{

PythonQtObjectPtr mod;

mod.setNewRef(PyImport_ImportModule(QStringToPythonCharPointer(name)));

return mod;

}

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

QVariant result;

clearError();

if (pycode) {

PyObject* dict = nullptr;

PyObject* globals = nullptr;

if (PyModule_Check(object)) {

dict = PyModule_GetDict(object);

globals = dict;

} else if (PyDict_Check(object)) {

dict = object;

globals = dict;

} else {

dict = PyObject_GetAttrString(object, "__dict__");

globals = PyObject_GetAttrString(PyImport_ImportModule(PyString_AS_STRING(PyObject_GetAttrString(object, "__module__"))),"__dict__");

}

PyObject* r = nullptr;

if (dict) {

#ifdef PY3K

r = PyEval_EvalCode(pycode, globals, dict);

#else

r = PyEval_EvalCode((PyCodeObject*)pycode, globals, dict);