WaylandEnum readEnum(QXmlStreamReader &xml)
{
WaylandEnum result;
result.name = byteArrayValue(xml, "name");
while (xml.readNextStartElement()) {
if (xml.name() == "entry") {
WaylandEnumEntry entry;
entry.name = byteArrayValue(xml, "name");
entry.value = byteArrayValue(xml, "value");
entry.summary = byteArrayValue(xml, "summary");
result.entries << entry;
}
xml.skipCurrentElement();
}
return result;
}
WaylandEvent readEvent(QXmlStreamReader &xml, bool request)
{
WaylandEvent event;
event.request = request;
event.name = byteArrayValue(xml, "name");
while (xml.readNextStartElement()) {
if (xml.name() == "arg") {
WaylandArgument argument;
argument.name = byteArrayValue(xml, "name");
argument.type = byteArrayValue(xml, "type");
argument.interface = byteArrayValue(xml, "interface");
argument.summary = byteArrayValue(xml, "summary");
argument.allowNull = boolValue(xml, "allowNull");
event.arguments << argument;
}
xml.skipCurrentElement();
}
return event;
}
WaylandInterface readInterface(QXmlStreamReader &xml)
{
WaylandInterface interface;
interface.name = byteArrayValue(xml, "name");
interface.version = intValue(xml, "version", 1);
while (xml.readNextStartElement()) {
if (xml.name() == "event")
interface.events << readEvent(xml, false);
else if (xml.name() == "request")
interface.requests << readEvent(xml, true);
else if (xml.name() == "enum")
interface.enums << readEnum(xml);
else
xml.skipCurrentElement();
}
return interface;
}
void process(QXmlStreamReader &xml, const QByteArray &headerPath, const QByteArray &prefix)
{
if (!xml.readNextStartElement())
return;
if (xml.name() != "protocol") {
xml.raiseError(QStringLiteral("The file is not a wayland protocol file."));
return;
}
protocolName = byteArrayValue(xml, "name");
if (protocolName.isEmpty()) {
xml.raiseError(QStringLiteral("Missing protocol name."));
return;
}
//We should convert - to _ so that the preprocessor wont generate code which will lead to unexpected behavior
//However, the wayland-scanner doesn't do so we will do the same for now
//QByteArray preProcessorProtocolName = QByteArray(protocolName).replace('-', '_').toUpper();
QByteArray preProcessorProtocolName = QByteArray(protocolName).toUpper();
QList<WaylandInterface> interfaces;
while (xml.readNextStartElement()) {
if (xml.name() == "interface")
interfaces << readInterface(xml);
else
xml.skipCurrentElement();
}
if (xml.hasError())
return;
if (option == ServerHeader) {
QByteArray inclusionGuard = QByteArray("QT_WAYLAND_SERVER_") + preProcessorProtocolName.constData();
printf("#ifndef %s\n", inclusionGuard.constData());
printf("#define %s\n", inclusionGuard.constData());
printf("\n");
printf("#include \"wayland-server.h\"\n");
if (headerPath.isEmpty())
printf("#include \"wayland-%s-server-protocol.h\"\n", QByteArray(protocolName).replace('_', '-').constData());
else
printf("#include <%s/wayland-%s-server-protocol.h>\n", headerPath.constData(), QByteArray(protocolName).replace('_', '-').constData());
printf("#include <QByteArray>\n");
printf("#include <QMultiMap>\n");
printf("#include <QString>\n");
printf("\n");
printf("#ifndef WAYLAND_VERSION_CHECK\n");
printf("#define WAYLAND_VERSION_CHECK(major, minor, micro) \\\n");
printf(" ((WAYLAND_VERSION_MAJOR > (major)) || \\\n");
printf(" (WAYLAND_VERSION_MAJOR == (major) && WAYLAND_VERSION_MINOR > (minor)) || \\\n");
printf(" (WAYLAND_VERSION_MAJOR == (major) && WAYLAND_VERSION_MINOR == (minor) && WAYLAND_VERSION_MICRO >= (micro)))\n");
printf("#endif\n");
printf("\n");
printf("QT_BEGIN_NAMESPACE\n");
QByteArray serverExport;
if (headerPath.size()) {
serverExport = QByteArray("Q_WAYLAND_SERVER_") + preProcessorProtocolName + "_EXPORT";
printf("\n");
printf("#if !defined(%s)\n", serverExport.constData());
printf("# if defined(QT_SHARED)\n");
printf("# define %s Q_DECL_EXPORT\n", serverExport.constData());
printf("# else\n");
printf("# define %s\n", serverExport.constData());
printf("# endif\n");
printf("#endif\n");
}
printf("\n");
printf("namespace QtWaylandServer {\n");
for (int j = 0; j < interfaces.size(); ++j) {
const WaylandInterface &interface = interfaces.at(j);
if (ignoreInterface(interface.name))
continue;
const char *interfaceName = interface.name.constData();
QByteArray stripped = stripInterfaceName(interface.name, prefix);
const char *interfaceNameStripped = stripped.constData();
printf(" class %s %s\n {\n", serverExport.constData(), interfaceName);
printf(" public:\n");
printf(" %s(struct ::wl_client *client, int id, int version);\n", interfaceName);
printf(" %s(struct ::wl_display *display, int version);\n", interfaceName);
printf(" %s();\n", interfaceName);
printf("\n");
printf(" virtual ~%s();\n", interfaceName);
printf("\n");
printf(" class Resource\n");
printf(" {\n");
printf(" public:\n");
printf(" Resource() : %s_object(0), handle(0) {}\n", interfaceNameStripped);
printf(" virtual ~Resource() {}\n");
printf("\n");
printf(" %s *%s_object;\n", interfaceName, interfaceNameStripped);
printf(" struct ::wl_resource *handle;\n");
printf("\n");
printf(" struct ::wl_client *client() const { return handle->client; }\n");
printf(" int version() const { return wl_resource_get_version(handle); }\n");
printf("\n");
printf(" static Resource *fromResource(struct ::wl_resource *resource) { return static_cast<Resource *>(resource->data); }\n");
printf(" };\n");
printf("\n");
printf(" void init(struct ::wl_client *client, int id, int version);\n");
printf(" void init(struct ::wl_display *display, int version);\n");
printf("\n");
printf(" Resource *add(struct ::wl_client *client, int version);\n");
printf(" Resource *add(struct ::wl_client *client, int id, int version);\n");
printf(" Resource *add(struct wl_list *resource_list, struct ::wl_client *client, int id, int version);\n");
printf("\n");
printf(" Resource *resource() { return m_resource; }\n");
printf(" const Resource *resource() const { return m_resource; }\n");
printf("\n");
printf(" QMultiMap<struct ::wl_client*, Resource*> resourceMap() { return m_resource_map; }\n");
printf(" const QMultiMap<struct ::wl_client*, Resource*> resourceMap() const { return m_resource_map; }\n");
printf("\n");
printf(" bool isGlobal() const { return m_global != 0; }\n");
printf(" bool isResource() const { return m_resource != 0; }\n");
printEnums(interface.enums);
bool hasEvents = !interface.events.isEmpty();
if (hasEvents) {
printf("\n");
foreach (const WaylandEvent &e, interface.events) {
printf(" void send_");
printEvent(e);
printf(";\n");
printf(" void send_");
printEvent(e, false, true);
printf(";\n");
}
}
printf("\n");
printf(" protected:\n");
printf(" virtual Resource *%s_allocate();\n", interfaceNameStripped);
printf("\n");
printf(" virtual void %s_bind_resource(Resource *resource);\n", interfaceNameStripped);
printf(" virtual void %s_destroy_resource(Resource *resource);\n", interfaceNameStripped);
bool hasRequests = !interface.requests.isEmpty();
if (hasRequests) {
printf("\n");
foreach (const WaylandEvent &e, interface.requests) {
printf(" virtual void %s_", interfaceNameStripped);
printEvent(e);
printf(";\n");
}
}
printf("\n");
printf(" private:\n");
printf(" static void bind_func(struct ::wl_client *client, void *data, uint32_t version, uint32_t id);\n");
printf(" static void destroy_func(struct ::wl_resource *client_resource);\n");
printf("\n");
printf(" Resource *bind(struct ::wl_client *client, uint32_t id, int version);\n");
if (hasRequests) {
printf("\n");
printf(" static const struct ::%s_interface m_%s_interface;\n", interfaceName, interfaceName);
printf("\n");
for (int i = 0; i < interface.requests.size(); ++i) {
const WaylandEvent &e = interface.requests.at(i);
printf(" static void ");
printEventHandlerSignature(e, interfaceName);
printf(";\n");
}
}
printf("\n");
printf(" QMultiMap<struct ::wl_client*, Resource*> m_resource_map;\n");
printf(" Resource *m_resource;\n");
printf(" struct ::wl_global *m_global;\n");
printf(" uint32_t m_globalVersion;\n");
printf(" };\n");
if (j < interfaces.size() - 1)
printf("\n");
}
printf("}\n");
printf("\n");
printf("QT_END_NAMESPACE\n");
printf("\n");
printf("#endif\n");
}
bool boolValue(const QXmlStreamReader &xml, const char *name)
{
return byteArrayValue(xml, name) == "true";
}
int intValue(const QXmlStreamReader &xml, const char *name, int defaultValue = 0)
{
bool ok;
int result = byteArrayValue(xml, name).toInt(&ok);
return ok ? result : defaultValue;
}
QList<XQCentralRepositorySettingsKey> XQCentralRepositoryUtilsPrivate::findKeys(const XQCentralRepositorySearchCriteria& criteria)
{
long int repositoryUid = criteria.repositoryUid();
CCentralRepositoryHandler* handler = m_settingsManagerPrivate.cenRepHandlerInstance(repositoryUid);
if (!handler)
{
m_settingsManagerPrivate.iError = XQSettingsManager::UnknownError;
return QList<XQCentralRepositorySettingsKey>();
}
QList<XQCentralRepositorySettingsKey> keys;
TRAP(m_settingsManagerPrivate.iError,
RArray<TUint32> foundKeys;
CleanupClosePushL(foundKeys);
if (criteria.value().isNull())
{
User::LeaveIfError(handler->findKeyL(criteria.partialKey(), criteria.bitMask(),
foundKeys));
}
else
{
switch (criteria.value().type())
{
case QVariant::Int:
{
User::LeaveIfError(handler->findKeyL(criteria.partialKey(), criteria.bitMask(),
criteria.value().toInt(), criteria.negativeCriteria(), foundKeys));
break;
}
case QVariant::Double:
{
User::LeaveIfError(handler->findKeyL(criteria.partialKey(), criteria.bitMask(),
criteria.value().toDouble(), criteria.negativeCriteria(), foundKeys));
break;
}
case QVariant::String:
{
TPtrC16 stringValue(reinterpret_cast<const TUint16*>(criteria.value().toString().utf16()));
User::LeaveIfError(handler->findKeyL(criteria.partialKey(), criteria.bitMask(),
stringValue, criteria.negativeCriteria(), foundKeys));
break;
}
case QVariant::ByteArray:
{
TPtrC8 byteArrayValue((TUint8*)(criteria.value().toByteArray().constData()));
User::LeaveIfError(handler->findKeyL(criteria.partialKey(), criteria.bitMask(),
byteArrayValue, criteria.negativeCriteria(), foundKeys));
break;
}
default:
{
User::Leave(KErrArgument);
break;
}
}
}
for (int i = 0; i < foundKeys.Count(); ++i)
{
XQCentralRepositorySettingsKey key(repositoryUid, foundKeys[i]);
keys.append(key);
}
CleanupStack::PopAndDestroy(&foundKeys);
)
return keys;
