GIT_REPOSITORIES/LPP/PythonQt Commit - r157:78da86ccde11

updated to upstream state in MeVisLab repository...

florianlink -

r157:78da86ccde11

parent child

Context file:

r157:78da86ccde11

Collapse all files

src/PythonQt.cpp +31 -3

                 PythonQt_init_QtCoreBuiltin(NULL);
                 PythonQt_init_QtGuiBuiltin(NULL);
                 PythonQtRegisterToolClassesTemplateConverter(QByteArray);
                 PythonQtRegisterToolClassesTemplateConverter(QDate);
                 PythonQtRegisterToolClassesTemplateConverter(QTime);
                 }
                 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;
                     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);
+                  PyModule_AddObject(module, info->className(), classWrapper);
                 }
                 if (first) {
                   first = false;
               _noLongerWrappedCB = NULL;
               _wrappedCB = NULL;
               _currentClassInfoForClassWrapperCreation = NULL;
+              _profilingCB = NULL;
             }
             void PythonQtPrivate::setupSharedLibrarySuffixes()
               imp.setNewRef(PyImport_ImportModule("imp"));
               int cExtensionCode = imp.getVariable("C_EXTENSION").toInt();
               QVariant result = imp.call("get_suffixes");
+            #ifdef __linux
+              #ifdef _DEBUG
+              // First look for shared libraries with the '_d' suffix in debug mode on Linux.
+              // This is a workaround, because python does not append the '_d' suffix on Linux
+              // and would always load the release library otherwise.
+              _sharedLibrarySuffixes << "_d.so";
+              #endif
+            #endif
               foreach (QVariant entry, result.toList()) {
                 QVariantList suffixEntry = entry.toList();
                 if (suffixEntry.count()==3) {
               _p->_noLongerWrappedCB = cb;
             }
+            void PythonQt::setProfilingCallback(ProfilingCB* cb)
+            {
+              _p->_profilingCB = cb;
+            }
             static PyMethodDef PythonQtMethods[] = {
               }
               _p->_pythonQtModule = Py_InitModule(name.constData(), PythonQtMethods);
               _p->_pythonQtModuleName = name;
               if (redirectStdOut) {
                 PythonQtObjectPtr sys;
                 PythonQtObjectPtr out;
               }
             }
+            void PythonQt::clearNotFoundCachedMembers()
+            {
+              foreach(PythonQtClassInfo* info, _p->_knownClassInfos) {
+                info->clearNotFoundCachedMembers();
+              }
+            }
             void PythonQtPrivate::removeWrapperPointer(void* obj)
             {
               _wrappedObjects.remove(obj);

src/PythonQt.h +43 -21

             //! returns the offset that needs to be added to upcast an object of type T1 to T2
             template<class T1, class T2> int PythonQtUpcastingOffset() {
               return (((char*)(static_cast<T2*>(reinterpret_cast<T1*>(0x100)))) - ((char*)reinterpret_cast<T1*>(0x100)));
             }
             //! callback to create a QObject lazily
               };
