← Back to branch summary

~oif-team/ubuntu/natty/qt4-x11/xi2.1

« back to all changes in this revision

Viewing changes to src/dbus/qdbusinterface.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Alessandro Ghersi
  • Date: 2009-11-02 18:30:08 UTC
  • mfrom: (1.2.2 upstream)
  • mto: (15.2.5 experimental)
  • mto: This revision was merged to the branch mainline in revision 88.
  • Revision ID: james.westby@ubuntu.com-20091102183008-b6a4gcs128mvfb3m
Tags: upstream-4.6.0~beta1
Import upstream version 4.6.0~beta1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/dbus/qdbusinterface.cpp
1
1
/****************************************************************************
2
2
**
3
3
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
 
4
** All rights reserved.
4
5
** Contact: Nokia Corporation (qt-info@nokia.com)
5
6
**
6
7
** This file is part of the QtDBus module of the Qt Toolkit.
7
8
**
8
9
** $QT_BEGIN_LICENSE:LGPL$
9
 
** Commercial Usage
10
 
** Licensees holding valid Qt Commercial licenses may use this file in
11
 
** accordance with the Qt Commercial License Agreement provided with the
12
 
** Software or, alternatively, in accordance with the terms contained in
13
 
** a written agreement between you and Nokia.
 
10
** No Commercial Usage
 
11
** This file contains pre-release code and may not be distributed.
 
12
** You may use this file in accordance with the terms and conditions
 
13
** contained in the Technology Preview License Agreement accompanying
 
14
** this package.
14
15
**
15
16
** GNU Lesser General Public License Usage
16
17
** Alternatively, this file may be used under the terms of the GNU Lesser
20
21
** ensure the GNU Lesser General Public License version 2.1 requirements
21
22
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
22
23
**
23
 
** In addition, as a special exception, Nokia gives you certain
24
 
** additional rights. These rights are described in the Nokia Qt LGPL
25
 
** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
26
 
** package.
27
 
**
28
 
** GNU General Public License Usage
29
 
** Alternatively, this file may be used under the terms of the GNU
30
 
** General Public License version 3.0 as published by the Free Software
31
 
** Foundation and appearing in the file LICENSE.GPL included in the
32
 
** packaging of this file.  Please review the following information to
33
 
** ensure the GNU General Public License version 3.0 requirements will be
34
 
** met: http://www.gnu.org/copyleft/gpl.html.
35
 
**
36
 
** If you are unsure which license is appropriate for your use, please
37
 
** contact the sales department at http://www.qtsoftware.com/contact.
 
24
** In addition, as a special exception, Nokia gives you certain additional
 
25
** rights.  These rights are described in the Nokia Qt LGPL Exception
 
26
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 
27
**
 
28
** If you have questions regarding the use of this file, please contact
 
29
** Nokia at qt-info@nokia.com.
 
30
**
 
31
**
 
32
**
 
33
**
 
34
**
 
35
**
 
36
**
 
37
**
38
38
** $QT_END_LICENSE$
39
39
**
40
40
****************************************************************************/
51
51
 
52
52
QT_BEGIN_NAMESPACE
53
53
 
 
54
static void copyArgument(void *to, int id, const QVariant &arg)
 
55
{
 
56
    if (id == arg.userType()) {
 
57
        switch (id) {
 
58
        case QVariant::Bool:
 
59
            *reinterpret_cast<bool *>(to) = arg.toBool();
 
60
            return;
 
61
 
 
62
        case QMetaType::UChar:
 
63
            *reinterpret_cast<uchar *>(to) = arg.value<uchar>();
 
64
            return;
 
65
 
 
66
        case QMetaType::Short:
 
67
            *reinterpret_cast<short *>(to) = arg.value<short>();
 
68
            return;
 
69
 
 
70
        case QMetaType::UShort:
 
71
            *reinterpret_cast<ushort *>(to) = arg.value<ushort>();
 
72
            return;
 
73
 
 
74
        case QVariant::Int:
 
75
            *reinterpret_cast<int *>(to) = arg.toInt();
 
76
            return;
 
77
 
 
78
        case QVariant::UInt:
 
79
            *reinterpret_cast<uint *>(to) = arg.toUInt();
 
80
            return;
 
81
 
 
82
        case QVariant::LongLong:
 
83
            *reinterpret_cast<qlonglong *>(to) = arg.toLongLong();
 
84
            return;
 
85
 
 
86
        case QVariant::ULongLong:
 
87
            *reinterpret_cast<qulonglong *>(to) = arg.toULongLong();
 
88
            return;
 
89
 
 
90
        case QVariant::Double:
 
91
            *reinterpret_cast<double *>(to) = arg.toDouble();
 
92
            return;
 
93
 
 
94
        case QVariant::String:
 
95
            *reinterpret_cast<QString *>(to) = arg.toString();
 
96
            return;
 
97
 
 
98
        case QVariant::ByteArray:
 
99
            *reinterpret_cast<QByteArray *>(to) = arg.toByteArray();
 
100
            return;
 
101
 
 
102
        case QVariant::StringList:
 
103
            *reinterpret_cast<QStringList *>(to) = arg.toStringList();
 
104
            return;
 
105
        }
 
106
 
 
107
        if (id == QDBusMetaTypeId::variant) {
 
108
            *reinterpret_cast<QDBusVariant *>(to) = arg.value<QDBusVariant>();
 
109
            return;
 
110
        } else if (id == QDBusMetaTypeId::objectpath) {
 
111
            *reinterpret_cast<QDBusObjectPath *>(to) = arg.value<QDBusObjectPath>();
 
112
            return;
 
113
        } else if (id == QDBusMetaTypeId::signature) {
 
114
            *reinterpret_cast<QDBusSignature *>(to) = arg.value<QDBusSignature>();
 
115
            return;
 
116
        }
 
117
 
 
118
        // those above are the only types possible
 
119
        // the demarshaller code doesn't demarshall anything else
 
120
        qFatal("Found a decoded basic type in a D-Bus reply that shouldn't be there");
 
121
    }
 
122
 
 
123
    // if we got here, it's either an un-dermarshalled type or a mismatch
 
124
    if (arg.userType() != QDBusMetaTypeId::argument) {
 
125
        // it's a mismatch
 
126
        //qWarning?
 
127
        return;
 
128
    }
 
129
 
 
130
    // is this type registered?
 
131
    const char *userSignature = QDBusMetaType::typeToSignature(id);
 
132
    if (!userSignature || !*userSignature) {
 
133
        // type not registered
 
134
        //qWarning?
 
135
        return;
 
136
    }
 
137
 
 
138
    // is it the same signature?
 
139
    QDBusArgument dbarg = arg.value<QDBusArgument>();
 
140
    if (dbarg.currentSignature() != QLatin1String(userSignature)) {
 
141
        // not the same signature, another mismatch
 
142
        //qWarning?
 
143
        return;
 
144
    }
 
145
 
 
146
    // we can demarshall
 
147
    QDBusMetaType::demarshall(dbarg, id, to);
 
148
}
 
