GIT_REPOSITORIES/LPP/PythonQt Commit - r36:1d1e7c03e848

- added call method that does a direct call on the ObjectType...

florianlink -

r36:1d1e7c03e848

parent child

Context file:

r36:1d1e7c03e848

src/PythonQt.cpp +11 -3

@@ -805,11 +805,19 QStringList PythonQt::introspection(PyObject* module, const QString& objectname,
805	return results;	805	return results;
806	}	806	}
807		807
808	QVariant PythonQt::call(PyObject* ~~module~~, const QString& name, const QVariantList& args)	808	QVariant PythonQt::call(PyObject* object, const QString& name, const QVariantList& args)
		809	{
		810	PythonQtObjectPtr callable = lookupCallable(object, name);
		811	if (callable) {
		812	return call(callable, args);
		813	} else {
		814	return QVariant();
		815	}
		816	}
		817
		818	QVariant PythonQt::call(PyObject* callable, const QVariantList& args)
809	{	819	{
810	QVariant r;	820	QVariant r;
811
812	PythonQtObjectPtr callable = lookupCallable(module, name);
813	if (callable) {	821	if (callable) {
814	PythonQtObjectPtr pargs;	822	PythonQtObjectPtr pargs;
815	int count = args.size();	823	int count = args.size();

src/PythonQt.h +5 -2

               //@{ Calling of python callables
-              //! call the given python method, returns the result converted to a QVariant
+              //! call the given python \c callable in the scope of object, returns the result converted to a QVariant
-              QVariant call(PyObject* module, const QString& callable, const QVariantList& args = QVariantList());
+              QVariant call(PyObject* object, const QString& callable, const QVariantList& args = QVariantList());
+              //! call the given python object, returns the result converted to a QVariant
+              QVariant call(PyObject* callable, const QVariantList& args = QVariantList());
               //@}

src/PythonQtConversion.cpp +3 -1

                   // c++ wrapper, check if the class names of the c++ objects match
                   if (wrap->classInfo()->isCPPWrapper()) {
                     if (wrap->classInfo()->metaTypeId()>0) {
-                      // construct a new variant from the C++ object if it has a meta type
+                      // construct a new variant from the C++ object if it has a meta type (this will COPY the object!)
                       v = QVariant(wrap->classInfo()->metaTypeId(), wrap->_wrappedPtr);
                     } else {
+                      // TODOXXX we could as well check if there is a registered meta type for "classname*", so that we may pass
+                      // the pointer here...
                       // is this worth anything? we loose the knowledge of the cpp object type
                       v = qVariantFromValue(wrap->_wrappedPtr);
                     }

src/PythonQtDoc.h +1 0

              - PythonQt allows to communicate in both directions, e.g. calling a Python object from C++ AND calling a C++ method from Python, while PyQt only handles the Python->C++ direction
              - PythonQt offers properties as Python attributes, while PyQt offers them as setter/getter methods (e.g. QWidget.width is a property in PythonQt and a method in PyQt)
              - PythonQt does not auto-convert objects, e.g. when a QPainter expects a QBrush and you pass a QColor, it is rejected, you will need to write QBrush(QColor(1,2,3)) instead
+             - PythonQt returns/handles enums/flags as integers, which can cause problems on overloads that take ints and enums, a future version might use an own enum type (like PyQt does)
              - Probably there are lots of details that differ, I do not know PyQt that well to list them all.

src/PythonQtObjectPtr.cpp +5 0

               return PythonQt::self()->call(_object, callable, args);
             }
+            QVariant PythonQtObjectPtr::call(const QVariantList& args)
+            {
+              return PythonQt::self()->call(_object, args);
+            }
             bool PythonQtObjectPtr::fromVariant(const QVariant& variant)
             {
               if (!variant.isNull()) {

src/PythonQtObjectPtr.h +2 -2

               //! call the given python object (in the scope of the current object), returns the result converted to a QVariant
               QVariant call(const QString& callable, const QVariantList& args = QVariantList());
+              //! call the contained python object directly, returns the result converted to a QVariant
+              QVariant call(const QVariantList& args = QVariantList());
             protected:

General Comments 0

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

No TODOs yet

	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