+              //! enum for profiling callback
+              enum ProfilingCallbackState {
+                Enter = 1,
+                Leave = 2
+              };
+              //! callback for profiling. className and methodName are only passed when state == Enter, otherwise
+              //! they are NULL.
+              typedef void ProfilingCB(ProfilingCallbackState state, const char* className, const char* methodName);
               //---------------------------------------------------------------------------
               //! \name Singleton Initialization
               //@{
               //! initialize the python qt binding (flags are a or combination of PythonQt::InitFlags), if \c pythonQtModuleName is given
               //! it defines the name of the python module that PythonQt will add, otherwise "PythonQt" is used.
               //! This can be used to e.g. pass in PySide or PyQt4 to make it more compatible.
               static PythonQt* self() { return _self; }
               //@}
               //! defines the object types for introspection
               enum ObjectType {
                 Class,
               //! to a module later on.
               //! The user needs to make sure that the \c name is unique in the python module dictionary.
               PythonQtObjectPtr createModuleFromFile(const QString& name, const QString& filename);
               //! creates the new module \c name and evaluates the given script in the context of that module.
               //! If the \c script is empty, the module contains no initial code. You can use evalScript/evalCode to add code
               //! to a module later on.
               //! The user needs to make sure that the \c name is unique in the python module dictionary.
               PythonQtObjectPtr createModuleFromScript(const QString& name, const QString& script = QString());
               //! create a uniquely named module, you can use evalFile or evalScript to populate the module with
               //! script code
               PythonQtObjectPtr createUniqueModule();
               void setModuleImportPath(PyObject* module, const QStringList& paths);
               //@}
               //---------------------------------------------------------------------------
               //! \name Registering Classes
               //@{
               //! registers a QObject derived class to PythonQt (this is implicitly called by addObject as well)
               /* Since Qt4 does not offer a way to detect if a given classname is derived from QObject and thus has a QMetaObject,
                you MUST register all your QObject derived classes here when you want them to be detected in signal and slot calls */
               void registerClass(const QMetaObject* metaobject, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL);
               //! add a wrapper object for the given QMetaType typeName, also does an addClassDecorators() to add constructors for variants
               //! (ownership of wrapper is passed to PythonQt)
               /*! Make sure that you have done a qRegisterMetaType first, if typeName is a user type!
                This will add a wrapper object that is used to make calls to the given classname \c typeName.
                All slots that take a pointer to typeName as the first argument will be callable from Python on
                a variant object that contains such a type.
               //---------------------------------------------------------------------------
               //! \name Script Parsing and Evaluation
               //@{
               //! parses the given file and returns the python code object, this can then be used to call evalCode()
               PythonQtObjectPtr parseFile(const QString& filename);
               //---------------------------------------------------------------------------
               //! \name Variable access
               //@{
               //! add the given \c qObject to the python \c object as a variable with \c name (it can be removed via clearVariable)
               void addObject(PyObject* object, const QString& name, QObject* qObject);
               //---------------------------------------------------------------------------
               //! \name Calling Python Objects
               //@{
               //! call the given python \c callable in the scope of object, returns the result converted to a QVariant
               QVariant call(PyObject* object, const QString& callable, const QVariantList& args = QVariantList());
               //---------------------------------------------------------------------------
               //! \name Custom Importer
               //@{
               //! replace the internal import implementation and use the supplied interface to load files (both py and pyc files)
               //! (this method should be called directly after initialization of init() and before calling overwriteSysPath().
               //! On the first call to this method, it will install a generic PythonQt importer in Pythons "path_hooks".
               //! This is not reversible, so even setting setImporter(NULL) afterwards will
               //! keep the custom PythonQt importer with a QFile default import interface.
               //! Subsequent python import calls will make use of the passed importInterface
               //! The error is currently just output to the python stderr, future version might implement better trace printing
               bool handleError();
+              //! clear all NotFound entries on all class infos, to ensure that
+              //! newly loaded wrappers can add methods even when the object was wrapped by PythonQt before the wrapper was loaded
+              void clearNotFoundCachedMembers();
               //! set a callback that is called when a QObject with parent == NULL is wrapped by pythonqt
               void setQObjectWrappedCallback(PythonQtQObjectWrappedCB* cb);
               //! set a callback that is called when a QObject with parent == NULL is no longer wrapped by pythonqt
               //! called by internal help methods
               PyObject* helpCalled(PythonQtClassInfo* info);
               //! returns the found object or NULL
               //! @return new reference
               PythonQtObjectPtr lookupObject(PyObject* module, const QString& name);
+              //! sets a callback that is called before and after function calls for profiling
+              void setProfilingCallback(ProfilingCB* cb);
               //@}
             signals:
               //! add a handler for polymorphic downcasting
               void addPolymorphicHandler(const char* typeName, PythonQtPolymorphicHandlerCB* cb);
               //! lookup existing classinfo and return new if not yet present
               PythonQtClassInfo* lookupClassInfoAndCreateIfNotPresent(const char* typeName);
               //! add a wrapper object for the given QMetaType typeName, also does an addClassDecorators() to add constructors for variants
               //! (ownership of wrapper is passed to PythonQt)
               /*! Make sure that you have done a qRegisterMetaType first, if typeName is a user type!
                This will add a wrapper object that is used to make calls to the given classname \c typeName.
                All slots that take a pointer to typeName as the first argument will be callable from Python on
                a variant object that contains such a type.
                */
               void registerCPPClass(const char* typeName, const char* parentTypeName = NULL, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL, PyObject* module = NULL, int typeSlots = 0);
               //! as an alternative to registerClass, you can tell PythonQt the names of QObject derived classes
               //! and it will register the classes when it first sees a pointer to such a derived class
               void registerQObjectClassNames(const QStringList& names);
               //! called by virtual overloads when a python return value can not be converted to the required Qt type
               void handleVirtualOverloadReturnError(const char* signature, const PythonQtMethodInfo* methodInfo, PyObject* result);
               //! get access to the PythonQt module
               PythonQtObjectPtr pythonQtModule() const { return _pythonQtModule; }
+              //! returns the profiling callback, which may be NULL
+              PythonQt::ProfilingCB* profilingCB() const { return _profilingCB; }
             private:
               //! Setup the shared library suffixes by getting them from the "imp" module.
               void setupSharedLibrarySuffixes();
               //! the name of the PythonQt python module
               QByteArray _pythonQtModuleName;
               //! the importer interface (if set)
               PythonQtImportFileInterface* _importInterface;
               //! the default importer
               PythonQtQFileImporter* _defaultImporter;
               PythonQtQObjectNoLongerWrappedCB* _noLongerWrappedCB;
               PythonQtQObjectWrappedCB* _wrappedCB;
               PythonQtClassInfo* _currentClassInfoForClassWrapperCreation;
+              PythonQt::ProfilingCB* _profilingCB;
               int _initFlags;
               int _PythonQtObjectPtr_metaId;

src/PythonQtClassInfo.cpp +19 0

@@ -847,3 +847,22 PyObject* PythonQtClassInfo::findEnumWrapper(const char* name) {
847	return NULL;	847	return NULL;
848	}	848	}
849		849
		850	void PythonQtClassInfo::setDecoratorProvider( PythonQtQObjectCreatorFunctionCB* cb )
		851	{
		852	_decoratorProviderCB = cb;
		853	_decoratorProvider = NULL;
		854	_enumsCreated = false;
		855	}
		856
		857	void PythonQtClassInfo::clearNotFoundCachedMembers()
		858	{
		859	// remove all not found entries, since a new decorator means new slots,
		860	// which might have been cached as "NotFound" already.
		861	QMutableHashIterator<QByteArray, PythonQtMemberInfo> it(_cachedMembers);
		862	while (it.hasNext()) {
		863	it.next();
		864	if (it.value()._type == PythonQtMemberInfo::NotFound) {
		865	it.remove();
		866	}
		867	}
		868	}

src/PythonQtClassInfo.h +6 -3

               int metaTypeId() { return _metaTypeId; }
               //! set an additional decorator provider that offers additional decorator slots for this class
