From bac154b896b39c1e817742ce2213da3e0d346977 Mon Sep 17 00:00:00 2001
From: Renato Filho <renato.filho@openbossa.org>
Date: Mon, 12 Jul 2010 18:45:19 -0300
Subject: Create support to QVariantList and QVariantMap.

Fixes bug: #263

Reviewer: Marcelo Lira <marcelo.lira@openbossa.org>
          Luciano Wolf <luciano.wolf@openbossa.org>
---
 PySide/QtCore/qvariant_conversions.h      | 63 +++++++++++++++++++++++++++++++
 PySide/QtCore/qvariant_type_conversions.h | 32 +++++++++++++++-
 PySide/QtCore/typesystem_core.xml         |  2 +
 3 files changed, 96 insertions(+), 1 deletion(-)

(limited to 'PySide/QtCore')

diff --git a/PySide/QtCore/qvariant_conversions.h b/PySide/QtCore/qvariant_conversions.h
index 613e523d2..9178aa824 100644
--- a/PySide/QtCore/qvariant_conversions.h
+++ b/PySide/QtCore/qvariant_conversions.h
@@ -40,6 +40,10 @@ struct Converter<QVariant>
         } else if (Shiboken::isShibokenEnum(pyObj)) {
             // QVariant(enum)
             return QVariant(Converter<int>::toCpp(pyObj));
+        } else if (PyDict_Check(pyObj)) {
+            return convertToVariantMap(pyObj);
+        } else if (PySequence_Check(pyObj)) {
+            return convertToVariantList(pyObj);
         } else if (!isShibokenType(pyObj) || isUserType(pyObj)) {
             // QVariant(User class)
             return QVariant::fromValue<PySide::PyObjectWrapper>(pyObj);
@@ -70,11 +74,70 @@ struct Converter<QVariant>
     static PyObject* toPython(const QVariant& cppObj)
     {
         if (cppObj.isValid()) {
+            if (qstrcmp(cppObj.typeName(), "QVariantList") == 0)
+                return Converter<QList<QVariant> >::toPython(cppObj.value<QVariantList>());
+
+            if (qstrcmp(cppObj.typeName(), "QStringList") == 0)
+                return Converter<QList<QString> >::toPython(cppObj.value<QStringList>());
+
+            if (qstrcmp(cppObj.typeName(), "QVariantMap") == 0)
+                return Converter<QMap<QString, QVariant> >::toPython(cppObj.value<QVariantMap>());
+
             Shiboken::TypeResolver* tr = Shiboken::TypeResolver::get(cppObj.typeName());
             if (tr)
                 return tr->toPython(const_cast<void*>(cppObj.data()));
         }
         Py_RETURN_NONE;
     }
+
+    static QVariant convertToVariantMap(PyObject* map)
+    {
+        PyObject *key, *value;
+        Py_ssize_t pos = 0;
+        AutoDecRef keys(PyDict_Keys(map));
+        bool keysIsString = isStringList(keys);
+        if (keysIsString) {
+            QMap<QString, QVariant> ret;
+            while (PyDict_Next(map, &pos, &key, &value))
+                ret.insert(Converter<QString>::toCpp(key), toCpp(value));
+            return QVariant(ret);
+        } else {
+            return toCpp(map);
+        }
+    }
+
+    static bool isStringList(PyObject *list)
+    {
+        bool allString = true;
+        AutoDecRef fast(PySequence_Fast(list, "Failed to convert QVariantList"));
+        Py_ssize_t size = PySequence_Fast_GET_SIZE(fast.object());
+        for(int i=0; i < size; i++) {
+            PyObject* item = PySequence_Fast_GET_ITEM(fast.object(), i);
+            if (!Converter<QString>::checkType(item)) {
+                allString = false;
+                break;
+            }
+        }
+        return allString;
+    }
+
+    static QVariant convertToVariantList(PyObject* list)
+    {
+        bool allString = isStringList(list);
+        if (allString) {
+            QStringList lst = Converter<QList<QString> >::toCpp(list);
+            return QVariant(lst);
+        } else {
+            QList<QVariant> lst;
+            AutoDecRef fast(PySequence_Fast(list, "Failed to convert QVariantList"));
+            Py_ssize_t size = PySequence_Fast_GET_SIZE(fast.object());
+            for(int i=0; i < size; i++) {
+                PyObject* item = PySequence_Fast_GET_ITEM(fast.object(), i);
+                lst.append(toCpp(item));
+            }
+            return QVariant(lst);
+        }
+        Q_ASSERT(false);
+    }
 };
 }
diff --git a/PySide/QtCore/qvariant_type_conversions.h b/PySide/QtCore/qvariant_type_conversions.h
index 107fb4203..d1cf9f0ca 100644
--- a/PySide/QtCore/qvariant_type_conversions.h
+++ b/PySide/QtCore/qvariant_type_conversions.h
@@ -15,7 +15,7 @@ struct Converter<QVariant::Type>
 
     static QVariant::Type toCpp(PyObject* pyObj)
     {
-        const char* typeName;
+        const char* typeName = 0;
         if (pyObj == Py_None)
             return QVariant::Invalid;
 
@@ -31,6 +31,15 @@ struct Converter<QVariant::Type>
             typeName = PyString_AS_STRING(pyObj);
         else if (PyUnicode_Check(pyObj))
             typeName = PyString_AsString(pyObj);
+        else if (PyDict_Check(pyObj) && checkAllStringKeys(pyObj))
+            typeName = "QVariantMap";
+        else if (PySequence_Check(pyObj))
+            if (isStringList(pyObj))
+                typeName = "QStringList";
+            else
+                typeName = "QVariantList";
+        else
+            Q_ASSERT(false);
 
         return QVariant::nameToType(typeName);
     }
@@ -49,5 +58,26 @@ struct Converter<QVariant::Type>
         Py_INCREF(pyObj);
         return pyObj;
     }
+
+    static bool isStringList(PyObject* list)
+    {
+        bool allString = true;
+        AutoDecRef fast(PySequence_Fast(list, "Failed to convert QVariantList"));
+        Py_ssize_t size = PySequence_Fast_GET_SIZE(fast.object());
+        for(int i=0; i < size; i++) {
+            PyObject* item = PySequence_Fast_GET_ITEM(fast.object(), i);
+            if (!Converter<QString>::checkType(item)) {
+                allString = false;
+                break;
+            }
+        }
+        return allString;
+    }
+
+    static bool checkAllStringKeys(PyObject* dict)
+    {
+        AutoDecRef keys(PyDict_Keys(dict));
+        return isStringList(keys);
+    }
 };
 }
diff --git a/PySide/QtCore/typesystem_core.xml b/PySide/QtCore/typesystem_core.xml
index 56c4f894d..133ece38c 100644
--- a/PySide/QtCore/typesystem_core.xml
+++ b/PySide/QtCore/typesystem_core.xml
@@ -178,6 +178,8 @@
     <conversion-rule file="qvector_conversions.h"/>
     <include file-name="QVector" location="global"/>
   </container-type>
+
+
   <rejection class="QVector" function-name="back"/>
   <rejection class="QVector" function-name="begin"/>
   <rejection class="QVector" function-name="constBegin"/>
-- 
cgit v1.2.3