149
 
54
150
QDBusInterfacePrivate::QDBusInterfacePrivate(const QString &serv, const QString &p,
55
151
                                             const QString &iface, const QDBusConnection &con)
56
152
    : QDBusAbstractInterfacePrivate(serv, p, iface, con, true), metaObject(0)
186
282
 
187
283
            // we will assume that the input arguments were passed correctly
188
284
            QVariantList args;
189
 
            for (int i = 1; i <= inputTypesCount; ++i)
 
285
            int i = 1;
 
286
            for ( ; i <= inputTypesCount; ++i)
190
287
                args << QVariant(inputTypes[i], argv[i]);
191
288
 
192
289
            // make the call
193
 
            QPointer<QDBusInterface> qq = q;
194
290
            QDBusMessage reply = q->callWithArgumentList(QDBus::Block, methodName, args);
195
 
            args.clear();
196
 
 
197
 
            // we ignore return values
198
 
 
199
 
            // access to "this" or to "q" below this point must check for "qq"
200
 
            // we may have been deleted!
201
 
 
202
 
            if (!qq.isNull())
203
 
                lastError = reply;
 
291
 
 
292
            if (reply.type() == QDBusMessage::ReplyMessage) {
 
293
                // attempt to demarshall the return values
 
294
                args = reply.arguments();
 
295
                QVariantList::ConstIterator it = args.constBegin();
 
296
                const int *outputTypes = metaObject->outputTypesForMethod(id);
 
297
                int outputTypesCount = *outputTypes++;
 
298
 
 
299
                if (*mm.typeName()) {
 
300
                    // this method has a return type
 
301
                    if (argv[0] && it != args.constEnd())
 
302
                        copyArgument(argv[0], *outputTypes++, *it);
 
303
 
 
304
                    // skip this argument even if we didn't copy it
 
305
                    --outputTypesCount;
 
306
                    ++it;
 
307
                }
 
308
 
 
309
                for (int j = 0; j < outputTypesCount && it != args.constEnd(); ++i, ++j, ++it) {
 
310
                    copyArgument(argv[i], outputTypes[j], *it);
 
311
                }
 
312
            }
204
313
 
205
314
            // done
 
315
            lastError = reply;
206
316
            return -1;
207
317
        }
208
 
    } else if (c == QMetaObject::ReadProperty) {
209
 
        // Qt doesn't support non-readable properties
210
 
        // we have to re-check
211
 
        QMetaProperty mp = metaObject->property(id + metaObject->propertyOffset());
212
 
        if (!mp.isReadable())
213
 
            return -1;          // don't read
214
 
 
215
 
        QVariant *value = reinterpret_cast<QVariant*>(argv[1]);
216
 
        argv[1] = 0;
217
 
        *value = property(mp);
218
 
 
219
 
        return -1;              // handled, error or not
220
 
    } else if (c == QMetaObject::WriteProperty) {
221
 
        // QMetaProperty::write has already checked that we're writable
222
 
        // it has also checked that the type is right
223
 
        QVariant *value = reinterpret_cast<QVariant *>(argv[1]);
224
 
        QMetaProperty mp = metaObject->property(id + metaObject->propertyOffset());
225
 
 
226
 
        setProperty(mp, *value);
227
 
        return -1;
228
318
    }
229
319
    return id;
230
320
}