-              void setDecoratorProvider(PythonQtQObjectCreatorFunctionCB* cb) { _decoratorProviderCB = cb; _decoratorProvider = NULL; }
+              void setDecoratorProvider(PythonQtQObjectCreatorFunctionCB* cb);
               //! get the decorator qobject instance
               QObject* decorator();
               //! returns if the localScope has an enum of that type name or if the enum contains a :: scope, if that class contails the enum
               static PyObject* findEnumWrapper(const QByteArray& name, PythonQtClassInfo* localScope, bool* isLocalEnum = NULL);
+              //! clear all members that where cached as "NotFound"
+              void clearNotFoundCachedMembers();
             private:
               void createEnumWrappers();
               void createEnumWrappers(const QMetaObject* meta);
               PythonQtSlotInfo* findDecoratorSlots(const char* memberName, int memberNameLen, PythonQtSlotInfo* tail, bool &found, QHash<QByteArray, PythonQtMemberInfo>& memberCache, int upcastingOffset);
               int findCharOffset(const char* sigStart, char someChar);
               QHash<QByteArray, PythonQtMemberInfo> _cachedMembers;
               PythonQtSlotInfo*                    _constructors;

src/PythonQtClassWrapper.cpp +37 -5

               return PythonQt::self()->helpCalled(type->classInfo());
             }
+            PyObject *PythonQtClassWrapper_delete(PythonQtClassWrapper *type, PyObject *args)
+            {
+              Q_UNUSED(type);
+              Py_ssize_t argc = PyTuple_Size(args);
+              if (argc>0) {
+                PyObject* self = PyTuple_GET_ITEM(args, 0);
+                if (PyObject_TypeCheck(self, &PythonQtInstanceWrapper_Type)) {
+                  return PythonQtInstanceWrapper_delete((PythonQtInstanceWrapper*)self);
+                }
+              }
+              return NULL;
+            }
+            PyObject *PythonQtClassWrapper_inherits(PythonQtClassWrapper *type, PyObject *args)
+            {
+              Q_UNUSED(type);
+              PythonQtInstanceWrapper* wrapper = NULL;
+              char *name = NULL;
+              if (!PyArg_ParseTuple(args, "O!s:PythonQtClassWrapper.inherits",&PythonQtInstanceWrapper_Type, &wrapper, &name)) {
+                return NULL;
+              }
+              return PythonQtConv::GetPyBool(wrapper->classInfo()->inherits(name));
+            }
             PyObject *PythonQtClassWrapper__init__(PythonQtClassWrapper *type, PyObject *args)
             {
               Py_ssize_t argc = PyTuple_Size(args);
               return NULL;
             }
             static PyMethodDef PythonQtClassWrapper_methods[] = {
                 {"__init__", (PyCFunction)PythonQtClassWrapper__init__, METH_VARARGS,
-                "Return the classname of the object"
+                "Init function"
                 },
                 {"className", (PyCFunction)PythonQtClassWrapper_classname, METH_NOARGS,
                  "Return the classname of the object"
                 },
+                {"inherits", (PyCFunction)PythonQtClassWrapper_inherits, METH_VARARGS,
+                "Returns if the class inherits or is of given type name"
+                },
                 {"help", (PyCFunction)PythonQtClassWrapper_help, METH_NOARGS,
                 "Shows the help of available methods for this class"
                 },
+                {"delete", (PyCFunction)PythonQtClassWrapper_delete, METH_VARARGS,
+                "Deletes the given C++ object"
+                },
                 {NULL, NULL, 0 , NULL}  /* Sentinel */
             };
             {
               const char *attributeName;
               PythonQtClassWrapper *wrapper = (PythonQtClassWrapper *)obj;
               if ((attributeName = PyString_AsString(name)) == NULL) {
                 return NULL;
               }
                   return dict;
                 }
                 dict = PyDict_Copy(dict);
                 QStringList l = wrapper->classInfo()->memberList(false);
                 foreach (QString name, l) {
                   PyObject* o = PyObject_GetAttrString(obj, name.toLatin1().data());
                   PyDict_SetItemString(dict, "__init__", func);
                   Py_DECREF(func);
                 }
