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 +33 -10

                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 QVariants to Python
+                   // transform QVariant arguments to Python
                  for (int i = 0; i < count; i++) {
                    PyObject* arg = PythonQtConv::QVariantToPyObject(args.at(i));
                    if (arg) {
                      break;
                    }
                  }
+                 }
                  if (!err) {
+                   if (kwargs.isEmpty()) {
+                     // 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