GIT_REPOSITORIES/LPP/PythonQt Commit - r84:8f25be796564

fixed initialization order, the importer needs to be store BEFORE the import module is initialized...

florianlink -

r84:8f25be796564

parent child

Context file:

r84:8f25be796564

Collapse all files

src/PythonQt.cpp +31 -31

                PythonQtMethodInfo::addParameterTypeAlias("QObjectList", "QList<QObject*>");
                qRegisterMetaType<QList<QObject*> >("QList<void*>");
                PythonQtRegisterToolClassesTemplateConverter(int);
                PythonQtRegisterToolClassesTemplateConverter(float);
                PythonQtRegisterToolClassesTemplateConverter(double);
                PythonQtRegisterToolClassesTemplateConverter(QPoint);
                PythonQtRegisterToolClassesTemplateConverter(QPointF);
                PythonQtRegisterToolClassesTemplateConverter(QRegExp);
                PythonQt::self()->registerCPPClass("QFont", "", "QtGui", PythonQtCreateObject<PythonQtWrapper_QFont>);
                PythonQt::self()->registerCPPClass("QPixmap", "", "QtGui", PythonQtCreateObject<PythonQtWrapper_QPixmap>);
                PythonQt::self()->registerCPPClass("QBrush", "", "QtGui", PythonQtCreateObject<PythonQtWrapper_QBrush>);
                PythonQtRegisterToolClassesTemplateConverter(QTextFormat);
                PythonQtRegisterToolClassesTemplateConverter(QMatrix);
                PyObject* pack = PythonQt::priv()->packageByName("QtCore");
                PyObject* pack2 = PythonQt::priv()->packageByName("Qt");
                PyObject* qtNamespace = PythonQt::priv()->getClassInfo("Qt")->pythonQtClassWrapper();
                _p->_initFlags = flags;
                _p->_PythonQtObjectPtr_metaId = qRegisterMetaType<PythonQtObjectPtr>("PythonQtObjectPtr");
                Py_SetProgramName("PythonQt");
                if (flags & IgnoreSiteModule) {
                  // this prevents the automatic importing of Python site files
                  Py_NoSiteFlag = 1;
                }
                Py_Initialize();
                // 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);
                // 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
                  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);
                initPythonQtModule(flags & RedirectStdOut);
                _p->setupSharedLibrarySuffixes();
                result->_wrappedPtr = wrappedPtr;
                result->_ownedByPythonQt = false;
                result->_useQMetaTypeDestroy = false;
                if (wrappedPtr) {
                  _wrappedObjects.insert(wrappedPtr, result);
                } else {
                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) {
              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(typeDict);
                Py_DECREF(args);
                Py_DECREF(className);
                return result;
              }
              QStringList PythonQt::introspection(PyObject* module, const QString& objectname, PythonQt::ObjectType type)
              {
                QStringList results;
                PythonQtObjectPtr object;
                if (objectname.isEmpty()) {
                  object = module;
                    if (PythonQtSlotFunction_Check(object)) {
                      PythonQtSlotFunctionObject* o = (PythonQtSlotFunctionObject*)object.object();
                      PythonQtSlotInfo* info = o->m_ml;
                      while (info) {
                        results << info->fullSignature();
                        info = info->nextInfo();
                    } else if (object->ob_type == &PythonQtClassWrapper_Type) {
                      PythonQtClassWrapper* o = (PythonQtClassWrapper*)object.object();
                      PythonQtSlotInfo* info = o->classInfo()->constructors();
                      while (info) {
                        results << info->fullSignature();
                        info = info->nextInfo();
                      break;
                    }
                  }
                  if (!err) {
                    PyErr_Clear();
                    result = PyObject_CallObject(callable, pargs);
              void PythonQt::setImporter(PythonQtImportFileInterface* importInterface)
              {
-               PythonQtImport::init();
                _p->_importInterface = importInterface;
+               PythonQtImport::init();
              }
              void PythonQt::setImporterIgnorePaths(const QStringList& paths)
                  if ((m.methodType() == QMetaMethod::Method ||
                    m.methodType() == QMetaMethod::Slot) && m.access() == QMetaMethod::Public) {
                    if (qstrncmp(m.signature(), "new_", 4)==0) {
-                     if ((decoTypes & ConstructorDecorator) == 0) continue;
+                     if ((decoTypes & ConstructorDecorator) == 0) continue;
                      const PythonQtMethodInfo* info = PythonQtMethodInfo::getCachedMethodInfo(m, NULL);
                      if (info->parameters().at(0).isPointer) {
                        QByteArray signature = m.signature();
                        classInfo->addConstructor(newSlot);
                      }
                    } else if (qstrncmp(m.signature(), "delete_", 7)==0) {
-                     if ((decoTypes & DestructorDecorator) == 0) continue;
+                     if ((decoTypes & DestructorDecorator) == 0) continue;
                      QByteArray signature = m.signature();
                      QByteArray nameOfClass = signature.mid(7, signature.indexOf('(')-7);
                      PythonQtClassInfo* classInfo = lookupClassInfoAndCreateIfNotPresent(nameOfClass);
                      PythonQtSlotInfo* newSlot = new PythonQtSlotInfo(NULL, m, i, o, PythonQtSlotInfo::ClassDecorator);
                      classInfo->setDestructor(newSlot);
                    } else if (qstrncmp(m.signature(), "static_", 7)==0) {
-                     if ((decoTypes & StaticDecorator) == 0) continue;
+                     if ((decoTypes & StaticDecorator) == 0) continue;
                      QByteArray signature = m.signature();
                      QByteArray nameOfClass = signature.mid(signature.indexOf('_')+1);
                      nameOfClass = nameOfClass.mid(0, nameOfClass.indexOf('_'));
                      PythonQtSlotInfo* newSlot = new PythonQtSlotInfo(NULL, m, i, o, PythonQtSlotInfo::ClassDecorator);
                      classInfo->addDecoratorSlot(newSlot);
                    } else {
-                     if ((decoTypes & InstanceDecorator) == 0) continue;
+                     if ((decoTypes & InstanceDecorator) == 0) continue;
                      const PythonQtMethodInfo* info = PythonQtMethodInfo::getCachedMethodInfo(m, NULL);
                      if (info->parameters().count()>1) {
                        PythonQtMethodInfo::ParameterInfo p = info->parameters().at(1);
              {
                bool flag = false;
                if (PyErr_Occurred()) {
                  // currently we just print the error and the stderr handler parses the errors
                  PyErr_Print();
                  /*
                  // EXTRA: the format of the ptype and ptraceback is not really documented, so I use PyErr_Print() above
                  PyObject *ptype;
                  PyObject *pvalue;
                  PyObject *ptraceback;
                  PyErr_Fetch( &ptype, &pvalue, &ptraceback);
                    Py_XDECREF(ptype);
                    Py_XDECREF(pvalue);
                    Py_XDECREF(ptraceback);
                PythonQtObjectPtr sys;
                sys.setNewRef(PyImport_ImportModule("sys"));
                PythonQtObjectPtr obj = lookupObject(sys, "path");
-               PyList_Insert(obj, 0, PythonQtConv::QStringToPyObject(path));
+               PyList_Insert(obj, 0, PythonQtConv::QStringToPyObject(path));
              }
              void PythonQt::overwriteSysPath(const QStringList& paths)
              void PythonQt::initPythonQtModule(bool redirectStdOut)
              {
                _p->_pythonQtModule = Py_InitModule("PythonQt", PythonQtMethods);
                if (redirectStdOut) {
                  PythonQtObjectPtr sys;
                  PythonQtObjectPtr out;
              }
              PyObject* PythonQt::helpCalled(PythonQtClassInfo* info)
+             {
+             {
                if (_p->_initFlags & ExternalHelp) {
                  emit pythonHelpRequest(QByteArray(info->className()));
                  return Py_BuildValue("");

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages