|
1 /**************************************************************************** |
|
2 ** |
|
3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). |
|
4 ** All rights reserved. |
|
5 ** Contact: Nokia Corporation (qt-info@nokia.com) |
|
6 ** |
|
7 ** This file is part of the QtDBus module of the Qt Toolkit. |
|
8 ** |
|
9 ** $QT_BEGIN_LICENSE:LGPL$ |
|
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. |
|
15 ** |
|
16 ** GNU Lesser General Public License Usage |
|
17 ** Alternatively, this file may be used under the terms of the GNU Lesser |
|
18 ** General Public License version 2.1 as published by the Free Software |
|
19 ** Foundation and appearing in the file LICENSE.LGPL included in the |
|
20 ** packaging of this file. Please review the following information to |
|
21 ** ensure the GNU Lesser General Public License version 2.1 requirements |
|
22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. |
|
23 ** |
|
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 ** $QT_END_LICENSE$ |
|
39 ** |
|
40 ****************************************************************************/ |
|
41 |
|
42 #include <QtCore/qmetaobject.h> |
|
43 #include <QtCore/qstringlist.h> |
|
44 |
|
45 #include "qdbusinterface_p.h" // for ANNOTATION_NO_WAIT |
|
46 #include "qdbusabstractadaptor_p.h" // for QCLASSINFO_DBUS_* |
|
47 #include "qdbusconnection_p.h" // for the flags |
|
48 #include "qdbusmetatype_p.h" |
|
49 #include "qdbusmetatype.h" |
|
50 #include "qdbusutil_p.h" |
|
51 |
|
52 QT_BEGIN_NAMESPACE |
|
53 |
|
54 extern QDBUS_EXPORT QString qDBusGenerateMetaObjectXml(QString interface, const QMetaObject *mo, |
|
55 const QMetaObject *base, int flags); |
|
56 |
|
57 static inline QString typeNameToXml(const char *typeName) |
|
58 { |
|
59 // ### copied from qtextdocument.cpp |
|
60 // ### move this into QtCore at some point |
|
61 QString plain = QLatin1String(typeName); |
|
62 QString rich; |
|
63 rich.reserve(int(plain.length() * 1.1)); |
|
64 for (int i = 0; i < plain.length(); ++i) { |
|
65 if (plain.at(i) == QLatin1Char('<')) |
|
66 rich += QLatin1String("<"); |
|
67 else if (plain.at(i) == QLatin1Char('>')) |
|
68 rich += QLatin1String(">"); |
|
69 else if (plain.at(i) == QLatin1Char('&')) |
|
70 rich += QLatin1String("&"); |
|
71 else |
|
72 rich += plain.at(i); |
|
73 } |
|
74 return rich; |
|
75 } |
|
76 |
|
77 // implement the D-Bus org.freedesktop.DBus.Introspectable interface |
|
78 // we do that by analysing the metaObject of all the adaptor interfaces |
|
79 |
|
80 static QString generateInterfaceXml(const QMetaObject *mo, int flags, int methodOffset, int propOffset) |
|
81 { |
|
82 QString retval; |
|
83 |
|
84 // start with properties: |
|
85 if (flags & (QDBusConnection::ExportScriptableProperties | |
|
86 QDBusConnection::ExportNonScriptableProperties)) { |
|
87 for (int i = propOffset; i < mo->propertyCount(); ++i) { |
|
88 static const char *accessvalues[] = {0, "read", "write", "readwrite"}; |
|
89 |
|
90 QMetaProperty mp = mo->property(i); |
|
91 |
|
92 if (!((mp.isScriptable() && (flags & QDBusConnection::ExportScriptableProperties)) || |
|
93 (!mp.isScriptable() && (flags & QDBusConnection::ExportNonScriptableProperties)))) |
|
94 continue; |
|
95 |
|
96 int access = 0; |
|
97 if (mp.isReadable()) |
|
98 access |= 1; |
|
99 if (mp.isWritable()) |
|
100 access |= 2; |
|
101 |
|
102 int typeId = qDBusNameToTypeId(mp.typeName()); |
|
103 if (!typeId) |
|
104 continue; |
|
105 const char *signature = QDBusMetaType::typeToSignature(typeId); |
|
106 if (!signature) |
|
107 continue; |
|
108 |
|
109 retval += QString::fromLatin1(" <property name=\"%1\" type=\"%2\" access=\"%3\"") |
|
110 .arg(QLatin1String(mp.name())) |
|
111 .arg(QLatin1String(signature)) |
|
112 .arg(QLatin1String(accessvalues[access])); |
|
113 |
|
114 if (QDBusMetaType::signatureToType(signature) == QVariant::Invalid) { |
|
115 const char *typeName = QVariant::typeToName(QVariant::Type(typeId)); |
|
116 retval += QString::fromLatin1(">\n <annotation name=\"com.trolltech.QtDBus.QtTypeName\" value=\"%3\"/>\n </property>\n") |
|
117 .arg(typeNameToXml(typeName)); |
|
118 } else { |
|
119 retval += QLatin1String("/>\n"); |
|
120 } |
|
121 } |
|
122 } |
|
123 |
|
124 // now add methods: |
|
125 for (int i = methodOffset; i < mo->methodCount(); ++i) { |
|
126 QMetaMethod mm = mo->method(i); |
|
127 QByteArray signature = mm.signature(); |
|
128 int paren = signature.indexOf('('); |
|
129 |
|
130 bool isSignal; |
|
131 if (mm.methodType() == QMetaMethod::Signal) |
|
132 // adding a signal |
|
133 isSignal = true; |
|
134 else if (mm.methodType() == QMetaMethod::Slot && mm.access() == QMetaMethod::Public) |
|
135 isSignal = false; |
|
136 else |
|
137 continue; // neither signal nor public slot |
|
138 |
|
139 if (isSignal && !(flags & (QDBusConnection::ExportScriptableSignals | |
|
140 QDBusConnection::ExportNonScriptableSignals))) |
|
141 continue; // we're not exporting any signals |
|
142 if (!isSignal && !(flags & (QDBusConnection::ExportScriptableSlots | |
|
143 QDBusConnection::ExportNonScriptableSlots))) |
|
144 continue; // we're not exporting any slots |
|
145 |
|
146 QString xml = QString::fromLatin1(" <%1 name=\"%2\">\n") |
|
147 .arg(isSignal ? QLatin1String("signal") : QLatin1String("method")) |
|
148 .arg(QLatin1String(signature.left(paren))); |
|
149 |
|
150 // check the return type first |
|
151 int typeId = qDBusNameToTypeId(mm.typeName()); |
|
152 if (typeId) { |
|
153 const char *typeName = QDBusMetaType::typeToSignature(typeId); |
|
154 if (typeName) { |
|
155 xml += QString::fromLatin1(" <arg type=\"%1\" direction=\"out\"/>\n") |
|
156 .arg(typeNameToXml(typeName)); |
|
157 |
|
158 // do we need to describe this argument? |
|
159 if (QDBusMetaType::signatureToType(typeName) == QVariant::Invalid) |
|
160 xml += QString::fromLatin1(" <annotation name=\"com.trolltech.QtDBus.QtTypeName.Out0\" value=\"%1\"/>\n") |
|
161 .arg(typeNameToXml(mm.typeName())); |
|
162 } else |
|
163 continue; |
|
164 } |
|
165 else if (*mm.typeName()) |
|
166 continue; // wasn't a valid type |
|
167 |
|
168 QList<QByteArray> names = mm.parameterNames(); |
|
169 QList<int> types; |
|
170 int inputCount = qDBusParametersForMethod(mm, types); |
|
171 if (inputCount == -1) |
|
172 continue; // invalid form |
|
173 if (isSignal && inputCount + 1 != types.count()) |
|
174 continue; // signal with output arguments? |
|
175 if (isSignal && types.at(inputCount) == QDBusMetaTypeId::message) |
|
176 continue; // signal with QDBusMessage argument? |
|
177 if (isSignal && mm.attributes() & QMetaMethod::Cloned) |
|
178 continue; // cloned signal? |
|
179 |
|
180 int j; |
|
181 bool isScriptable = mm.attributes() & QMetaMethod::Scriptable; |
|
182 for (j = 1; j < types.count(); ++j) { |
|
183 // input parameter for a slot or output for a signal |
|
184 if (types.at(j) == QDBusMetaTypeId::message) { |
|
185 isScriptable = true; |
|
186 continue; |
|
187 } |
|
188 |
|
189 QString name; |
|
190 if (!names.at(j - 1).isEmpty()) |
|
191 name = QString::fromLatin1("name=\"%1\" ").arg(QLatin1String(names.at(j - 1))); |
|
192 |
|
193 bool isOutput = isSignal || j > inputCount; |
|
194 |
|
195 const char *signature = QDBusMetaType::typeToSignature(types.at(j)); |
|
196 xml += QString::fromLatin1(" <arg %1type=\"%2\" direction=\"%3\"/>\n") |
|
197 .arg(name) |
|
198 .arg(QLatin1String(signature)) |
|
199 .arg(isOutput ? QLatin1String("out") : QLatin1String("in")); |
|
200 |
|
201 // do we need to describe this argument? |
|
202 if (QDBusMetaType::signatureToType(signature) == QVariant::Invalid) { |
|
203 const char *typeName = QVariant::typeToName( QVariant::Type(types.at(j)) ); |
|
204 xml += QString::fromLatin1(" <annotation name=\"com.trolltech.QtDBus.QtTypeName.%1%2\" value=\"%3\"/>\n") |
|
205 .arg(isOutput ? QLatin1String("Out") : QLatin1String("In")) |
|
206 .arg(isOutput ? j - inputCount : j - 1) |
|
207 .arg(typeNameToXml(typeName)); |
|
208 } |
|
209 } |
|
210 |
|
211 int wantedMask; |
|
212 if (isScriptable) |
|
213 wantedMask = isSignal ? QDBusConnection::ExportScriptableSignals |
|
214 : QDBusConnection::ExportScriptableSlots; |
|
215 else |
|
216 wantedMask = isSignal ? QDBusConnection::ExportNonScriptableSignals |
|
217 : QDBusConnection::ExportNonScriptableSlots; |
|
218 if ((flags & wantedMask) != wantedMask) |
|
219 continue; |
|
220 |
|
221 if (qDBusCheckAsyncTag(mm.tag())) |
|
222 // add the no-reply annotation |
|
223 xml += QLatin1String(" <annotation name=\"" ANNOTATION_NO_WAIT "\"" |
|
224 " value=\"true\"/>\n"); |
|
225 |
|
226 retval += xml; |
|
227 retval += QString::fromLatin1(" </%1>\n") |
|
228 .arg(isSignal ? QLatin1String("signal") : QLatin1String("method")); |
|
229 } |
|
230 |
|
231 return retval; |
|
232 } |
|
233 |
|
234 QString qDBusGenerateMetaObjectXml(QString interface, const QMetaObject *mo, |
|
235 const QMetaObject *base, int flags) |
|
236 { |
|
237 if (interface.isEmpty()) |
|
238 // generate the interface name from the meta object |
|
239 interface = qDBusInterfaceFromMetaObject(mo); |
|
240 |
|
241 QString xml; |
|
242 int idx = mo->indexOfClassInfo(QCLASSINFO_DBUS_INTROSPECTION); |
|
243 if (idx >= mo->classInfoOffset()) |
|
244 return QString::fromUtf8(mo->classInfo(idx).value()); |
|
245 else |
|
246 xml = generateInterfaceXml(mo, flags, base->methodCount(), base->propertyCount()); |
|
247 |
|
248 if (xml.isEmpty()) |
|
249 return QString(); // don't add an empty interface |
|
250 return QString::fromLatin1(" <interface name=\"%1\">\n%2 </interface>\n") |
|
251 .arg(interface, xml); |
|
252 } |
|
253 #if 0 |
|
254 QString qDBusGenerateMetaObjectXml(QString interface, const QMetaObject *mo, const QMetaObject *base, |
|
255 int flags) |
|
256 { |
|
257 if (interface.isEmpty()) { |
|
258 // generate the interface name from the meta object |
|
259 int idx = mo->indexOfClassInfo(QCLASSINFO_DBUS_INTERFACE); |
|
260 if (idx >= mo->classInfoOffset()) { |
|
261 interface = QLatin1String(mo->classInfo(idx).value()); |
|
262 } else { |
|
263 interface = QLatin1String(mo->className()); |
|
264 interface.replace(QLatin1String("::"), QLatin1String(".")); |
|
265 |
|
266 if (interface.startsWith(QLatin1String("QDBus"))) { |
|
267 interface.prepend(QLatin1String("com.trolltech.QtDBus.")); |
|
268 } else if (interface.startsWith(QLatin1Char('Q')) && |
|
269 interface.length() >= 2 && interface.at(1).isUpper()) { |
|
270 // assume it's Qt |
|
271 interface.prepend(QLatin1String("com.trolltech.Qt.")); |
|
272 } else if (!QCoreApplication::instance()|| |
|
273 QCoreApplication::instance()->applicationName().isEmpty()) { |
|
274 interface.prepend(QLatin1String("local.")); |
|
275 } else { |
|
276 interface.prepend(QLatin1Char('.')).prepend(QCoreApplication::instance()->applicationName()); |
|
277 QStringList domainName = |
|
278 QCoreApplication::instance()->organizationDomain().split(QLatin1Char('.'), |
|
279 QString::SkipEmptyParts); |
|
280 if (domainName.isEmpty()) |
|
281 interface.prepend(QLatin1String("local.")); |
|
282 else |
|
283 for (int i = 0; i < domainName.count(); ++i) |
|
284 interface.prepend(QLatin1Char('.')).prepend(domainName.at(i)); |
|
285 } |
|
286 } |
|
287 } |
|
288 |
|
289 QString xml; |
|
290 int idx = mo->indexOfClassInfo(QCLASSINFO_DBUS_INTROSPECTION); |
|
291 if (idx >= mo->classInfoOffset()) |
|
292 return QString::fromUtf8(mo->classInfo(idx).value()); |
|
293 else |
|
294 xml = generateInterfaceXml(mo, flags, base->methodCount(), base->propertyCount()); |
|
295 |
|
296 if (xml.isEmpty()) |
|
297 return QString(); // don't add an empty interface |
|
298 return QString::fromLatin1(" <interface name=\"%1\">\n%2 </interface>\n") |
|
299 .arg(interface, xml); |
|
300 } |
|
301 |
|
302 #endif |
|
303 |
|
304 QT_END_NAMESPACE |