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

                return results;
              }
-             QVariant PythonQt::call(PyObject* module, const QString& name, const QVariantList& args)
+             QVariant PythonQt::call(PyObject* object, const QString& name, const QVariantList& args)
              {
-               QVariant r;
+               PythonQtObjectPtr callable = lookupCallable(object, name);
+               if (callable) {
+                 return call(callable, args);
+               } else {
+                 return QVariant();
+               }
+             }
-               PythonQtObjectPtr callable = lookupCallable(module, name);
+             QVariant PythonQt::call(PyObject* callable, const QVariantList& args)
+             {
+               QVariant r;
                if (callable) {
                  PythonQtObjectPtr pargs;
                  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
-               QVariant call(PyObject* module, const QString& callable, const QVariantList& args = QVariantList());
+               //! 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());
+               //! 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