GIT_REPOSITORIES/LPP/PythonQt Commit - r189:91b62d374275

added support for kwargs on call() methods...

florianlink -

r189:91b62d374275

parent child

Context file:

r189:91b62d374275

Collapse all files

src/PythonQt.cpp +43 -20

               return results;
             }
-            QVariant PythonQt::call(PyObject* object, const QString& name, const QVariantList& args)
+            QVariant PythonQt::call(PyObject* object, const QString& name, const QVariantList& args, const QVariantMap& kwargs)
             {
               PythonQtObjectPtr callable = lookupCallable(object, name);
               if (callable) {
-                return call(callable, args);
+                return call(callable, args, kwargs);
               } else {
                 return QVariant();
               }
             }
-            QVariant PythonQt::call(PyObject* callable, const QVariantList& args)
+            QVariant PythonQt::call(PyObject* callable, const QVariantList& args, const QVariantMap& kwargs)
             {
               QVariant r;
               PythonQtObjectPtr result;
-              result.setNewRef(callAndReturnPyObject(callable, args));
+              result.setNewRef(callAndReturnPyObject(callable, args, kwargs));
               if (result) {
                 r = PythonQtConv::PyObjToQVariant(result);
               } else {
               return r;
             }
-            PyObject* PythonQt::callAndReturnPyObject(PyObject* callable, const QVariantList& args)
+            PyObject* PythonQt::callAndReturnPyObject(PyObject* callable, const QVariantList& args, const QVariantMap& kwargs)
             {
               PyObject* result = NULL;
               if (callable) {
+                bool err = false;
                 PythonQtObjectPtr pargs;
                 int count = args.size();
-                if (count>0) {
+                if ((count > 0) || (kwargs.count() > 0)) { // create empty tuple if kwargs are given
                   pargs.setNewRef(PyTuple_New(count));
-                bool err = false;
+                  // transform QVariant arguments to Python
-                // transform QVariants to Python
+                  for (int i = 0; i < count; i++) {
-                for (int i = 0; i < count; i++) {
+                    PyObject* arg = PythonQtConv::QVariantToPyObject(args.at(i));
-                  PyObject* arg = PythonQtConv::QVariantToPyObject(args.at(i));
+                    if (arg) {
-                  if (arg) {
+                      // steals reference, no unref
-                    // steals reference, no unref
+                      PyTuple_SetItem(pargs, i,arg);
-                    PyTuple_SetItem(pargs, i,arg);
+                    } else {
-                  } else {
+                      err = true;
-                    err = true;
+                      break;
-                    break;
                   }
                 }
                 if (!err) {
-                  PyErr_Clear();
+                  if (kwargs.isEmpty()) {
-                  result = PyObject_CallObject(callable, pargs);
+                    // do a direct call if we have no keyword arguments
+                    PyErr_Clear();
+                    result = PyObject_CallObject(callable, pargs);
+                  } else {
+                    // convert keyword arguments to Python
+                    PythonQtObjectPtr pkwargs;
+                    pkwargs.setNewRef(PyDict_New());
+                    QMapIterator<QString, QVariant> it(kwargs);
+                    while (it.hasNext()) {
+                      it.next();
+                      PyObject* arg = PythonQtConv::QVariantToPyObject(it.value());
+                      if (arg) {
+                        PyDict_SetItemString(pkwargs, it.key().toLatin1().constData(), arg);
+                      } else {
+                        err = true;
+                        break;
+                      }
+                    }
+                    if (!err) {
+                      // call with arguments and keyword arguments
+                      PyErr_Clear();
+                      result = PyObject_Call(callable, pargs, pkwargs);
+                    }
+                  }
                 }
               }
               return result;

src/PythonQt.h +3 -3

               //@{
               //! 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());
+              QVariant call(PyObject* object, const QString& callable, const QVariantList& args = QVariantList(), const QVariantMap& kwargs = QVariantMap());
               //! call the given python object, returns the result converted to a QVariant
-              QVariant call(PyObject* callable, const QVariantList& args = QVariantList());
+              QVariant call(PyObject* callable, const QVariantList& args = QVariantList(), const QVariantMap& kwargs = QVariantMap());
               //! call the given python object, returns the result as new PyObject
-              PyObject* callAndReturnPyObject(PyObject* callable, const QVariantList& args = QVariantList());
+              PyObject* callAndReturnPyObject(PyObject* callable, const QVariantList& args = QVariantList(), const QVariantMap& kwargs = QVariantMap());
               //@}

src/PythonQtObjectPtr.cpp +4 -4

             }
-            QVariant PythonQtObjectPtr::call(const QString& callable, const QVariantList& args)
+            QVariant PythonQtObjectPtr::call(const QString& callable, const QVariantList& args, const QVariantMap& kwargs)
             {
-              return PythonQt::self()->call(_object, callable, args);
+              return PythonQt::self()->call(_object, callable, args, kwargs);
             }
-            QVariant PythonQtObjectPtr::call(const QVariantList& args)
+            QVariant PythonQtObjectPtr::call(const QVariantList& args, const QVariantMap& kwargs)
             {
-              return PythonQt::self()->call(_object, args);
+              return PythonQt::self()->call(_object, args, kwargs);
             }
             bool PythonQtObjectPtr::fromVariant(const QVariant& variant)

src/PythonQtObjectPtr.h +3 -2

             #include "PythonQtSystem.h"
             #include <QVariant>
             #include <QVariantList>
+            #include <QVariantMap>
             //! a smart pointer that stores a PyObject pointer and that handles reference counting automatically
             class PYTHONQT_EXPORT PythonQtObjectPtr
               QVariant getVariable(const QString& name);
               //! 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());
+              QVariant call(const QString& callable, const QVariantList& args = QVariantList(), const QVariantMap& kwargs = QVariantMap());
               //! call the contained python object directly, returns the result converted to a QVariant
-              QVariant call(const QVariantList& args = QVariantList());
+              QVariant call(const QVariantList& args = QVariantList(), const QVariantMap& kwargs = QVariantMap());
             protected:

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