Actually move the kde files that were renamed in the last commit

1 files changed, 945 insertions, 0 deletions

diff --git a/sip/tdecore/bytearray.sip b/sip/tdecore/bytearray.sip
new file mode 100644
index 0000000..aae4780
--- /dev/null
+++ b/sip/tdecore/bytearray.sip
@@ -0,0 +1,945 @@
+//
+//     Copyright 2004 Jim Bublitz <jbublitz@nwinternet.com>
+//     Earlier copyrights 1998 - 2003 Jim Bublitz and/or Phil Thompson
+//     may also apply
+
+//            module tdecore  version KDE_3_2_2
+
+
+// This software is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of
+// the License, or (at your option) any later version.
+//
+// This software is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public
+// License along with this library; see the file COPYING.
+// If not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+%ModuleHeaderCode
+#include <qvariant.h>
+%End
+
+
+void dcop_add (QDataStream&, QWidget::FocusPolicy /Constrained/);
+void dcop_add (QDataStream&, int /Constrained/, const QCString& = "int");
+//void dcop_add (QDataStream&, longlong);
+//void dcop_add (QDataStream&, ulonglong);
+void dcop_add (QDataStream&, double, const QCString& = "double");
+void dcop_add (QDataStream&, QString);
+void dcop_add (QDataStream&, QStringList);
+void dcop_add (QDataStream&, QCString);
+void dcop_add (QDataStream&, KURL);
+void dcop_add (QDataStream&, KURL::List);
+void dcop_add (QDataStream&, QSize);
+void dcop_add (QDataStream&, QRect);
+void dcop_add (QDataStream&, QRegion);
+void dcop_add (QDataStream&, QPoint);
+void dcop_add (QDataStream&, QFont);
+void dcop_add (QDataStream&, QCursor);
+void dcop_add (QDataStream&, QPixmap);
+void dcop_add (QDataStream&, QColor);
+void dcop_add (QDataStream&, QColorGroup);
+void dcop_add (QDataStream&, QPalette);
+void dcop_add (QDataStream&, QBrush);
+void dcop_add (QDataStream&, DCOPRef);
+void dcop_add (QDataStream&, QVariant);
+void dcop_add (QDataStream&, QDate);
+void dcop_add (QDataStream&, QTime);
+void dcop_add (QDataStream&, QDateTime);
+void dcop_add (QDataStream&, QImage);
+void dcop_add (QDataStream&, QKeySequence);
+void dcop_add (QDataStream&, QPen);
+void dcop_add (QDataStream&, QPicture);
+void dcop_add (QDataStream&, QPointArray);
+void dcop_add (QDataStream&, QByteArray);
+
+void dcop_add (QDataStream&, SIP_PYDICT, QCString);
+%MethodCode
+    const sipTypeDef *map_td = sipFindType(*a2);
+
+    if (map_td)
+    {
+        int iserr = 0;
+        void *map_v;
+
+        map_v = sipForceConvertToType(a1, map_td, NULL,
+                SIP_NOT_NONE|SIP_NO_CONVERTORS, NULL, &iserr);
+
+        if (iserr)
+        {
+            sipIsErr = 1;
+        }
+        else if (*a2 == "QMap<QCString,DCOPRef>")
+        {
+            QMap<QCString,DCOPRef> *map = (QMap<QCString,DCOPRef> *)map_v;
+
+            *a0 << *map;
+        }
+        else if (*a2 == "QMap<QString,DCOPRef>")
+        {
+            QMap<QString,DCOPRef> *map = (QMap<QString,DCOPRef> *)map_v;
+
+            *a0 << *map;
+        }
+        else if (*a2 == "QMap<QString,QString>")
+        {
+            QMap<QString,QString> *map = (QMap<QString,QString> *)map_v;
+
+            *a0 << *map;
+        }
+        else if (*a2 == "QMap<QString,QByteArray>")
+        {
+            QMap<QString,QByteArray> *map = (QMap<QString,QByteArray> *)map_v;
+
+            *a0 << *map;
+        }
+    }
+%End
+
+
+void dcop_add (QDataStream&, SIP_PYLIST, QCString);
+%MethodCode
+    const sipTypeDef *list_td = sipFindType(*a2);
+
+    if (list_td)
+    {
+        int iserr = 0;
+        void *list_v;
+
+        list_v = sipForceConvertToType(a1, list_td, NULL,
+                SIP_NOT_NONE|SIP_NO_CONVERTORS, NULL, &iserr);
+
+        if (iserr)
+        {
+            sipIsErr = 1;
+        }
+        else if (*a2 == "QValueList<QCString>")
+        {
+            QValueList<QCString> *list = (QValueList<QCString> *)list_v;
+
+            *a0 << *list;
+        }
+        else if (*a2 == "QValueList<DCOPRef>")
+        {
+            QValueList<DCOPRef> *list = (QValueList<DCOPRef> *)list_v;
+
+            *a0 << *list;
+        }
+    }
+%End
+
+
+void dcop_next (QDataStream&, QCString&);
+%MethodCode
+    if (*a1 == "char")
+    {
+        Q_INT8 res;
+        *a0 >> res;
+        return PyInt_FromLong ((long)res);
+    }
+    else if (*a1 == "bool")
+    {
+        bool res;
+        *a0 >> res;
+        return PyBool_FromLong ((long)res);
+    }
+    else if (*a1 == "int")
+    {
+        int res;
+        *a0 >> res;
+        return PyInt_FromLong ((long)res);
+    }
+    else if (*a1 == "long")
+    {
+        long res;
+        *a0 >> res;
+        return PyLong_FromLong (res);
+    }
+    else if (*a1 == "short")
+    {
+        short res;
+        *a0 >> res;
+        return PyInt_FromLong ((long)res);
+    }
+    if (*a1 == "uchar" || *a1 == "unsigned char")
+    {
+        Q_UINT8 res;
+        *a0 >> res;
+        return PyInt_FromLong ((long)res);
+    }
+    else if (*a1 == "uint" || *a1 == "unsigned int")
+    {
+        unsigned int res;
+        *a0 >> res;
+        return PyInt_FromLong ((long)res);
+    }
+    else if (*a1 == "ulong" || *a1 == "unsigned long")
+    {
+        unsigned long res;
+        *a0 >> res;
+        return PyLong_FromLong (res);
+    }
+    else if (*a1 == "Q_INT32")
+    {
+        Q_INT32 res;
+        *a0 >> res;
+        return PyLong_FromLong ((long)res);
+    }
+    else if (*a1 == "pid_t")
+    {
+        pid_t res;
+        *a0 >> res;
+        return PyLong_FromLong ((long)res);
+    }
+    else if (*a1 == "ushort" || *a1 == "unsigned short")
+    {
+        unsigned short res;
+        *a0 >> res;
+        return PyInt_FromLong ((long)res);
+    }
+    else if (*a1 == "float")
+    {
+        float res;
+        *a0 >> res;
+        return PyFloat_FromDouble ((double)res);
+    }
+    else if (*a1 == "double")
+    {
+        double res;
+        *a0 >> res;
+        return PyFloat_FromDouble (res);
+    }
+    else if (*a1 == "QString")
+    {
+        QString res;
+        *a0 >> res;
+        return sipConvertFromNewType(new QString(res), sipType_QString, NULL);
+    }
+    else if (*a1 == "QStringList")
+    {
+        QStringList res;
+        *a0 >> res;
+        return sipConvertFromNewType(new QStringList(res), sipType_QStringList, NULL);
+    }
+    else if (*a1 == "QCString")
+    {
+        QCString res;
+        *a0 >> res;
+        return sipConvertFromNewType(new QCString(res), sipType_QCString, NULL);
+    }
+    else if (*a1 == "KURL")
+    {
+        KURL res;
+        *a0 >> res;
+        return sipConvertFromNewType(new KURL(res), sipType_KURL, NULL);
+    }
+    else if (*a1 == "KURL::List")
+    {
+        KURL::List res;
+        *a0 >> res;
+        return sipConvertFromNewType(new KURL::List(res), sipType_KURL_List, NULL);
+    }
+    else if (*a1 == "QSize")
+    {
+        QSize res;
+        *a0 >> res;
+        return sipConvertFromNewType(new QSize(res), sipType_QSize, NULL);
+    }
+    else if (*a1 == "QRect")
+    {
+        QRect res;
+        *a0 >> res;
+        return sipConvertFromNewType(new QRect(res), sipType_QRect, NULL);
+    }
+    else if (*a1 == "QRegion")
+    {
+        QRect res;
+        *a0 >> res;
+        return sipConvertFromNewType(new QRegion(res), sipType_QRegion, NULL);
+    }
+    else if (*a1 == "QPoint")
+    {
+        QPoint res;
+        *a0 >> res;
+        return sipConvertFromNewType(new QPoint(res), sipType_QPoint, NULL);
+    }
+    else if (*a1 == "QFont")
+    {
+        QFont res;
+        *a0 >> res;
+        return sipConvertFromNewType(new QFont(res), sipType_QFont, NULL);
+    }
+    else if (*a1 == "QCursor")
+    {
+        QCursor res;
+        *a0 >> res;
+        return sipConvertFromNewType(new QCursor(res), sipType_QCursor, NULL);
+    }
+    else if (*a1 == "QPixmap")
+    {
+        QPixmap res;
+        *a0 >> res;
+        return sipConvertFromNewType(new QPixmap(res), sipType_QPixmap, NULL);
+    }
+    else if (*a1 == "QColor")
+    {
+        QColor res;
+        *a0 >> res;
+        return sipConvertFromNewType(new QColor(res), sipType_QColor, NULL);
+    }
+    else if (*a1 == "QColorGroup")
+    {
+        QColorGroup res;
+        *a0 >> res;
+        return sipConvertFromNewType(new QColorGroup(res), sipType_QColorGroup, NULL);
+    }
+    else if (*a1 == "QPalette")
+    {
+        QPalette res;
+        *a0 >> res;
+        return sipConvertFromNewType(new QPalette(res), sipType_QPalette, NULL);
+    }
+    else if (*a1 == "QBrush")
+    {
+        QBrush res;
+        *a0 >> res;
+        return sipConvertFromNewType(new QBrush(res), sipType_QBrush, NULL);
+    }
+    else if (*a1 == "FocusPolicy")
+    {
+        unsigned int res;
+        *a0 >> res;
+        return PyInt_FromLong ((long)res);
+    }
+    else if (*a1 == "DCOPRef")
+    {
+        DCOPRef res;
+        *a0 >> res;
+        return sipConvertFromNewType(new DCOPRef(res), sipType_DCOPRef, NULL);
+    }
+    else if (*a1 == "QVariant")
+    {
+        QVariant res;
+        *a0 >> res;
+        return sipConvertFromNewType(new QVariant(res), sipType_QVariant, NULL);
+    }
+    else if (*a1 == "QDate")
+    {
+        QDate res;
+        *a0 >> res;
+        return sipConvertFromNewType(new QDate(res), sipType_QDate, NULL);
+    }
+    else if (*a1 == "QTime")
+    {
+        QTime res;
+        *a0 >> res;
+        return sipConvertFromNewType(new QTime(res), sipType_QTime, NULL);
+    }
+    else if (*a1 == "QDateTime")
+    {
+        QDateTime res;
+        *a0 >> res;
+        return sipConvertFromNewType(new QDateTime(res), sipType_QDateTime, NULL);
+    }
+    else if (*a1 == "QImage")
+    {
+        QImage res;
+        *a0 >> res;
+        return sipConvertFromNewType(new QImage(res), sipType_QImage, NULL);
+    }
+    else if (*a1 == "QKeySequence")
+    {
+        QKeySequence res;
+        *a0 >> res;
+        return sipConvertFromNewType(new QKeySequence(res), sipType_QKeySequence, NULL);
+    }
+    else if (*a1 == "QPen")
+    {
+        QPen res;
+        *a0 >> res;
+        return sipConvertFromNewType(new QPen(res), sipType_QPen, NULL);
+    }
+    else if (*a1 == "QPicture")
+    {
+        QPicture res;
+        *a0 >> res;
+        return sipConvertFromNewType(new QPicture(res), sipType_QPicture, NULL);
+    }
+    else if (*a1 == "QPointArray")
+    {
+        QPointArray res;
+        *a0 >> res;
+        return sipConvertFromNewType(new QPointArray(res), sipType_QPointArray, NULL);
+    }
+    else if (*a1 == "QByteArray")
+    {
+        QByteArray res;
+        *a0 >> res;
+        return sipConvertFromNewType(new QByteArray(res), sipType_QByteArray, NULL);
+    }
+    else if (*a1 == "QMap<QCString,DCOPRef>")
+    {
+        QMap<QCString, DCOPRef> res;
+        *a0 >> res;
+        return sipConvertFromType(&res, sipFindType(*a1), NULL);
+    }
+    else if (*a1 == "QMap<QString,DCOPRef>")
+    {
+        QMap<QString, DCOPRef> res;
+        *a0 >> res;
+        return sipConvertFromType(&res, sipFindType(*a1), NULL);
+    }
+    else if (*a1 == "QMap<QString,QString>")
+    {
+        QMap<QString, QString> res;
+        *a0 >> res;
+        return sipConvertFromType(&res, sipFindType(*a1), NULL);
+    }
+    else if (*a1 == "QMap<QString,QByteArray>")
+    {
+        QMap<QString, QByteArray> res;
+        *a0 >> res;
+        return sipConvertFromType(&res, sipFindType(*a1), NULL);
+    }
+    else if (*a1 == "QValueList<QCString>")
+    {
+        QValueList<QCString> res;
+        *a0 >> res;
+        return sipConvertFromType(&res, sipFindType(*a1), NULL);
+    }
+    else if (*a1 == "QValueList<DCOPRef>" || *a1 == "QCStringList")
+    {
+        QValueList<DCOPRef> res;
+        *a0 >> res;
+        return sipConvertFromType(&res, sipFindType(*a1), NULL);
+    }
+
+%End
+
+%ModuleHeaderCode
+#include <qcstring.h>
+#include <qdatastream.h>
+#include <dcopref.h>
+%End
+
+%ModuleCode
+
+void dcop_add (QDataStream& s, int value, const QCString& type_)
+{
+    if (type_ == "char")
+        s << (Q_INT8)value;
+    else if (type_ == "bool")
+        s << (bool)value;
+    else if (type_ == "short")
+        s << (short)value;
+    else if (type_ == "int")
+        s << (int)value;
+    else if (type_ == "long")
+        s << (long)value;
+    else if (type_== "uchar" || type_ == "unsigned char")
+        s << (Q_UINT8)value;
+    else if (type_ == "ushort" || type_ == "unsigned short")
+        s << (ushort)value;
+    else if (type_ == "uint" || type_ == "unsigned int")
+        s << (uint)value;
+    else if (type_ == "ulong" || type_ == "unsigned long")
+        s << (long)value;
+}
+
+/*void dcop_add (QDataStream& s, longlong value)
+{
+    s << value;
+}
+
+void dcop_add (QDataStream& s, ulonglong value)
+{
+    s << value;
+}*/
+
+void dcop_add (QDataStream& s, double value, const QCString& type_)
+{
+    if (type_ == "double")
+        s << value;
+    else if (type_ == "float")
+        s << (float)value;
+}
+
+void dcop_add (QDataStream& s, QString value)
+{
+    s << value;
+}
+
+void dcop_add (QDataStream& s, QStringList value)
+{
+    s << value;
+}
+
+void dcop_add (QDataStream& s, QCString value)
+{
+    s << value;
+}
+
+void dcop_add (QDataStream& s, KURL value)
+{
+    s << value;
+}
+
+void dcop_add (QDataStream& s, KURL::List value)
+{
+    s << value;
+}
+
+void dcop_add (QDataStream& s, QSize value)
+{
+    s << value;
+}
+
+void dcop_add (QDataStream& s, QRect value)
+{
+    s << value;
+}
+
+void dcop_add (QDataStream& s, QRegion value)
+{
+    s << value;
+}
+
+void dcop_add (QDataStream& s, QPoint value)
+{
+    s << value;
+}
+
+void dcop_add (QDataStream& s, QFont value)
+{
+    s << value;
+}
+
+void dcop_add (QDataStream& s, QCursor value)
+{
+    s << value;
+}
+
+void dcop_add (QDataStream& s, QPixmap value)
+{
+    s << value;
+}
+
+void dcop_add (QDataStream& s, QColor value)
+{
+    s << value;
+}
+
+void dcop_add (QDataStream& s, QColorGroup value)
+{
+    s << value;
+}
+
+void dcop_add (QDataStream& s, QPalette value)
+{
+    s << value;
+}
+
+void dcop_add (QDataStream& s, QBrush value)
+{
+    s << value;
+}
+
+void dcop_add (QDataStream& s, QWidget::FocusPolicy value)
+{
+    s << value;
+}
+
+void dcop_add (QDataStream& s, DCOPRef value)
+{
+    s << value;
+}
+
+void dcop_add (QDataStream& s, QVariant value)
+{
+    s << value;
+}
+
+void dcop_add (QDataStream& s, QDate value)
+{
+    s << value;
+}
+
+void dcop_add (QDataStream& s, QTime value)
+{
+    s << value;
+}
+
+void dcop_add (QDataStream& s, QDateTime value)
+{
+    s << value;
+}
+
+void dcop_add (QDataStream& s, QImage value)
+{
+    s << value;
+}
+
+void dcop_add (QDataStream& s, QKeySequence value)
+{
+    s << value;
+}
+
+void dcop_add (QDataStream& s, QPen value)
+{
+    s << value;
+}
+
+void dcop_add (QDataStream& s, QPicture value)
+{
+    s << value;
+}
+
+void dcop_add (QDataStream& s, QPointArray value)
+{
+    s << value;
+}
+
+void dcop_add (QDataStream& s, QByteArray value)
+{
+    s << value;
+}
+
+%End
+
+
+%MappedType QMap<QCString,DCOPRef>
+//converts a Python dict of QCString:DCOPRef
+{
+%TypeHeaderCode
+#include <qmap.h>
+//typedef QMap<QCString,DCOPRef> DCOPRefMap;
+%End
+
+%ConvertFromTypeCode
+    // Convert to a Python dict
+
+    if (!sipCpp)
+        return PyDict_New();
+
+    PyObject *dict;
+
+    // Create the dictionary.
+
+    if ((dict = PyDict_New()) == NULL)
+        return NULL;
+
+    // Get it.
+
+    const QMap<QCString,DCOPRef> cppmap = *sipCpp;
+    QMap<QCString,DCOPRef>::ConstIterator it;
+
+    for (it = cppmap.begin (); it != cppmap.end (); ++it)
+    {
+        QCString acpp = it.key ();
+        DCOPRef bcpp = it.data ();
+        PyObject *ainst;
+        PyObject *binst = NULL;
+        if (((ainst = sipConvertFromNewType(new QCString(acpp), sipType_QCString, NULL)) == NULL)
+            || ((binst = sipConvertFromNewType(new DCOPRef(bcpp), sipType_DCOPRef, NULL)) == NULL)
+            || (PyDict_SetItem (dict, ainst, binst) < 0))
+        {
+            Py_XDECREF (ainst);
+            Py_XDECREF (binst);
+            Py_DECREF (dict);
+            return NULL;
+        }
+    }
+
+    return dict;
+%End
+
+
+%ConvertToTypeCode
+    // Convert a Python dictionary to a QMap on the heap.
+
+    if (sipIsErr == NULL)
+        return PyDict_Check(sipPy);
+
+    QMap<QCString,DCOPRef> *cppmap = new QMap<QCString,DCOPRef>;
+
+    PyObject *aelem, *belem;
+    SIP_SSIZE_T pos = 0;
+    QCString *acpp;
+    DCOPRef *bcpp;
+
+    while (PyDict_Next(sipPy, &pos, &aelem, &belem))
+    {
+        int iserr = 0;
+
+        acpp = (QCString *)sipForceConvertToType(aelem, sipType_QCString, sipTransferObj, SIP_NOT_NONE|SIP_NO_CONVERTORS, NULL, &iserr);
+        bcpp = (DCOPRef *)sipForceConvertToType(belem, sipType_DCOPRef, sipTransferObj, SIP_NOT_NONE|SIP_NO_CONVERTORS, NULL, &iserr);
+
+        if (iserr)
+        {
+            *sipIsErr = 1;
+            delete cppmap;
+            return 0;
+        }
+
+        cppmap->insert (*acpp, *bcpp);
+    }
+
+    *sipCppPtr = cppmap;
+
+    return 1;
+%End
+};
+
+%MappedType QMap<QString,DCOPRef>
+//converts a Python dict of QString:DCOPRef
+{
+%TypeHeaderCode
+#include <qmap.h>
+//typedef QMap<QString,DCOPRef> DCOPRefMap;
+%End
+
+%ConvertFromTypeCode
+    // Convert to a Python dict
+
+    if (!sipCpp)
+        return PyDict_New();
+
+    PyObject *dict;
+
+    // Create the dictionary.
+
+    if ((dict = PyDict_New()) == NULL)
+        return NULL;
+
+    // Get it.
+
+    const QMap<QString,DCOPRef> cppmap = *sipCpp;
+    QMap<QString,DCOPRef>::ConstIterator it;
+
+    for (it = cppmap.begin (); it != cppmap.end (); ++it)
+    {
+        QString acpp = it.key ();
+        DCOPRef bcpp = it.data ();
+        PyObject *ainst;
+        PyObject *binst = NULL;
+        if (((ainst = sipConvertFromNewType(new QString(acpp), sipType_QString, sipTransferObj)) == NULL)
+            || ((binst = sipConvertFromNewType(new DCOPRef(bcpp), sipType_DCOPRef, sipTransferObj)) == NULL)
+            || (PyDict_SetItem (dict, ainst, binst) < 0))
+        {
+            Py_XDECREF (ainst);
+            Py_XDECREF (binst);
+            Py_DECREF (dict);
+            return NULL;
+        }
+    }
+
+    return dict;
+%End
+
+
+%ConvertToTypeCode
+    // Convert a Python dictionary to a QMap on the heap.
+
+    if (sipIsErr == NULL)
+        return PyDict_Check(sipPy);
+
+    QMap<QString,DCOPRef> *cppmap = new QMap<QString,DCOPRef>;
+
+    PyObject *aelem, *belem;
+    SIP_SSIZE_T pos = 0;
+    QString *acpp;
+    DCOPRef *bcpp;
+
+    while (PyDict_Next(sipPy, &pos, &aelem, &belem))
+    {
+        int iserr = 0, acpp_state;
+
+        acpp = (QString *)sipForceConvertToType(aelem, sipType_QString, sipTransferObj, SIP_NOT_NONE, &acpp_state, &iserr);
+        bcpp = (DCOPRef *)sipForceConvertToType(belem, sipType_DCOPRef, sipTransferObj, SIP_NOT_NONE|SIP_NO_CONVERTORS, NULL, &iserr);
+  
+        if (iserr)
+        {
+            if (acpp)
+                sipReleaseType(acpp, sipType_QString, acpp_state);
+
+            *sipIsErr = 1;
+            delete cppmap;
+            return 0;
+        }
+
+        cppmap->insert (*acpp, *bcpp);
+
+        sipReleaseType(acpp, sipType_QString, acpp_state);
+    }
+
+    *sipCppPtr = cppmap;
+
+    return 1;
+%End
+};
+
+
+//%MappedType QMap<QString,QString> is available in tdecore/kconfig.sip
+
+
+%MappedType QMap<QString,QByteArray>
+//converts a Python dict of QString:QByteArray
+{
+%TypeHeaderCode
+#include <qmap.h>
+%End
+
+%ConvertFromTypeCode
+    // Convert to a Python dict
+
+    if (!sipCpp)
+        return PyDict_New();
+
+    PyObject *dict;
+
+    // Create the dictionary.
+
+    if ((dict = PyDict_New()) == NULL)
+        return NULL;
+
+    // Get it.
+
+    const QMap<QString,QByteArray> cppmap = *sipCpp;
+    QMap<QString,QByteArray>::ConstIterator it;
+
+    for (it = cppmap.begin (); it != cppmap.end (); ++it)
+    {
+        QString acpp = it.key ();
+        QByteArray bcpp = it.data ();
+        PyObject *ainst;
+        PyObject *binst = NULL;
+        if (((ainst = sipConvertFromNewType(new QString(acpp), sipType_QString, sipTransferObj)) == NULL)
+            || ((binst = sipConvertFromNewType(new QByteArray(bcpp), sipType_QByteArray, sipTransferObj)) == NULL)
+            || (PyDict_SetItem (dict, ainst, binst) < 0))
+        {
+            Py_XDECREF (ainst);
+            Py_XDECREF (binst);
+            Py_DECREF (dict);
+            return NULL;
+        }
+    }
+
+    return dict;
+%End
+
+
+%ConvertToTypeCode
+    // Convert a Python dictionary to a QMap<QString,QByteArray> on the heap.
+
+    if (sipIsErr == NULL)
+        return PyDict_Check(sipPy);
+
+    QMap<QString,QByteArray> *cppmap = new QMap<QString,QByteArray>;
+
+    PyObject *aelem, *belem;
+    SIP_SSIZE_T pos = 0;
+    QString *acpp;
+    QByteArray *bcpp;
+
+    while (PyDict_Next(sipPy, &pos, &aelem, &belem))
+    {
+        int iserr = 0, acpp_state, bcpp_state;
+
+        acpp = (QString *)sipForceConvertToType(aelem, sipType_QString, sipTransferObj, SIP_NOT_NONE, &acpp_state, &iserr);
+        bcpp = (QByteArray *)sipForceConvertToType(belem, sipType_QByteArray, sipTransferObj, SIP_NOT_NONE, &bcpp_state, &iserr);
+  
+        if (iserr)
+        {
+            if (acpp)
+                sipReleaseType(acpp, sipType_QString, acpp_state);
+
+            *sipIsErr = 1;
+            delete cppmap;
+            return 0;
+        }
+
+        cppmap->insert (*acpp, *bcpp);
+
+        sipReleaseType(acpp, sipType_QString, acpp_state);
+        sipReleaseType(bcpp, sipType_QByteArray, bcpp_state);
+    }
+
+    *sipCppPtr = cppmap;
+
+    return 1;
+%End
+};
+
+
+
+%MappedType QValueList<DCOPRef>
+//converts a Python list of DCOPRef
+{
+%TypeHeaderCode
+#include <qvaluelist.h>
+%End
+
+%ConvertFromTypeCode
+    if (!sipCpp)
+        return PyList_New(0);
+
+    // Create the list
+    PyObject *pylist;
+    if ((pylist = PyList_New(0)) == NULL)
+        return NULL;
+
+    QValueList<DCOPRef> *cpplist = (QValueList<DCOPRef> *)sipCpp;
+    PyObject *inst;
+
+    // Get it.
+    QValueList<DCOPRef>::Iterator it;
+    for( it = cpplist->begin(); it != cpplist->end(); ++it )
+    {
+        if (((inst = sipConvertFromNewType(new DCOPRef(*it), sipType_DCOPRef, NULL)) == NULL)
+            || PyList_Append (pylist, inst) < 0)
+        {
+            Py_DECREF (pylist);
+            return NULL;
+        }
+    }
+
+    return pylist;
+%End
+
+
+%ConvertToTypeCode
+    if (sipIsErr == NULL)
+        return PyList_Check(sipPy);
+
+    QValueList<DCOPRef> *cpplist = new QValueList<DCOPRef>;
+
+    PyObject *elem;
+    DCOPRef *cpp;
+    int iserr = 0;
+
+    for (int i = 0; i < PyList_Size (sipPy); i++)
+    {
+        elem = PyList_GET_ITEM (sipPy, i);
+        cpp = (DCOPRef *)sipForceConvertToType(elem, sipType_DCOPRef, sipTransferObj, SIP_NOT_NONE|SIP_NO_CONVERTORS, NULL, &iserr);
+        if (iserr)
+        {
+            *sipIsErr = 1;
+            delete cpplist;
+            return 0;
+        }
+
+        cpplist->append (*cpp);
+    }
+
+    *sipCppPtr = cpplist;
+
+    return 1;
+%End
+};
+