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 +28 0

                     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[] = {
               }
             }
+            void PythonQt::clearNotFoundCachedMembers()
+            {
+              foreach(PythonQtClassInfo* info, _p->_knownClassInfos) {
+                info->clearNotFoundCachedMembers();
+              }
+            }
             void PythonQtPrivate::removeWrapperPointer(void* obj)
             {
               _wrappedObjects.remove(obj);

src/PythonQt.h +22 0

               };
+              //! 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
               //@{
               //! 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
               //! @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:
               //! 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();
               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 +4 -1

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

src/PythonQtClassWrapper.cpp +34 -2

               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 */
             };
                   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);

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 0 0

NO CONTENT: modified file

src/PythonQtImportFileInterface.h +3 0

               //! 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

src/PythonQtImporter.cpp +34 -5

                   info.fullPath = test;
                   info.moduleName = subname;
                   info.type = MI_SHAREDLIBRARY;
+                  return info;
                 }
               }
               return info;
                 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) {
+                time_t timeDiff = getLong((unsigned char *)buf + 4) - mtime;
+                if (timeDiff<0) { timeDiff = -timeDiff; }
+                if (timeDiff > 1) {
                   if (Py_VerboseFlag)
                     PySys_WriteStderr("# %s has bad mtime\n",
                     path.toLatin1().constData());
                   Py_INCREF(Py_None);
                   return Py_None;
                 }
+              }
               code = PyMarshal_ReadObjectFromString(buf + 8, size - 8);
               if (code == NULL)
               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;
+                // 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 +2 0

             int PythonQtInstanceWrapper_init(PythonQtInstanceWrapper * self, PyObject * args, PyObject * kwds);
+            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 +4 -4

                 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);
               //! 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); }
                 }
               }

src/PythonQtSignalReceiver.cpp +2 0

             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

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 +17 0

@@ -142,9 +142,26 bool PythonQtCallSlot(PythonQtClassInfo* classInfo, QObject* objectToCall, PyObj
142	}	142	}
143	}	143	}
144		144
		145
		146	PythonQt::ProfilingCB* profilingCB = PythonQt::priv()->profilingCB();
		147	if (profilingCB) {
		148	const char* className = NULL;
		149	if (info->decorator()) {
		150	className = info->decorator()->metaObject()->className();
		151	} else {
		152	className = objectToCall->metaObject()->className();
		153	}
		154
		155	profilingCB(PythonQt::Enter, className, info->metaMethod()->signature());
		156	}
		157
145	// invoke the slot via metacall	158	// invoke the slot via metacall
146	(info->decorator()?info->decorator():objectToCall)->qt_metacall(QMetaObject::InvokeMetaMethod, info->slotIndex(), argList);	159	(info->decorator()?info->decorator():objectToCall)->qt_metacall(QMetaObject::InvokeMetaMethod, info->slotIndex(), argList);
147		160
		161	if (profilingCB) {
		162	profilingCB(PythonQt::Leave, NULL, NULL);
		163	}
		164
148	// handle the return value (which in most cases still needs to be converted to a Python object)	165	// handle the return value (which in most cases still needs to be converted to a Python object)
149	if (argList[0] \|\| returnValueParam.typeId == QMetaType::Void) {	166	if (argList[0] \|\| returnValueParam.typeId == QMetaType::Void) {
150	if (directReturnValuePointer) {	167	if (directReturnValuePointer) {

src/PythonQtStdDecorators.cpp 0 -9

@@ -126,15 +126,6 bool PythonQtStdDecorators::disconnect(QObject* sender, const QByteArray& signal
126	return r;	126	return r;
127	}	127	}
128		128
129	#undef emit
130	void PythonQtStdDecorators::emit(QObject* sender, const QByteArray& signal, PyObject* arg1 ,PyObject* arg2 ,
131	PyObject* arg3 ,PyObject* arg4 ,PyObject* arg5 ,PyObject* arg6 ,PyObject* arg7 )
132	{
133	// TODO xxx
134	// use normal PythonQtSlot calling code, add "allowSignal" to member lookup?!
135	}
136	#define emit
137
138	QObject* PythonQtStdDecorators::parent(QObject* o) {	129	QObject* PythonQtStdDecorators::parent(QObject* o) {
139	return o->parent();	130	return o->parent();
140	}	131	}

src/PythonQtStdDecorators.h +4 -9

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

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