-                for (int i = 1;i<3;i++) {
+                for (int i = 1; PythonQtClassWrapper_methods[i].ml_name != NULL; i++) {
                   PyObject* func = PyCFunction_New(&PythonQtClassWrapper_methods[i], obj);
                   PyDict_SetItemString(dict, PythonQtClassWrapper_methods[i].ml_name, func);
                   Py_DECREF(func);
             {
               PythonQtClassWrapper* wrapper = (PythonQtClassWrapper*)obj;
               if (wrapper->classInfo()->isCPPWrapper()) {
                 const QMetaObject* meta = wrapper->classInfo()->metaObject();
                 if (!meta) {
                   QObject* decorator = wrapper->classInfo()->decorator();
                   if (decorator) {

src/PythonQtConversion.cpp +1 -1

             PythonQtValueStorage<qint64, 128>  PythonQtConv::global_valueStorage;
             PythonQtValueStorage<void*, 128>   PythonQtConv::global_ptrStorage;
-            PythonQtValueStorage<QVariant, 32> PythonQtConv::global_variantStorage;
+            PythonQtValueStorageWithCleanup<QVariant, 128> PythonQtConv::global_variantStorage;
             QHash<int, PythonQtConvertMetaTypeToPythonCB*> PythonQtConv::_metaTypeToPythonConverters;
             QHash<int, PythonQtConvertPythonToMetaTypeCB*> PythonQtConv::_pythonToMetaTypeConverters;

src/PythonQtConversion.h +1 -1

               static PythonQtValueStorage<qint64, 128>  global_valueStorage;
               static PythonQtValueStorage<void*, 128>   global_ptrStorage;
-              static PythonQtValueStorage<QVariant, 32> global_variantStorage;
+              static PythonQtValueStorageWithCleanup<QVariant, 128>  global_variantStorage;
             protected:
               static QHash<int, PythonQtConvertMetaTypeToPythonCB*> _metaTypeToPythonConverters;

src/PythonQtCppWrapperFactory.h +1 -1

@@ -58,4 +58,4 public:
58		58
59	};	59	};
60		60
61	#endif No newline at end of file	61	#endif

src/PythonQtImportFileInterface.h +5 -2

             #include <QString>
             #include <QByteArray>
             //! Defines an abstract interface to file access for the Python import statement.
             //! see PythonQt::setImporter()
             class PythonQtImportFileInterface {
               //! get the last modified data of a file
               virtual QDateTime lastModifiedDate(const QString& filename) = 0;
+              //! indicates that *.py files which are newer than their corresponding *.pyc files
+              //! are ignored
+              virtual bool ignoreUpdatedPythonSourceFiles() { return false; }
             };
-            #endif
  No newline at end of file
+            #endif

src/PythonQtImporter.cpp +41 -12

                   info.fullPath = test;
                   info.moduleName = subname;
                   info.type = MI_SHAREDLIBRARY;
+                  return info;
                 }
               }
               return info;
               } else {
                 PythonQtObjectPtr imp;
                 imp.setNewRef(PyImport_ImportModule("imp"));
                 // Create a PyList with the current path as its single element,
                 // which is required for find_module (it won't accept a tuple...)
                 PythonQtObjectPtr pathList;
                 args.append(QVariant::fromValue(pathList));
                 QVariant result = imp.call("find_module", args);
                 if (result.isValid()) {
-                  // This will return a tuple with (file, pathname, description)
+                  // This will return a tuple with (file, pathname, description=(suffix,mode,type))
                   QVariantList list = result.toList();
                   if (list.count()==3) {
                     // We prepend the full module name (including package prefix)
                     list.prepend(fullname);
-                    // And call "load_module" with (fullname, file, pathname, description)
+            #ifdef __linux
+              #ifdef _DEBUG
+                    // imp_find_module() does not respect the debug suffix '_d' on Linux,
+                    // so it does not return the correct file path and we correct it now
+                    // find_module opened a file to the release library, but that file handle is
+                    // ignored on Linux and Windows, maybe on MacOS also.
+                    list[2] = info.fullPath;
+              #endif
+            #endif
+                    // And call "load_module" with (fullname, file, pathname, description=(suffix,mode,type))
                     PythonQtObjectPtr module = imp.call("load_module", list);
                     mod = module.object();
                     if (mod) {
                 return Py_None;
               }
-              if (mtime != 0 && !(getLong((unsigned char *)buf + 4) == mtime)) {
+              if (mtime != 0) {
-                if (Py_VerboseFlag)
+                time_t timeDiff = getLong((unsigned char *)buf + 4) - mtime;
-                  PySys_WriteStderr("# %s has bad mtime\n",
+                if (timeDiff<0) { timeDiff = -timeDiff; }
-                        path.toLatin1().constData());
+                if (timeDiff > 1) {
-                Py_INCREF(Py_None);
+                  if (Py_VerboseFlag)
-                return Py_None;
+                    PySys_WriteStderr("# %s has bad mtime\n",
+                    path.toLatin1().constData());
+                  Py_INCREF(Py_None);
+                  return Py_None;
+                }
               }
               code = PyMarshal_ReadObjectFromString(buf + 8, size - 8);
               path2.truncate(path.length()-1);
               if (PythonQt::importInterface()->exists(path2)) {
-                mtime = PythonQt::importInterface()->lastModifiedDate(path2).toTime_t();
+                QDateTime t = PythonQt::importInterface()->lastModifiedDate(path2);
+                if (t.isValid()) {
+                  mtime = t.toTime_t();
+                }
               }
               return mtime;
                   int ispackage = zso->type & IS_PACKAGE;
                   int isbytecode = zso->type & IS_BYTECODE;
-                  if (isbytecode) {
+                  // if ignoreUpdatedPythonSourceFiles() returns true, then mtime stays 0
+                  // and unmarshalCode() in getCodeFromData() will always read an existing *.pyc file,
+                  // even if a newer *.py file exists. This is a release optimization where
+                  // typically only *.pyc files are delivered without *.py files and reading file
+                  // modification time is slow.
+                  if (isbytecode && !PythonQt::importInterface()->ignoreUpdatedPythonSourceFiles()) {
                     mtime = getMTimeOfSource(test);
                   }
                   code = getCodeFromData(test, isbytecode, ispackage, mtime);
               QString pyc = replaceExtension(file, pycStr);
               if (PythonQt::importInterface()->exists(pyc)) {
                 time_t mtime = 0;
-                mtime = getMTimeOfSource(pyc);
+                // if ignoreUpdatedPythonSourceFiles() returns true, then mtime stays 0
+                // and unmarshalCode() in getCodeFromData() will always read an existing *.pyc file,
+                // even if a newer *.py file exists. This is a release optimization where
+                // typically only *.pyc files are delivered without *.py files and reading file
+                // modification time is slow.
+                if (!PythonQt::importInterface()->ignoreUpdatedPythonSourceFiles()) {
+                  mtime = getMTimeOfSource(pyc);
+                }
                 code = getCodeFromData(pyc, true, false, mtime);
                 if (code != Py_None && code != NULL) {
                   return code;

src/PythonQtInstanceWrapper.cpp +46 -6

               return PyString_FromString(obj->ob_type->tp_name);
             }
+            PyObject *PythonQtInstanceWrapper_inherits(PythonQtInstanceWrapper* obj, PyObject *args)
+            {
+              char *name = NULL;
+              if (!PyArg_ParseTuple(args, "s:PythonQtInstanceWrapper.inherits",&name)) {
+                return NULL;
+              }
+              return PythonQtConv::GetPyBool(obj->classInfo()->inherits(name));
+            }
             static PyObject *PythonQtInstanceWrapper_help(PythonQtInstanceWrapper* obj)
             {
               return PythonQt::self()->helpCalled(obj->classInfo());
             }
-            static PyObject *PythonQtInstanceWrapper_delete(PythonQtInstanceWrapper * self)
+            PyObject *PythonQtInstanceWrapper_delete(PythonQtInstanceWrapper * self)
             {
               PythonQtInstanceWrapper_deleteObject(self, true);
               Py_INCREF(Py_None);
                 {"className", (PyCFunction)PythonQtInstanceWrapper_classname, METH_NOARGS,
                  "Return the classname of the object"
                 },
+                {"inherits", (PyCFunction)PythonQtInstanceWrapper_inherits, METH_VARARGS,
+                "Returns if the class inherits or is of given type name"
+                },
                 {"help", (PyCFunction)PythonQtInstanceWrapper_help, METH_NOARGS,
                 "Shows the help of available methods for this class"
                 },
               case PythonQtMemberInfo::Property:
                 if (wrapper->_obj) {
                   if (member._property.userType() != QVariant::Invalid) {
-                    return PythonQtConv::QVariantToPyObject(member._property.read(wrapper->_obj));
+                    PythonQt::ProfilingCB* profilingCB = PythonQt::priv()->profilingCB();
+                    if (profilingCB) {
+                      QString methodName = "getProperty(";
+                      methodName += attributeName;
+                      methodName += ")";
+                      profilingCB(PythonQt::Enter, wrapper->_obj->metaObject()->className(), methodName.toLatin1());
+                    }
+                    PyObject* value = PythonQtConv::QVariantToPyObject(member._property.read(wrapper->_obj));
+                    if (profilingCB) {
+                      profilingCB(PythonQt::Leave, NULL, NULL);
+                    }
+                    return value;
                   } else {
                     Py_INCREF(Py_None);
                     return Py_None;
                   }
                   bool success = false;
                   if (v.isValid()) {
+                    PythonQt::ProfilingCB* profilingCB = PythonQt::priv()->profilingCB();
+                    if (profilingCB) {
+                      QString methodName = "setProperty(";
+                      methodName += attributeName;
+                      methodName += ")";
+                      profilingCB(PythonQt::Enter, wrapper->_obj->metaObject()->className(), methodName.toLatin1());
+                    }
                     success = prop.write(wrapper->_obj, v);
+                    if (profilingCB) {
+                      profilingCB(PythonQt::Leave, NULL, NULL);
+                    }
                   }
                   if (success) {
                     return 0;
                 if (str.startsWith(typeName)) {
                   return PyString_FromFormat("%s", str.toLatin1().constData());
                 } else {
-                  return PyString_FromFormat("%s(%s, %p)", typeName, str.toLatin1().constData(), wrapper->_wrappedPtr);
+                  return PyString_FromFormat("%s (%s, at: %p)", typeName, str.toLatin1().constData(), wrapper->_wrappedPtr ? wrapper->_wrappedPtr : qobj);
                 }
               }
               if (wrapper->_wrappedPtr) {
                 if (wrapper->_obj) {
-                  return PyString_FromFormat("%s (C++ Object %p wrapped by %s %p))", typeName, wrapper->_wrappedPtr, wrapper->_obj->metaObject()->className(), qobj);
+                  return PyString_FromFormat("%s (C++ object at: %p wrapped by %s at: %p)", typeName, wrapper->_wrappedPtr, wrapper->_obj->metaObject()->className(), qobj);
                 } else {
-                  return PyString_FromFormat("%s (C++ Object %p)", typeName, wrapper->_wrappedPtr);
+                  return PyString_FromFormat("%s (C++ object at: %p)", typeName, wrapper->_wrappedPtr);
                 }
               } else {
-                return PyString_FromFormat("%s (%s %p)", typeName, wrapper->classInfo()->className(), qobj);
+                return PyString_FromFormat("%s (%s at: %p)", typeName, wrapper->classInfo()->className(), qobj);
               }
             }

src/PythonQtInstanceWrapper.h +4 -2

               //! stores if the object is a shell instance
               bool _isShellInstance;
             } PythonQtInstanceWrapper;
             int PythonQtInstanceWrapper_init(PythonQtInstanceWrapper * self, PyObject * args, PyObject * kwds);
-            #endif
  No newline at end of file
+            PyObject *PythonQtInstanceWrapper_delete(PythonQtInstanceWrapper * self);
+            #endif

src/PythonQtMethodInfo.cpp +5 -8

                 _parameterTypeDict.insert("qreal", QMetaType::Double);
                 _parameterTypeDict.insert("QChar", QMetaType::QChar);
                 _parameterTypeDict.insert("QByteArray", QMetaType::QByteArray);
-                _parameterTypeDict.insert("Q3CString", QMetaType::QByteArray);
                 _parameterTypeDict.insert("QString", QMetaType::QString);
                 _parameterTypeDict.insert("", QMetaType::Void);
                 _parameterTypeDict.insert("void", QMetaType::Void);
                 _parameterTypeDict.insert("qulonglong", QMetaType::ULongLong);
                 _parameterTypeDict.insert("qint64", QMetaType::LongLong);
                 _parameterTypeDict.insert("quint64", QMetaType::ULongLong);
-                _parameterTypeDict.insert("QIconSet", QMetaType::QIcon);
                 _parameterTypeDict.insert("QVariantMap", QMetaType::QVariantMap);
                 _parameterTypeDict.insert("QVariantList", QMetaType::QVariantList);
                 _parameterTypeDict.insert("QMap<QString,QVariant>", QMetaType::QVariantMap);
                 _parameterTypeDict.insert("QUrl", QMetaType::QUrl);
                 _parameterTypeDict.insert("QLocale", QMetaType::QLocale);
                 _parameterTypeDict.insert("QRect", QMetaType::QRect);
-                _parameterTypeDict.insert("QRectf", QMetaType::QRectF);
+                _parameterTypeDict.insert("QRectF", QMetaType::QRectF);
                 _parameterTypeDict.insert("QSize", QMetaType::QSize);
-                _parameterTypeDict.insert("QSizef", QMetaType::QSizeF);
+                _parameterTypeDict.insert("QSizeF", QMetaType::QSizeF);
                 _parameterTypeDict.insert("QLine", QMetaType::QLine);
-                _parameterTypeDict.insert("QLinef", QMetaType::QLineF);
+                _parameterTypeDict.insert("QLineF", QMetaType::QLineF);
                 _parameterTypeDict.insert("QPoint", QMetaType::QPoint);
-                _parameterTypeDict.insert("QPointf", QMetaType::QPointF);
+                _parameterTypeDict.insert("QPointF", QMetaType::QPointF);
                 _parameterTypeDict.insert("QRegExp", QMetaType::QRegExp);
-            //    _parameterTypeDict.insert("QColorGroup", QMetaType::QColorGroup);
                 _parameterTypeDict.insert("QFont", QMetaType::QFont);
                 _parameterTypeDict.insert("QPixmap", QMetaType::QPixmap);
                 _parameterTypeDict.insert("QBrush", QMetaType::QBrush);
                 _parameterTypeDict.insert("QCursor", QMetaType::QCursor);
                 _parameterTypeDict.insert("QPalette", QMetaType::QPalette);
                 _parameterTypeDict.insert("QIcon", QMetaType::QIcon);
-                _parameterTypeDict.insert("QImage", QMetaType::QPolygon);
+                _parameterTypeDict.insert("QImage", QMetaType::QImage);
                 _parameterTypeDict.insert("QRegion", QMetaType::QRegion);
                 _parameterTypeDict.insert("QBitmap", QMetaType::QBitmap);
                 _parameterTypeDict.insert("QSizePolicy", QMetaType::QSizePolicy);

src/PythonQtMisc.h +41 -8

@@ -89,13 +89,6 public:
89	_chunks.clear();	89	_chunks.clear();
90	}	90	}
91		91
92	//! reset the storage to 0 (without freeing memory, thus caching old entries for reuse)
93	void reset() {
94	_chunkIdx = 0;
95	_chunkOffset = 0;
96	_currentChunk = _chunks.at(0);
97	}
98
99	//! get the current position to be restored with setPos	92	//! get the current position to be restored with setPos
100	void getPos(PythonQtValueStoragePosition & pos) {	93	void getPos(PythonQtValueStoragePosition & pos) {
101	pos.chunkIdx = _chunkIdx;	94	pos.chunkIdx = _chunkIdx;
@@ -129,7 +122,7 public:
129	return newEntry;	122	return newEntry;
130	};	123	};
131		124
132	private:	125	protected:
133	QList<T*> _chunks;	126	QList<T*> _chunks;
134		127
135	int _chunkIdx;	128	int _chunkIdx;
@@ -138,5 +131,45 private:
138		131
139	};	132	};
140		133
		134	//! a helper class that stores basic C++ value types in chunks and clears the unused values on setPos() usage.
		135	template <typename T, int chunkEntries> class PythonQtValueStorageWithCleanup : public PythonQtValueStorage<T, chunkEntries>
		136	{
		137	public:
		138	void setPos(const PythonQtValueStoragePosition& pos) {
		139	if (_chunkIdx > pos.chunkIdx) {
		140	T* firstChunk = _chunks.at(pos.chunkIdx);
		141	// clear region in first chunk
		142	for (int i = pos.chunkOffset; i < chunkEntries; i++) {
		143	firstChunk[i] = T();
		144	}
		145	for (int chunk = pos.chunkIdx + 1; chunk < _chunkIdx; chunk++) {
		146	// clear the full chunks between the first and last chunk
		147	T* fullChunk = _chunks.at(chunk);
		148	for (int i = 0; i < chunkEntries; i++) {
		149	fullChunk[i] = T();
		150	}
		151	}
		152	// clear region in last chunk
		153	T* lastChunk = _chunks.at(_chunkIdx);
		154	for (int i = 0; i < _chunkOffset; i++) {
		155	lastChunk[i] = T();
		156	}
		157	} else if (_chunkIdx == pos.chunkIdx) {
		158	// clear the region in the last chunk only
		159	T* lastChunk = _chunks.at(_chunkIdx);
		160	for (int i = pos.chunkOffset; i<_chunkOffset; i++) {
		161	lastChunk[i] = T();
		162	}
		163	}
		164
		165	PythonQtValueStorage<T, chunkEntries>::setPos(pos);
		166	}
		167
		168	private:
		169	using PythonQtValueStorage<T, chunkEntries>::_chunks;
		170	using PythonQtValueStorage<T, chunkEntries>::_chunkIdx;
		171	using PythonQtValueStorage<T, chunkEntries>::_chunkOffset;
		172	using PythonQtValueStorage<T, chunkEntries>::_currentChunk;
		173	};
141		174
142	#endif	175	#endif

src/PythonQtObjectPtr.h +13 -13

                 setObject(p.object());
               }
               //! If the given variant holds a PythonQtObjectPtr, extract the value from it and hold onto the reference. This results in an increment of the reference count.
               PythonQtObjectPtr(const QVariant& variant):_object(NULL) {
                   fromVariant(variant);
               }
               PythonQtObjectPtr(PyObject* o) {
                 _object = o;
                 if (o) Py_INCREF(_object);
               }
-              ~PythonQtObjectPtr() { if (_object) Py_DECREF(_object); }
+              ~PythonQtObjectPtr() { if (_object) { Py_DECREF(_object); } }
               //! If the given variant holds a PythonQtObjectPtr, extract the value from it and hold onto the reference. This results in an increment of the reference count.
               bool fromVariant(const QVariant& variant);
               PythonQtObjectPtr &operator=(const PythonQtObjectPtr &p) {
                 setObject(p.object());
                 return *this;
                 return *this;
               }
               PythonQtObjectPtr &operator=(const QVariant& variant) {
                   fromVariant(variant);
                   return *this;
               }
               bool operator==( const PythonQtObjectPtr &p ) const {
                 return object() == p.object();
               }
               //! sets the object and passes the ownership (stealing the reference, in Python slang)
               void setNewRef(PyObject* o) {
                 if (o != _object) {
-                  if (_object) Py_DECREF(_object);
+                  if (_object) { Py_DECREF(_object); }
                   _object = o;
                 }
               }
               void setObject(PyObject* o) {
                 if (o != _object) {
-                  if (_object) Py_DECREF(_object);
+                  if (_object) { Py_DECREF(_object); }
                   _object = o;
-                  if (_object) Py_INCREF(_object);
+                  if (_object) { Py_INCREF(_object); }
                 }
               }
             // register it to the meta type system
             Q_DECLARE_METATYPE(PythonQtObjectPtr)
-            #endif
  No newline at end of file
+            #endif

src/PythonQtSignalReceiver.cpp +4 -2

             PyObject* PythonQtSignalTarget::call(PyObject* callable, const PythonQtMethodInfo* methodInfos, void **arguments, bool skipFirstArgumentOfMethodInfo)
             {
+              Q_UNUSED(skipFirstArgumentOfMethodInfo)
               // Note: we check if the callable is a PyFunctionObject and has a fixed number of arguments
               // if that is the case, we only pass these arguments to python and skip the additional arguments from the signal
               int numPythonArgs = -1;
               if (PyFunction_Check(callable)) {
                 PyObject* o = callable;
             PythonQtSignalReceiver::PythonQtSignalReceiver(QObject* obj):PythonQtSignalReceiverBase(obj)
             {
               _obj = obj;
               // fetch the class info for object, since we will need to for correct enum resolution in
               // signals
               _objClassInfo = PythonQt::priv()->getClassInfo(obj->metaObject());

src/PythonQtSignalReceiver.h +1 -1

             class PythonQtClassInfo;
             //! stores information about a signal target
-            /*! copy construction and assignment works fine with the C++ standard behaviour and are thus not implemented
+            /*! copy construction and assignment works fine with the C++ standard behavior and are thus not implemented
             */
             class PYTHONQT_EXPORT PythonQtSignalTarget {
             public:

src/PythonQtSlot.cpp +28 -11

             bool PythonQtCallSlot(PythonQtClassInfo* classInfo, QObject* objectToCall, PyObject* args, bool strict, PythonQtSlotInfo* info, void* firstArgument, PyObject** pythonReturnValue, void** directReturnValuePointer)
             {
               static unsigned int recursiveEntry = 0;
               if (directReturnValuePointer) {
                 *directReturnValuePointer = NULL;
               }
               PythonQtConv::global_valueStorage.getPos(globalValueStoragePos);
               PythonQtConv::global_ptrStorage.getPos(globalPtrStoragePos);
               PythonQtConv::global_variantStorage.getPos(globalVariantStoragePos);
               recursiveEntry++;
               // the arguments that are passed to qt_metacall
               void* argList[PYTHONQT_MAX_ARGS];
               PyObject* result = NULL;
               int argc = info->parameterCount();
               const QList<PythonQtSlotInfo::ParameterInfo>& params = info->parameters();
               const PythonQtSlotInfo::ParameterInfo& returnValueParam = params.at(0);
               // set return argument to NULL
               argList[0] = NULL;
               bool ok = true;
               bool skipFirst = false;
               if (info->isInstanceDecorator()) {
                   }
                 }
               }
               if (ok) {
                 // parameters are ok, now create the qt return value which is assigned to by metacall
                 if (returnValueParam.typeId != QMetaType::Void) {
                         if (result) {
                           argList[0] = ((PythonQtInstanceWrapper*)result)->_wrappedPtr;
                         }
                         Py_DECREF(emptyTuple);
+                      }
                     }
                   } else {
                     // we can use our pointer directly!
                   }
                 }
+                PythonQt::ProfilingCB* profilingCB = PythonQt::priv()->profilingCB();
+                if (profilingCB) {
+                  const char* className = NULL;
+                  if (info->decorator()) {
+                    className = info->decorator()->metaObject()->className();
+                  } else {
+                    className = objectToCall->metaObject()->className();
+                  }
+                  profilingCB(PythonQt::Enter, className, info->metaMethod()->signature());
+                }
                 // invoke the slot via metacall
                 (info->decorator()?info->decorator():objectToCall)->qt_metacall(QMetaObject::InvokeMetaMethod, info->slotIndex(), argList);
+                if (profilingCB) {
+                  profilingCB(PythonQt::Leave, NULL, NULL);
+                }
                 // handle the return value (which in most cases still needs to be converted to a Python object)
                 if (argList[0] || returnValueParam.typeId == QMetaType::Void) {
                   if (directReturnValuePointer) {
                 }
               }
               recursiveEntry--;
               // reset the parameter storage position to the stored pos to "pop" the parameter stack
               PythonQtConv::global_valueStorage.setPos(globalValueStoragePos);
               PythonQtConv::global_ptrStorage.setPos(globalPtrStoragePos);
               PythonQtConv::global_variantStorage.setPos(globalVariantStoragePos);
               *pythonReturnValue = result;
               // NOTE: it is important to only return here, otherwise the stack will not be popped!!!
               return result || (directReturnValuePointer && *directReturnValuePointer);
                   PyErr_SetString(PyExc_ValueError, e.toLatin1().data());
                 }
               }
               return r;
             }

src/PythonQtStdDecorators.cpp +6 -15

               } else {
                 signalTmp = "2" + signal;
               }
               if (sender) {
                 return PythonQt::self()->addSignalHandler(sender, signalTmp, callable);
               } else {
                 } else {
                   signalTmp = "2" + signal;
                 }
                 QByteArray slotTmp;
                 first = slot.at(0);
                 if (first>='0' && first<='9') {
                 } else {
                   slotTmp = "1" + slot;
                 }
                 r = QObject::disconnect(sender, signalTmp, receiver, slotTmp);
               }
               return r;
             }
-            #undef emit
-            void PythonQtStdDecorators::emit(QObject* sender, const QByteArray& signal, PyObject* arg1 ,PyObject* arg2 ,
-                      PyObject* arg3 ,PyObject* arg4 ,PyObject* arg5 ,PyObject* arg6 ,PyObject* arg7 )
-              // TODO xxx
-              // use normal PythonQtSlot calling code, add "allowSignal" to member lookup?!
-            #define emit
             QObject* PythonQtStdDecorators::parent(QObject* o) {
               return o->parent();
             }
                 if (!name.isNull() && obj->objectName() != name)
                   continue;
                 if ((typeName && obj->inherits(typeName)) ||
                   (meta && meta->cast(obj)))
                   return obj;
               }
                 if (!name.isNull() && obj->objectName() != name)
                   continue;
                 if ((typeName && obj->inherits(typeName)) ||
                   (meta && meta->cast(obj))) {
                     list += obj;
                 }
                 if (regExp.indexIn(obj->objectName()) == -1)
                   continue;
                 if ((typeName && obj->inherits(typeName)) ||
                   (meta && meta->cast(obj))) {
                     list += obj;
                 }

src/PythonQtStdDecorators.h +6 -11

               bool disconnect(QObject* sender, const QByteArray& signal, PyObject* callable);
               bool disconnect(QObject* sender, const QByteArray& signal, QObject* receiver, const QByteArray& slot);
-            #undef emit
-              void emit(QObject* sender, const QByteArray& signal, PyObject* arg1 = NULL,PyObject* arg2 = NULL,
-                        PyObject* arg3 = NULL,PyObject* arg4 = NULL,PyObject* arg5 = NULL,PyObject* arg6 = NULL,PyObject* arg7 = NULL);
-            #define emit
               QObject* parent(QObject* o);
               void setParent(QObject* o, QObject* parent);
               QObject* findChild(QObject* parent, PyObject* type, const QString& name = QString());
               QList<QObject*> findChildren(QObject* parent, PyObject* type, const QString& name= QString());
               QList<QObject*> findChildren(QObject* parent, PyObject* type, const QRegExp& regExp);
               bool setProperty(QObject* o, const char* name, const QVariant& value);
               QVariant property(QObject* o, const char* name);
               double static_Qt_qAbs(double a) { return qAbs(a); }
               double static_Qt_qBound(double a,double b,double c) { return qBound(a,b,c); }
-              void static_Qt_qDebug(const QByteArray& msg) { qDebug(msg.constData()); }
+              void static_Qt_qDebug(const QByteArray& msg) { qDebug("%s", msg.constData()); }
               // TODO: multi arg qDebug...
-              void static_Qt_qWarning(const QByteArray& msg) { qWarning(msg.constData()); }
+              void static_Qt_qWarning(const QByteArray& msg) { qWarning("%s", msg.constData()); }
               // TODO: multi arg qWarning...
-              void static_Qt_qCritical(const QByteArray& msg) { qCritical(msg.constData()); }
+              void static_Qt_qCritical(const QByteArray& msg) { qCritical("%s", msg.constData()); }
               // TODO: multi arg qCritical...
-              void static_Qt_qFatal(const QByteArray& msg) { qFatal(msg.constData()); }
+              void static_Qt_qFatal(const QByteArray& msg) { qFatal("%s", msg.constData()); }
               // TODO: multi arg qFatal...
               bool static_Qt_qFuzzyCompare(double a, double b) { return qFuzzyCompare(a, b); }
               double static_Qt_qMax(double a, double b) { return qMax(a, b); }
               void static_Qt_qsrand(uint a) { qsrand(a); }
               QString tr(QObject* obj, const QByteArray& text, const QByteArray& ambig = QByteArray(), int n = -1);
               QByteArray static_Qt_SIGNAL(const QByteArray& s) { return QByteArray("2") + s; }
               QByteArray static_Qt_SLOT(const QByteArray& s) { return QByteArray("1") + s; }

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