Merge lp:~nick-dedekind/libdbusmenu-qt/qpaexporter into lp:libdbusmenu-qt

[Nick Dedekind]

Added exporter support for Qt platform menus.
Exported dbus interface for com.canonical.dbusmenu for use in unity8.

[lp:~nick-dedekind/libdbusmenu-qt/qpaexporter]

276. By Nick Dedekind on 2015-03-18

reverted dbus xml

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:276
http://jenkins.qa.ubuntu.com/job/libdbusmenu-qt-ci/19/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/libdbusmenu-qt-vivid-amd64-ci/2/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/libdbusmenu-qt-vivid-armhf-ci/2/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/libdbusmenu-qt-ci/19/rebuild

review: Needs Fixing (continuous-integration)

Unmerged revisions

276. By Nick Dedekind on 2015-03-18

reverted dbus xml

275. By Nick Dedekind on 2015-03-18

fixed addMenu

274. By Nick Dedekind on 2015-03-18

added exported platformmenu test

273. By Nick Dedekind on 2015-03-05

merged with test branch

272. By Nick Dedekind on 2015-03-05

parent of exporter

271. By Nick Dedekind on 2015-03-05

logging & version bump

270. By Nick Dedekind on 2015-03-04

added dbusmenuinterface + reworked dbus properties

269. By Nick Dedekind on 2015-02-23

more qpa exporter

268. By Nick Dedekind on 2015-02-10

app menu qpa exporter

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-03-18 11:19:06 +0000
+++ CMakeLists.txt	2015-03-18 11:19:06 +0000
@@ -34,12 +34,22 @@
     endif()
 endif()
 
+find_package(PkgConfig)
 # Detect for which Qt version we're building
 if (USE_QT5)
+    find_package(Qt5Core REQUIRED)
     find_package(Qt5Widgets REQUIRED)
     find_package(Qt5DBus REQUIRED)
-    include_directories(${Qt5Widgets_INCLUDE_DIRS} ${Qt5DBus_INCLUDE_DIRS})
-    find_package(Qt5Core REQUIRED)
+    find_package(Qt5Gui REQUIRED)
+    pkg_check_modules(DBUS_CPP dbus-cpp REQUIRED)
+
+    include_directories(
+        ${Qt5Widgets_INCLUDE_DIRS}
+        ${Qt5DBus_INCLUDE_DIRS}
+        ${Qt5DBus_PRIVATE_INCLUDE_DIRS}
+        ${Qt5Gui_PRIVATE_INCLUDE_DIRS}
+        ${DBUS_CPP_INCLUDE_DIRS}
+    )
     set(CMAKE_AUTOMOC ON)
     set(CMAKE_AUTOMOC_RELAXED_MODE ON)
     set(CMAKE_POSITION_INDEPENDENT_CODE ON)

=== modified file 'Doxyfile.in'
--- Doxyfile.in	2011-03-24 15:04:52 +0000
+++ Doxyfile.in	2015-03-18 11:19:06 +0000
@@ -232,7 +232,7 @@
 SEARCH_INCLUDES        = YES
 INCLUDE_PATH           =
 INCLUDE_FILE_PATTERNS  =
-PREDEFINED             =
+PREDEFINED             = DOXYGEN_SHOULD_SKIP_THIS
 EXPAND_AS_DEFINED      =
 SKIP_FUNCTION_MACROS   = YES
 #---------------------------------------------------------------------------

=== modified file 'debian/changelog'
--- debian/changelog	2014-06-19 09:07:18 +0000
+++ debian/changelog	2015-03-18 11:19:06 +0000
@@ -1,3 +1,10 @@
+libdbusmenu-qt (0.9.4) UNRELEASED; urgency=medium
+
+  [ Nick Dedekind ]
+  * Added exported qpa platform menu & dbusmenu interface
+
+ -- Nick Dedekind <[e-mail]>  Thu, 05 Mar 2015 13:39:12 +0000
+
 libdbusmenu-qt (0.9.3+14.10.20140619-0ubuntu1) utopic; urgency=low
 
   [ Aurélien Gâteau ]

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2015-03-18 11:19:06 +0000
+++ src/CMakeLists.txt	2015-03-18 11:19:06 +0000
@@ -1,34 +1,20 @@
 include(CheckCXXSourceCompiles)
 
-check_cxx_compiler_flag(-Wall __DBUSMENU_HAVE_W_ALL)
-if (__DBUSMENU_HAVE_W_ALL)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
-endif (__DBUSMENU_HAVE_W_ALL)
-
 # Check some compiler flags
-check_cxx_compiler_flag(-fvisibility=hidden __DBUSMENU_HAVE_GCC_VISIBILITY)
-if (__DBUSMENU_HAVE_GCC_VISIBILITY AND NOT WIN32)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden")
-endif (__DBUSMENU_HAVE_GCC_VISIBILITY AND NOT WIN32)
-
-check_cxx_compiler_flag(-Woverloaded-virtual __DBUSMENU_HAVE_W_OVERLOADED_VIRTUAL)
-if (__DBUSMENU_HAVE_W_OVERLOADED_VIRTUAL)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Woverloaded-virtual")
-endif (__DBUSMENU_HAVE_W_OVERLOADED_VIRTUAL)
-
 check_cxx_compiler_flag(-Wall __DBUSMENU_HAVE_W_ALL)
 if (__DBUSMENU_HAVE_W_ALL)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
 endif (__DBUSMENU_HAVE_W_ALL)
 
-check_cxx_compiler_flag(-std=c++11 __DBUSMENU_HAVE_CXX11)
-if (__DBUSMENU_HAVE_CXX11)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
-endif (__DBUSMENU_HAVE_CXX11)
+# Find the dbusxml2cpp tool
+if(DEFINED ENV{DEB_BUILD_MULTIARCH})
+  set(QDBUSXML2CPP_EXECUTABLE "/usr/lib/$ENV{DEB_BUILD_MULTIARCH}/qt5/bin/qdbusxml2cpp")
+else()
+  FIND_PROGRAM(QDBUSXML2CPP_EXECUTABLE qdbusxml2cpp)
+endif()
 
 # Check whether QIcon::name() exists. It was added in late Qt 4.7 cycle, and is
 # not present in betas.
-
 if (NOT USE_QT5)
     set(CMAKE_REQUIRED_INCLUDES "${QT_INCLUDE_DIR}")
     set(CMAKE_REQUIRED_LIBRARIES "${QT_QTGUI_LIBRARIES};${QT_QTCORE_LIBRARIES}")
@@ -49,34 +35,55 @@
 endif()
 configure_file(dbusmenu_config.h.in ${CMAKE_CURRENT_BINARY_DIR}/dbusmenu_config.h @ONLY)
 
+include_directories(
+    ${CMAKE_SOURCE_DIR}/src
+    ${CMAKE_BINARY_DIR}/src
+    )
+
 set(dbusmenu_qt_SRCS
     dbusmenu_p.cpp
     dbusmenuexporter.cpp
     dbusmenuexporterdbus_p.cpp
+    dbusmenuexporterdbusinterface_p.cpp
     dbusmenuimporter.cpp
-    dbusmenutypes_p.cpp
+    dbusmenuinterface.cpp
+    dbusmenutypes.cpp
     dbusmenushortcut_p.cpp
     utils.cpp
-    )
-
-include_directories(
-    ${CMAKE_SOURCE_DIR}/src
-    ${CMAKE_BINARY_DIR}/src
+    dbusmenuproperty.h
+    ${CMAKE_BINARY_DIR}/src/dbusmenuinterface_p.cpp
     )
 
 if (NOT USE_QT5)
     qt4_automoc(${dbusmenu_qt_SRCS})
     qt4_add_dbus_adaptor(dbusmenu_qt_SRCS
         ${CMAKE_CURRENT_SOURCE_DIR}/com.canonical.dbusmenu.xml
-        ${CMAKE_CURRENT_SOURCE_DIR}/dbusmenuexporterdbus_p.h DBusMenuExporterDBus
+        ${CMAKE_CURRENT_SOURCE_DIR}/dbusmenuexporterdbusinterface_p.h DBusMenuExporterDBusInterface
         )
 else()
+    set(dbusmenu_qt_SRCS
+        ${dbusmenu_qt_SRCS}
+        qpa/exportedplatformmenubar.cpp
+        qpa/exportedplatformmenubar_p.cpp
+        qpa/qpadbusmenuexporter_p.cpp
+    )
+
     qt5_add_dbus_adaptor(dbusmenu_qt_SRCS
         ${CMAKE_CURRENT_SOURCE_DIR}/com.canonical.dbusmenu.xml
-        ${CMAKE_CURRENT_SOURCE_DIR}/dbusmenuexporterdbus_p.h DBusMenuExporterDBus
+        ${CMAKE_CURRENT_SOURCE_DIR}/dbusmenuexporterdbusinterface_p.h DBusMenuExporterDBusInterface
         )
 endif()
 
+if(${CMAKE_CURRENT_SOURCE_DIR}/com.canonical.dbusmenu.xml IS_NEWER_THAN ${CMAKE_CURRENT_BINARY_DIR}/dbusmenuinterface.h)
+    execute_process(COMMAND ${QDBUSXML2CPP_EXECUTABLE}
+                            -c DbusMenuInterfacePrivate
+                            -p ${CMAKE_CURRENT_BINARY_DIR}/dbusmenuinterface_p
+                            -i "${CMAKE_SOURCE_DIR}/src/dbusmenutypes.h"
+                            ${CMAKE_CURRENT_SOURCE_DIR}/com.canonical.dbusmenu.xml
+                            com.canonical.dbusmenu
+    )
+endif()
+
 configure_file(dbusmenu_version.h.in
     ${CMAKE_CURRENT_BINARY_DIR}/dbusmenu_version.h
     )

=== modified file 'src/dbusmenuexporter.cpp'
--- src/dbusmenuexporter.cpp	2012-10-24 14:43:10 +0000
+++ src/dbusmenuexporter.cpp	2015-03-18 11:19:06 +0000
@@ -35,7 +35,7 @@
 #include "dbusmenu_p.h"
 #include "dbusmenuexporterdbus_p.h"
 #include "dbusmenuexporterprivate_p.h"
-#include "dbusmenutypes_p.h"
+#include "dbusmenutypes.h"
 #include "dbusmenushortcut_p.h"
 #include "debug_p.h"
 #include "utils_p.h"
@@ -94,7 +94,7 @@
     QAction *action = button->defaultAction();
     DMRETURN_VALUE_IF_FAIL(action, map);
 
-    map.insert("label", swapMnemonicChar(action->text(), '&', '_'));
+    map.insert("label", Utils::swapMnemonicChar(action->text(), '&', '_'));
     insertIconProperty(&map, action);
     if (!action->isVisible()) {
         map.insert("visible", false);
@@ -115,7 +115,7 @@
 QVariantMap DBusMenuExporterPrivate::propertiesForStandardAction(QAction *action) const
 {
     QVariantMap map;
-    map.insert("label", swapMnemonicChar(action->text(), '&', '_'));
+    map.insert("label", Utils::swapMnemonicChar(action->text(), '&', '_'));
     if (!action->isEnabled()) {
         map.insert("enabled", false);
     }
@@ -338,7 +338,7 @@
     d->m_emittedLayoutUpdatedOnce = false;
     d->m_itemUpdatedTimer = new QTimer(this);
     d->m_layoutUpdatedTimer = new QTimer(this);
-    d->m_dbusObject = new DBusMenuExporterDBus(this);
+    d->m_dbusObject = new DBusMenuExporterDBus(objectPath, this);
 
     d->addMenu(d->m_rootMenu, 0);
 
@@ -379,33 +379,7 @@
         QVariantMap  updatedProperties;
         QStringList  removedProperties;
 
-        // Find updated and removed properties
-        QVariantMap::ConstIterator newEnd = newProperties.constEnd();
-
-        QVariantMap::ConstIterator
-            oldIt = oldProperties.constBegin(),
-            oldEnd = oldProperties.constEnd();
-        for(; oldIt != oldEnd; ++oldIt) {
-            QString key = oldIt.key();
-            QVariantMap::ConstIterator newIt = newProperties.constFind(key);
-            if (newIt != newEnd) {
-                if (newIt.value() != oldIt.value()) {
-                    updatedProperties.insert(key, newIt.value());
-                }
-            } else {
-                removedProperties << key;
-            }
-        }
-
-        // Find new properties (treat them as updated properties)
-        QVariantMap::ConstIterator newIt = newProperties.constBegin();
-        for (; newIt != newEnd; ++newIt) {
-            QString key = newIt.key();
-            oldIt = oldProperties.constFind(key);
-            if (oldIt == oldEnd) {
-                updatedProperties.insert(key, newIt.value());
-            }
-        }
+        Utils::parsePropertyChanges(oldProperties, newProperties, updatedProperties, removedProperties);
 
         // Update our data (oldProperties is a reference)
         oldProperties = newProperties;

=== modified file 'src/dbusmenuexporterdbus_p.cpp'
--- src/dbusmenuexporterdbus_p.cpp	2011-08-29 14:51:01 +0000
+++ src/dbusmenuexporterdbus_p.cpp	2015-03-18 11:19:06 +0000
@@ -21,26 +21,19 @@
 #include "dbusmenuexporterdbus_p.h"
 
 // Qt
-#include <QDBusMessage>
+#include <QEvent>
 #include <QMenu>
 #include <QVariant>
 
 // Local
-#include "dbusmenuadaptor.h"
 #include "dbusmenuexporterprivate_p.h"
 #include "dbusmenushortcut_p.h"
 #include "debug_p.h"
 
-static const char *DBUSMENU_INTERFACE = "com.canonical.dbusmenu";
-static const char *FDO_PROPERTIES_INTERFACE = "org.freedesktop.DBus.Properties";
-
-DBusMenuExporterDBus::DBusMenuExporterDBus(DBusMenuExporter *exporter)
-: QObject(exporter)
-, m_exporter(exporter)
-, m_status("normal")
+DBusMenuExporterDBus::DBusMenuExporterDBus(const QString& objectPath, DBusMenuExporter *exporter)
+    : DBusMenuExporterDBusInterface(objectPath, exporter)
+    , m_exporter(exporter)
 {
-    DBusMenuTypes_register();
-    new DbusmenuAdaptor(this);
 }
 
 uint DBusMenuExporterDBus::GetLayout(int parentId, int recursionDepth, const QStringList &propertyNames, DBusMenuLayoutItem &item)
@@ -157,30 +150,5 @@
     return filter.mChanged;
 }
 
-void DBusMenuExporterDBus::setStatus(const QString& status)
-{
-    if (m_status == status) {
-        return;
-    }
-    m_status = status;
-
-    QVariantMap map;
-    map.insert("Status", QVariant(status));
-
-    QDBusMessage msg = QDBusMessage::createSignal(m_exporter->d->m_objectPath, FDO_PROPERTIES_INTERFACE, "PropertiesChanged");
-    QVariantList args = QVariantList()
-        << DBUSMENU_INTERFACE
-        << map
-        << QStringList() // New properties: none
-        ;
-    msg.setArguments(args);
-    QDBusConnection::sessionBus().send(msg);
-}
-
-QString DBusMenuExporterDBus::status() const
-{
-    return m_status;
-}
-
 
 #include "dbusmenuexporterdbus_p.moc"

=== modified file 'src/dbusmenuexporterdbus_p.h'
--- src/dbusmenuexporterdbus_p.h	2011-08-29 14:51:01 +0000
+++ src/dbusmenuexporterdbus_p.h	2015-03-18 11:19:06 +0000
@@ -22,50 +22,26 @@
 #define DBUSMENUEXPORTERDBUS_P_H
 
 // Local
-#include <dbusmenutypes_p.h>
-
-// Qt
-#include <QtCore/QObject>
-#include <QtCore/QVariant>
-#include <QtDBus/QDBusAbstractAdaptor>
-#include <QtDBus/QDBusVariant>
+#include "dbusmenuexporterdbusinterface_p.h"
 
 class DBusMenuExporter;
 
-/**
- * Internal class implementing the DBus side of DBusMenuExporter
- * This avoid exposing the implementation of the DBusMenu spec to the outside
- * world.
- */
-class DBusMenuExporterDBus : public QObject
+class DBusMenuExporterDBus : public DBusMenuExporterDBusInterface
 {
     Q_OBJECT
     Q_CLASSINFO("D-Bus Interface", "com.canonical.dbusmenu")
-    Q_PROPERTY(uint Version READ Version)
-    Q_PROPERTY(QString Status READ status)
 public:
-    DBusMenuExporterDBus(DBusMenuExporter *m_exporter);
-
-    uint Version() const { return 2; }
-
-    QString status() const;
-    void setStatus(const QString &status);
-
-public Q_SLOTS:
-    Q_NOREPLY void Event(int id, const QString &eventId, const QDBusVariant &data, uint timestamp);
-    QDBusVariant GetProperty(int id, const QString &property);
-    uint GetLayout(int parentId, int recursionDepth, const QStringList &propertyNames, DBusMenuLayoutItem &item);
-    DBusMenuItemList GetGroupProperties(const QList<int> &ids, const QStringList &propertyNames);
-    bool AboutToShow(int id);
-
-Q_SIGNALS:
-    void ItemsPropertiesUpdated(DBusMenuItemList, DBusMenuItemKeysList);
-    void LayoutUpdated(uint revision, int parentId);
-    void ItemActivationRequested(int id, uint timeStamp);
+    DBusMenuExporterDBus(const QString& objectPath, DBusMenuExporter *m_exporter);
+
+public: // overrides
+    void Event(int id, const QString &eventId, const QDBusVariant &data, uint timestamp) override;
+    QDBusVariant GetProperty(int id, const QString &property) override;
+    uint GetLayout(int parentId, int recursionDepth, const QStringList &propertyNames, DBusMenuLayoutItem &item) override;
+    DBusMenuItemList GetGroupProperties(const QList<int> &ids, const QStringList &propertyNames) override;
+    bool AboutToShow(int id) override;
 
 private:
     DBusMenuExporter *m_exporter;
-    QString m_status;
 
     friend class DBusMenuExporter;
     friend class DBusMenuExporterPrivate;

=== added file 'src/dbusmenuexporterdbusinterface_p.cpp'
--- src/dbusmenuexporterdbusinterface_p.cpp	1970-01-01 00:00:00 +0000
+++ src/dbusmenuexporterdbusinterface_p.cpp	2015-03-18 11:19:06 +0000
@@ -0,0 +1,67 @@
+/* This file is part of the dbusmenu-qt library
+   Copyright 2015 Canonical
+   Author: Nick Dedekind <[e-mail]>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License (LGPL) as published by the Free Software Foundation;
+   either version 2 of the License, or (at your option) any later
+   version.
+
+   This library 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
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this library; see the file COPYING.LIB.  If not, write to
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.
+*/
+
+#include "dbusmenuexporterdbusinterface_p.h"
+#include "dbusmenuadaptor.h"
+
+// Qt
+#include <QDBusMessage>
+#include <QEvent>
+
+static const char *DBUSMENU_INTERFACE = "com.canonical.dbusmenu";
+static const char *FDO_PROPERTIES_INTERFACE = "org.freedesktop.DBus.Properties";
+
+DBusMenuExporterDBusInterface::DBusMenuExporterDBusInterface(const QString& objectPath, QObject *parent)
+    : QObject(parent)
+    , m_objectPath(objectPath)
+    , m_status("normal")
+{
+    DBusMenuTypes_register();
+
+    new DbusmenuAdaptor(this);
+    QDBusConnection::sessionBus().registerObject(objectPath, this, QDBusConnection::ExportAllContents);
+}
+
+QString DBusMenuExporterDBusInterface::status() const
+{
+    return m_status;
+}
+
+void DBusMenuExporterDBusInterface::setStatus(const QString& status)
+{
+    if (m_status == status) {
+        return;
+    }
+    m_status = status;
+
+    QVariantMap map;
+    map.insert("Status", QVariant(status));
+
+    QDBusMessage msg = QDBusMessage::createSignal(m_objectPath, FDO_PROPERTIES_INTERFACE, "PropertiesChanged");
+    QVariantList args = QVariantList()
+        << DBUSMENU_INTERFACE
+        << map
+        << QStringList() // New properties: none
+        ;
+    msg.setArguments(args);
+    QDBusConnection::sessionBus().send(msg);
+}
+

=== added file 'src/dbusmenuexporterdbusinterface_p.h'
--- src/dbusmenuexporterdbusinterface_p.h	1970-01-01 00:00:00 +0000
+++ src/dbusmenuexporterdbusinterface_p.h	2015-03-18 11:19:06 +0000
@@ -0,0 +1,80 @@
+/* This file is part of the dbusmenu-qt library
+   Copyright 2015 Canonical
+   Author: Nick Dedekind <[e-mail]>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License (LGPL) as published by the Free Software Foundation;
+   either version 2 of the License, or (at your option) any later
+   version.
+
+   This library 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
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this library; see the file COPYING.LIB.  If not, write to
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.
+*/
+#ifndef DBUSMENUEXPORTERDBUSINTERFACE_P_H
+#define DBUSMENUEXPORTERDBUSINTERFACE_P_H
+
+// Local
+#include <dbusmenutypes.h>
+
+// Qt
+#include <QtCore/QObject>
+#include <QtCore/QVariant>
+#include <QtDBus/QDBusAbstractAdaptor>
+#include <QtDBus/QDBusVariant>
+
+/**
+ * Internal class implementing the DBus side of DBusMenuExporter
+ * This avoid exposing the implementation of the DBusMenu spec to the outside
+ * world.
+ */
+class DBusMenuExporterDBusInterface : public QObject
+{
+    Q_OBJECT
+    Q_CLASSINFO("D-Bus Interface", "com.canonical.dbusmenu")
+    Q_PROPERTY(uint Version READ Version)
+    Q_PROPERTY(QString Status READ status)
+public:
+    DBusMenuExporterDBusInterface(const QString& objectPath, QObject* parent = nullptr);
+    uint Version() const { return 2; }
+
+    /**
+     * The status of the menu. Can be one of "normal" or "notice". This can be
+     * used to notify the other side the menu should be made more visible.
+     * For example, appmenu uses it to tell Unity panel to show/hide the menubar
+     * when the Alt modifier is pressed/released.
+     */
+    QString status() const;
+
+    /**
+     * Returns the status of the menu.
+     * @ref setStatus
+     */
+    void setStatus(const QString &status);
+
+public Q_SLOTS:
+    virtual Q_NOREPLY void Event(int id, const QString &eventId, const QDBusVariant &data, uint timestamp) = 0;
+    virtual QDBusVariant GetProperty(int id, const QString &property) = 0;
+    virtual uint GetLayout(int parentId, int recursionDepth, const QStringList &propertyNames, DBusMenuLayoutItem &item) = 0;
+    virtual DBusMenuItemList GetGroupProperties(const QList<int> &ids, const QStringList &propertyNames) = 0;
+    virtual bool AboutToShow(int id) = 0;
+
+Q_SIGNALS:
+    void ItemsPropertiesUpdated(DBusMenuItemList, DBusMenuItemKeysList);
+    void LayoutUpdated(uint revision, int parentId);
+    void ItemActivationRequested(int id, uint timeStamp);
+
+private:
+    QString m_objectPath;
+    QString m_status;
+};
+
+
+#endif // DBUSMENUEXPORTERDBUSINTERFACE_P_H

=== modified file 'src/dbusmenuexporterprivate_p.h'
--- src/dbusmenuexporterprivate_p.h	2012-03-29 14:23:32 +0000
+++ src/dbusmenuexporterprivate_p.h	2015-03-18 11:19:06 +0000
@@ -23,7 +23,7 @@
 
 // Local
 #include "dbusmenuexporter.h"
-#include "dbusmenutypes_p.h"
+#include "dbusmenutypes.h"
 
 // Qt
 #include <QtCore/QHash>

=== modified file 'src/dbusmenuimporter.cpp'
--- src/dbusmenuimporter.cpp	2014-03-05 09:53:39 +0000
+++ src/dbusmenuimporter.cpp	2015-03-18 11:19:06 +0000
@@ -36,7 +36,7 @@
 #include <QWidgetAction>
 
 // Local
-#include "dbusmenutypes_p.h"
+#include "dbusmenutypes.h"
 #include "dbusmenushortcut_p.h"
 #include "debug_p.h"
 #include "utils_p.h"
@@ -199,7 +199,7 @@
 
     void updateActionLabel(QAction *action, const QVariant &value)
     {
-        QString text = swapMnemonicChar(value.toString(), '_', '&');
+        QString text = Utils::swapMnemonicChar(value.toString(), '_', '&');
         action->setText(text);
     }
 

=== added file 'src/dbusmenuinterface.cpp'
--- src/dbusmenuinterface.cpp	1970-01-01 00:00:00 +0000
+++ src/dbusmenuinterface.cpp	2015-03-18 11:19:06 +0000
@@ -0,0 +1,63 @@
+#include "dbusmenuinterface.h"
+#include "dbusmenuinterface_p.h"
+
+DBusMenuInterface::DBusMenuInterface(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent)
+    : d(new DbusMenuInterfacePrivate(service, path, connection, this))
+{
+    DBusMenuTypes_register();
+}
+
+uint DBusMenuInterface::version() const
+{
+    return d->version();
+}
+
+QString DBusMenuInterface::status() const
+{
+    return d->status();
+}
+
+bool DBusMenuInterface::isValid() const
+{
+    return d->isValid();
+}
+
+QString DBusMenuInterface::service() const
+{
+    return d->service();
+}
+
+QString DBusMenuInterface::path() const
+{
+    return d->path();
+}
+
+QDBusPendingReply<bool> DBusMenuInterface::AboutToShow(int id)
+{
+    return d->AboutToShow(id);
+}
+
+QDBusPendingReply<> DBusMenuInterface::Event(int id, const QString &eventId, const QDBusVariant &data, uint timestamp)
+{
+    return d->Event(id, eventId, data, timestamp);
+}
+
+QDBusPendingReply<DBusMenuItemList> DBusMenuInterface::GetGroupProperties(const QList<int> &ids, const QStringList &propertyNames)
+{
+    return d->GetGroupProperties(ids, propertyNames);
+}
+
+QDBusPendingReply<QDBusVariant> DBusMenuInterface::GetProperty(int id, const QString &name)
+{
+    return d->GetProperty(id, name);
+}
+
+QDBusPendingReply<uint, DBusMenuLayoutItem> DBusMenuInterface::GetLayout(int parentId, int recursionDepth, const QStringList &propertyNames)
+{
+    return d->GetLayout(parentId, recursionDepth, propertyNames);
+}
+
+QDBusReply<uint> DBusMenuInterface::GetLayout(int parentId, int recursionDepth, const QStringList &propertyNames, DBusMenuLayoutItem &layout)
+{
+    return d->GetLayout(parentId, recursionDepth, propertyNames, layout);
+}

=== added file 'src/dbusmenuinterface.h'
--- src/dbusmenuinterface.h	1970-01-01 00:00:00 +0000
+++ src/dbusmenuinterface.h	2015-03-18 11:19:06 +0000
@@ -0,0 +1,154 @@
+/* This file is part of the dbusmenu-qt library
+   Copyright 2015 Canonical
+   Author: Nick Dedekind <[e-mail]>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License (LGPL) as published by the Free Software Foundation;
+   either version 2 of the License, or (at your option) any later
+   version.
+
+   This library 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
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this library; see the file COPYING.LIB.  If not, write to
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.
+*/
+#ifndef DBUSMENUINTERFACE_H
+#define DBUSMENUINTERFACE_H
+
+// Local
+#include <dbusmenutypes.h>
+class DbusMenuInterfacePrivate;
+
+// Qt
+#include <QtCore/QObject>
+#include <QtDBus/QtDBus>
+
+/**
+ * Internal class implementing the DBus side of DBusMenuExporter
+ * This avoid exposing the implementation of the DBusMenu spec to the outside
+ * world.
+ */
+class DBUSMENU_EXPORT DBusMenuInterface : public QObject
+{
+    Q_OBJECT
+
+    /**
+     * Version of the menu interface.
+     */
+    Q_PROPERTY(uint Version READ version)
+
+    /**
+     * Status of the menu.
+     */
+    Q_PROPERTY(QString Status READ status)
+public:
+    /**
+     * Creates a DBusMenuInterface on specified service, path & connection
+     */
+    DBusMenuInterface(const QString &service, const QString &path, const QDBusConnection &connection, QObject* parent = nullptr);
+
+    /**
+     * Returns the version of the menu interface.
+     */
+    uint version() const;
+
+    /**
+     * The status of the menu. Can be one of "normal" or "notice". This can be
+     * used to notify the other side the menu should be made more visible.
+     * For example, appmenu uses it to tell Unity panel to show/hide the menubar
+     * when the Alt modifier is pressed/released.
+     */
+    QString status() const;
+
+    /**
+     * Returns true if this is a valid reference to a remote object.
+     * It returns false if there was an error during the creation of the interface
+     */
+    bool isValid() const;
+
+    /**
+     * Returns the name of the service this interface is associated with.
+     */
+    QString service() const;
+
+    /**
+     * Returns the object path that this interface is associated with.
+     */
+    QString path() const;
+
+public Q_SLOTS:
+    /**
+     * This is called to notify the application that it is about
+     * to show the menu under the specified item.
+     */
+    QDBusPendingReply<bool> AboutToShow(int id);
+
+    /**
+     * This is called by the applet to notify the application an event happened on a
+     * menu item.
+     */
+    QDBusPendingReply<> Event(int id, const QString &eventId, const QDBusVariant &data, uint timestamp);
+
+    /**
+     * Returns the list of items which are children of @p parentId.
+     */
+    QDBusPendingReply<DBusMenuItemList> GetGroupProperties(const QList<int> &ids, const QStringList &propertyNames);
+
+    /**
+     * Get a signal property on a single item.  This is not useful if you're
+     * going to implement this interface, it should only be used if you're
+     * debugging via a commandline tool.
+     */
+    QDBusPendingReply<QDBusVariant> GetProperty(int id, const QString &name);
+
+    /**
+     * Provides the layout and propertiers that are attached to the entries
+     * that are in the layout.  It only gives the items that are children
+     * of the item that is specified in @p parentId.  It will return all of the
+     * properties or specific ones depending of the value in @p propertyNames.
+     */
+    QDBusPendingReply<uint, DBusMenuLayoutItem> GetLayout(int parentId, int recursionDepth, const QStringList &propertyNames);
+
+    /**
+     * Provides the layout and propertiers that are attached to the entries
+     * that are in the layout.  It only gives the items that are children
+     * of the item that is specified in @p parentId.  It will return all of the
+     * properties or specific ones depending of the value @p propertyNames.
+     */
+    QDBusReply<uint> GetLayout(int parentId, int recursionDepth, const QStringList &propertyNames, DBusMenuLayoutItem &layout);
+
+Q_SIGNALS: // SIGNALS
+    /**
+     * The server is requesting that all clients displaying this
+     * menu open it to the user.  This would be for things like
+     * hotkeys that when the user presses them the menu should
+     * open and display itself to the user.
+     */
+    void ItemActivationRequested(int id, uint timestamp);
+
+    /**
+     * Triggered when there are lots of property updates across many items
+     * so they all get grouped into a single dbus message.  The format is
+     * the ID of the item with a hashtable of names and values for those
+     * properties.
+     */
+    void ItemsPropertiesUpdated(DBusMenuItemList updatedProps, DBusMenuItemKeysList removedProps);
+
+    /**
+     * Triggered by the application to notify display of a layout update, up to
+     * revision
+     */
+    void LayoutUpdated(uint revision, int parent);
+
+private:
+    DbusMenuInterfacePrivate* d;
+};
+
+
+#endif // DBUSMENUINTERFACE_H

=== added file 'src/dbusmenuproperty.h'
--- src/dbusmenuproperty.h	1970-01-01 00:00:00 +0000
+++ src/dbusmenuproperty.h	2015-03-18 11:19:06 +0000
@@ -0,0 +1,78 @@
+#ifndef DBUSMENUPROPERTY_H
+#define DBUSMENUPROPERTY_H
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+// Qt
+#include <QtCore/QVariantMap>
+
+// Local
+#include <dbusmenu_export.h>
+
+class QKeySequence;
+class QByteArray;
+class QString;
+
+//// DBusMenuProperty
+/**
+ * Structure which contains the names of the common properties
+ * for a menu item.
+ */
+struct DBUSMENU_EXPORT DBusMenuProperty
+{
+    static const char* Type;
+    static const char* Label;
+    static const char* Enabled;
+    static const char* Visible;
+    static const char* IconName;
+    static const char* IconData;
+    static const char* Shortcut;
+    static const char* ToggleType;
+    static const char* ToggleState;
+    static const char* ChildrenDisplay;
+};
+
+//// DBusMenuProperties
+/**
+ * A map of properties for the dbus with easy accessors for
+ * the common properties
+ */
+struct DBUSMENU_EXPORT DBusMenuProperties: public QVariantMap
+{
+    QString type() const;
+    void setType(const QString&);
+
+    QString label() const;
+    void setLabel(const QString&);
+
+    bool enabled() const;
+    void setEnabled(bool);
+
+    bool visible() const;
+    void setVisible(bool);
+
+    QString iconName() const;
+    void setIconName(const QString&);
+
+    QByteArray iconData() const;
+    void setIconData(const QByteArray&);
+
+    QKeySequence shortcut() const;
+    void setShortcut(const QKeySequence&);
+
+    QString toggleType() const;
+    void setToggleType(const QString&);
+
+    int toggleState() const;
+    void setToggleState(int);
+
+    bool childrenDisplay() const;
+    void setChildrenDisplay(bool);
+
+    DBusMenuProperties& operator=(const QVariantMap& rhs);
+};
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+#endif // DBUSMENUPROPERTY_H

=== modified file 'src/dbusmenushortcut_p.cpp'
--- src/dbusmenushortcut_p.cpp	2011-04-12 09:12:18 +0000
+++ src/dbusmenushortcut_p.cpp	2015-03-18 11:19:06 +0000
@@ -44,6 +44,8 @@
       // cf https://bugs.launchpad.net/libdbusmenu-qt/+bug/712565
       {"+", "plus"},
       {"-", "minus"},
+      {"+", "KP_Add"},
+      {"-", "KP_Subtract"},
       {0, 0}
     };
 

=== renamed file 'src/dbusmenutypes_p.cpp' => 'src/dbusmenutypes.cpp'
--- src/dbusmenutypes_p.cpp	2011-02-23 13:23:56 +0000
+++ src/dbusmenutypes.cpp	2015-03-18 11:19:06 +0000
@@ -18,7 +18,7 @@
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
-#include "dbusmenutypes_p.h"
+#include "dbusmenutypes.h"
 
 // Local
 #include <dbusmenushortcut_p.h>
@@ -27,6 +27,18 @@
 // Qt
 #include <QDBusArgument>
 #include <QDBusMetaType>
+#include <QKeySequence>
+
+const char* DBusMenuProperty::Type = "type";
+const char* DBusMenuProperty::Label = "label";
+const char* DBusMenuProperty::Enabled = "enabled";
+const char* DBusMenuProperty::Visible = "visible";
+const char* DBusMenuProperty::IconName = "icon-name";
+const char* DBusMenuProperty::IconData = "icon-data";
+const char* DBusMenuProperty::Shortcut = "shortcut";
+const char* DBusMenuProperty::ToggleType = "toggle-type";
+const char* DBusMenuProperty::ToggleState = "toggle-state";
+const char* DBusMenuProperty::ChildrenDisplay = "children-display";
 
 //// DBusMenuItem
 QDBusArgument &operator<<(QDBusArgument &argument, const DBusMenuItem &obj)
@@ -95,6 +107,16 @@
     return argument;
 }
 
+bool operator==(const DBusMenuLayoutItem& lhs, const DBusMenuLayoutItem& rhs)
+{
+    return lhs.id == rhs.id && lhs.properties == rhs.properties && lhs.children == rhs.children;
+}
+
+bool operator!=(const DBusMenuLayoutItem& lhs, const DBusMenuLayoutItem& rhs)
+{
+    return !(lhs == rhs);
+}
+
 void DBusMenuTypes_register()
 {
     static bool registered = false;
@@ -110,3 +132,122 @@
     qDBusRegisterMetaType<DBusMenuShortcut>();
     registered = true;
 }
+
+QString DBusMenuProperties::type() const
+{
+    return value(DBusMenuProperty::Type, "standard").toString();
+}
+
+void DBusMenuProperties::setType(const QString &type)
+{
+    insert(DBusMenuProperty::Type, type);
+}
+
+QString DBusMenuProperties::label() const
+{
+    return value(DBusMenuProperty::Label, "").toString();
+}
+
+void DBusMenuProperties::setLabel(const QString &label)
+{
+    insert(DBusMenuProperty::Label, label);
+}
+
+bool DBusMenuProperties::enabled() const
+{
+    return value(DBusMenuProperty::Enabled, true).toBool();
+}
+
+void DBusMenuProperties::setEnabled(bool enabled)
+{
+    insert(DBusMenuProperty::Enabled, enabled);
+}
+
+bool DBusMenuProperties::visible() const
+{
+    return value(DBusMenuProperty::Visible, true).toBool();
+}
+
+void DBusMenuProperties::setVisible(bool enabled)
+{
+    insert(DBusMenuProperty::Visible, enabled);
+}
+
+QString DBusMenuProperties::iconName() const
+{
+    return value(DBusMenuProperty::IconName, "").toString();
+}
+
+void DBusMenuProperties::setIconName(const QString &iconName)
+{
+    insert(DBusMenuProperty::IconName, iconName);
+}
+
+QByteArray DBusMenuProperties::iconData() const
+{
+    return value(DBusMenuProperty::IconData, QVariant()).toByteArray();
+}
+
+void DBusMenuProperties::setIconData(const QByteArray &iconData)
+{
+    insert(DBusMenuProperty::IconData, iconData);
+}
+
+QKeySequence DBusMenuProperties::shortcut() const
+{
+    QKeySequence seq;
+
+    QVariant var = value(DBusMenuProperty::Shortcut, QVariant());
+
+    if (var.userType() == qMetaTypeId<QDBusArgument>()) {
+        QDBusArgument arg = var.value<QDBusArgument>();
+
+        DBusMenuShortcut shortcut;
+        arg >> shortcut;
+
+        return shortcut.toKeySequence();
+    }
+    return seq;
+}
+
+void DBusMenuProperties::setShortcut(const QKeySequence &keySequence)
+{
+    insert(DBusMenuProperty::Shortcut, keySequence);
+}
+
+QString DBusMenuProperties::toggleType() const
+{
+    return value(DBusMenuProperty::ToggleType, "").toString();
+}
+
+void DBusMenuProperties::setToggleType(const QString &toggleType)
+{
+    insert(DBusMenuProperty::ToggleType, toggleType);
+}
+
+int DBusMenuProperties::toggleState() const
+{
+    return value(DBusMenuProperty::ToggleState, -1).toInt();
+}
+
+void DBusMenuProperties::setToggleState(int toggleType)
+{
+    insert(DBusMenuProperty::ToggleState, toggleType);
+}
+
+bool DBusMenuProperties::childrenDisplay() const
+{
+    return value(DBusMenuProperty::ChildrenDisplay, false).toBool();
+}
+
+void DBusMenuProperties::setChildrenDisplay(bool childrenDisplay)
+{
+    insert(DBusMenuProperty::ChildrenDisplay, childrenDisplay);
+
+}
+
+DBusMenuProperties &DBusMenuProperties::operator=(const QVariantMap &rhs)
+{
+    QVariantMap::operator=(rhs);
+    return *this;
+}

=== renamed file 'src/dbusmenutypes_p.h' => 'src/dbusmenutypes.h'
--- src/dbusmenutypes_p.h	2011-02-23 13:23:56 +0000
+++ src/dbusmenutypes.h	2015-03-18 11:19:06 +0000
@@ -18,8 +18,8 @@
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
-#ifndef DBUSMENUTYPES_P_H
-#define DBUSMENUTYPES_P_H
+#ifndef DBUSMENUTYPES_H
+#define DBUSMENUTYPES_H
 
 // Qt
 #include <QtCore/QList>
@@ -28,6 +28,7 @@
 
 // Local
 #include <dbusmenu_export.h>
+#include <dbusmenuproperty.h>
 
 class QDBusArgument;
 
@@ -37,8 +38,11 @@
  */
 struct DBUSMENU_EXPORT DBusMenuItem
 {
+    /// Id of the menu item
     int id;
-    QVariantMap properties;
+
+    /// Properties for the menu item
+    DBusMenuProperties properties;
 };
 
 Q_DECLARE_METATYPE(DBusMenuItem)
@@ -57,7 +61,10 @@
  */
 struct DBUSMENU_EXPORT DBusMenuItemKeys
 {
+    /// Id of the menu item
     int id;
+
+    /// Properties for the menu item
     QStringList properties;
 };
 
@@ -75,11 +82,15 @@
  * Represents an item with its children. GetLayout() returns a
  * DBusMenuLayoutItemList.
  */
-struct DBusMenuLayoutItem;
 struct DBUSMENU_EXPORT DBusMenuLayoutItem
 {
+    /// Id of the menu item
     int id;
-    QVariantMap properties;
+
+    /// Id of the menu item
+    DBusMenuProperties properties;
+
+    /// Children of the menu item
     QList<DBusMenuLayoutItem> children;
 };
 
@@ -88,9 +99,13 @@
 DBUSMENU_EXPORT QDBusArgument &operator<<(QDBusArgument &argument, const DBusMenuLayoutItem &);
 DBUSMENU_EXPORT const QDBusArgument &operator>>(const QDBusArgument &argument, DBusMenuLayoutItem &);
 
+DBUSMENU_EXPORT bool operator==(const DBusMenuLayoutItem& lhs, const DBusMenuLayoutItem& rhs);
+DBUSMENU_EXPORT bool operator!=(const DBusMenuLayoutItem& lhs, const DBusMenuLayoutItem& rhs);
+
 typedef QList<DBusMenuLayoutItem> DBusMenuLayoutItemList;
 
 Q_DECLARE_METATYPE(DBusMenuLayoutItemList)
 
 void DBusMenuTypes_register();
+
 #endif /* DBUSMENUTYPES_P_H */

=== added directory 'src/qpa'
=== added file 'src/qpa/exportedplatformmenubar.cpp'
--- src/qpa/exportedplatformmenubar.cpp	1970-01-01 00:00:00 +0000
+++ src/qpa/exportedplatformmenubar.cpp	2015-03-18 11:19:06 +0000
@@ -0,0 +1,377 @@
+/* This file is part of the dbusmenu-qt library
+   Copyright 2015 Canonical
+   Author: Nick Dedekind <[e-mail]>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License (LGPL) as published by the Free Software Foundation;
+   either version 2 of the License, or (at your option) any later
+   version.
+
+   This library 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
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this library; see the file COPYING.LIB.  If not, write to
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.
+*/
+
+// Local
+#include "exportedplatformmenubar.h"
+#include "exportedplatformmenubar_p.h"
+#include "qpadbusmenuexporter_p.h"
+#include "logging_p.h"
+
+// Qt
+#include <QWindow>
+#include <QWidget>
+
+#define MENU_ID(x) (qobject_cast<ExportedPlatformMenu*>(x) ? qobject_cast<ExportedPlatformMenu*>(x)->id() : -1)
+#define MENU_ITEM_ID(x) (qobject_cast<ExportedPlatformMenuItem*>(x) ? qobject_cast<ExportedPlatformMenuItem*>(x)->id() : -1)
+
+ExportedPlatformMenuBar::ExportedPlatformMenuBar(const QString& exportPath)
+    : d(new ExportedPlatformMenuBarPrivate)
+{
+    LOG;
+
+    d->m_objectPath = exportPath;
+    new QPADBusMenuExporter(exportPath, this);
+}
+
+ExportedPlatformMenuBar::~ExportedPlatformMenuBar()
+{
+    LOG;
+}
+
+QString ExportedPlatformMenuBar::exportedPath() const
+{
+    return d->m_objectPath;
+}
+
+void
+ExportedPlatformMenuBar::insertMenu(QPlatformMenu *menu, QPlatformMenu *before)
+{
+    LOG << MENU_ID(menu) << " before:" << before;
+
+    if (!before) {
+        d->m_menus.push_back(menu);
+    } else {
+        for (auto iter = d->m_menus.begin(); iter != d->m_menus.end(); ++iter) {
+            if (*iter == before) {
+                d->m_menus.insert(iter, menu);
+                break;
+            }
+        }
+    }
+
+    Q_EMIT menuInserted(menu);
+}
+
+void
+ExportedPlatformMenuBar::removeMenu(QPlatformMenu *menu)
+{
+    LOG << menu;
+
+    for (auto iter = d->m_menus.begin(); iter != d->m_menus.end(); ++iter) {
+        if (*iter == menu) {
+            iter = d->m_menus.erase(iter);
+        }
+    }
+
+    Q_EMIT menuRemoved(menu);
+}
+
+void
+ExportedPlatformMenuBar::syncMenu(QPlatformMenu *menu)
+{
+    LOG_VAR(menu);
+    QMetaObject::invokeMethod(menu, "propertyUpdated");
+}
+
+void
+ExportedPlatformMenuBar::handleReparent(QWindow *newParentWindow)
+{
+    LOG_VAR(newParentWindow);
+}
+
+QPlatformMenu *
+ExportedPlatformMenuBar::menuForTag(quintptr tag) const
+{
+    for (auto iter = d->m_menus.begin(); iter != d->m_menus.end(); ++iter) {
+        if ((*iter)->tag() == tag) {
+            return *iter;
+        }
+    }
+    return nullptr;
+}
+
+QPlatformMenu *
+ExportedPlatformMenuBar::menuAt(int position) const
+{
+    if (position < 0 || position >= d->m_menus.count()) return nullptr;
+    return d->m_menus.at(position);
+}
+
+uint ExportedPlatformMenuBar::menuCount()
+{
+    return d->m_menus.count();
+}
+
+//////////////////////////////////////////////////////////////
+
+ExportedPlatformMenu::ExportedPlatformMenu()
+    : QPlatformMenu()
+    , d(new ExportedPlatformMenuPrivate)
+{
+    LOG << id();
+}
+
+ExportedPlatformMenu::~ExportedPlatformMenu()
+{
+    LOG << id();
+}
+
+void ExportedPlatformMenu::insertMenuItem(QPlatformMenuItem *menuItem, QPlatformMenuItem *before)
+{
+    LOG << MENU_ITEM_ID(menuItem) << " before:" << before << " on: " << id();
+
+    if (!before) {
+        d->m_menuItems.push_back(menuItem);
+    } else {
+        for (auto iter = d->m_menuItems.begin(); iter != d->m_menuItems.end(); ++iter) {
+            if (*iter == before) {
+                d->m_menuItems.insert(iter, menuItem);
+                break;
+            }
+        }
+    }
+
+    Q_EMIT menuItemInserted(menuItem);
+}
+
+void ExportedPlatformMenu::removeMenuItem(QPlatformMenuItem *menuItem)
+{
+    LOG_VAR(menuItem) << " on: " << id();
+
+    QMutableListIterator<QPlatformMenuItem*> iter(d->m_menuItems);
+    while (iter.hasNext()) {
+        if (iter.next() == menuItem) {
+            iter.remove();
+        }
+    }
+
+    Q_EMIT menuItemRemoved(menuItem);
+}
+
+void ExportedPlatformMenu::syncMenuItem(QPlatformMenuItem *menuItem)
+{
+    LOG_VAR(menuItem) << " from: " << id();
+    QMetaObject::invokeMethod(menuItem, "propertyUpdated");
+}
+
+void ExportedPlatformMenu::syncSeparatorsCollapsible(bool enable)
+{
+    LOG_VAR(enable) << " on: " << id();
+    Q_EMIT propertyUpdated();
+}
+
+void ExportedPlatformMenu::setTag(quintptr tag)
+{
+    LOG_VAR(tag) << " on: " << id();
+    d->m_tag = tag;
+}
+
+quintptr ExportedPlatformMenu::tag() const
+{
+    return d->m_tag;
+}
+
+void ExportedPlatformMenu::setText(const QString &text)
+{
+    LOG_VAR(text) << " on: " << id();
+    ExportedPlatformMenuPrivate::set_text(this, text);
+    Q_EMIT propertyUpdated();
+}
+
+void ExportedPlatformMenu::setIcon(const QIcon &icon)
+{
+    LOG_VAR(icon) << " on: " << id();
+    ExportedPlatformMenuPrivate::set_icon(this, icon);
+    Q_EMIT propertyUpdated();
+}
+
+void ExportedPlatformMenu::setEnabled(bool isEnabled)
+{
+    LOG_VAR(isEnabled) << " on: " << id();
+    ExportedPlatformMenuPrivate::set_enabled(this, isEnabled);
+    Q_EMIT propertyUpdated();
+}
+
+void ExportedPlatformMenu::setVisible(bool isVisible)
+{
+    LOG_VAR(isVisible) << " on: " << id();
+    ExportedPlatformMenuPrivate::set_visible(this, isVisible);
+    Q_EMIT propertyUpdated();
+}
+
+void ExportedPlatformMenu::setMinimumWidth(int width)
+{
+    LOG_VAR(width) << " on: " << id();
+    Q_EMIT propertyUpdated();
+}
+
+void ExportedPlatformMenu::setFont(const QFont &font)
+{
+    LOG_VAR(font) << " on: " << id();
+    Q_EMIT propertyUpdated();
+}
+
+QPlatformMenuItem *ExportedPlatformMenu::menuItemAt(int position) const
+{
+    if (position < 0 || position >= d->m_menuItems.count()) return nullptr;
+    return d->m_menuItems.at(position);
+}
+
+QPlatformMenuItem *ExportedPlatformMenu::menuItemForTag(quintptr tag) const
+{
+    for (auto iter = d->m_menuItems.begin(); iter != d->m_menuItems.end(); ++iter) {
+        if ((*iter)->tag() == tag) {
+            return *iter;
+        }
+    }
+    return nullptr;
+}
+
+uint ExportedPlatformMenu::menuItemCount()
+{
+    return d->m_menuItems.count();
+}
+
+QPlatformMenuItem *ExportedPlatformMenu::createMenuItem() const
+{
+    return new ExportedPlatformMenuItem();
+}
+
+int ExportedPlatformMenu::id() const
+{
+    return d->m_id;
+}
+
+//////////////////////////////////////////////////////////////
+
+ExportedPlatformMenuItem::ExportedPlatformMenuItem()
+    : d(new ExportedPlatformMenuItemPrivate)
+{
+    LOG << id();
+}
+
+ExportedPlatformMenuItem::~ExportedPlatformMenuItem()
+{
+    LOG << id();
+}
+
+void ExportedPlatformMenuItem::setTag(quintptr tag)
+{
+    LOG_VAR(tag) << " on: " << id();
+    d->m_tag = tag;
+}
+
+quintptr ExportedPlatformMenuItem::tag() const
+{
+    return d->m_tag;
+}
+
+void ExportedPlatformMenuItem::setText(const QString &text)
+{
+    LOG_VAR(text) << " on: " << id();
+    ExportedPlatformMenuItemPrivate::set_text(this, text);
+    Q_EMIT propertyUpdated();
+}
+
+void ExportedPlatformMenuItem::setIcon(const QIcon &icon)
+{
+    LOG_VAR(icon) << " on: " << id();
+    ExportedPlatformMenuItemPrivate::set_icon(this, icon);
+    Q_EMIT propertyUpdated();
+}
+
+void ExportedPlatformMenuItem::setMenu(QPlatformMenu *menu)
+{
+    LOG << MENU_ID(menu) << " on: " << id();
+    d->m_menu = menu;
+    Q_EMIT propertyUpdated();
+}
+
+void ExportedPlatformMenuItem::setVisible(bool isVisible)
+{
+    LOG_VAR(isVisible) << " on: " << id();
+    ExportedPlatformMenuItemPrivate::set_visible(this, isVisible);
+    Q_EMIT propertyUpdated();
+}
+
+void ExportedPlatformMenuItem::setIsSeparator(bool isSeparator)
+{
+    LOG_VAR(isSeparator) << " on: " << id();
+    ExportedPlatformMenuItemPrivate::set_separator(this, isSeparator);
+    Q_EMIT propertyUpdated();
+}
+
+void ExportedPlatformMenuItem::setFont(const QFont &font)
+{
+    LOG_VAR(font) << " on: " << id();
+    Q_EMIT propertyUpdated();
+}
+
+void ExportedPlatformMenuItem::setRole(QPlatformMenuItem::MenuRole role)
+{
+    LOG_VAR(role) << " on: " << id();
+    Q_EMIT propertyUpdated();
+}
+
+void ExportedPlatformMenuItem::setCheckable(bool checkable)
+{
+    LOG_VAR(checkable) << " on: " << id();
+    ExportedPlatformMenuItemPrivate::set_checkable(this, checkable);
+    Q_EMIT propertyUpdated();
+}
+
+void ExportedPlatformMenuItem::setChecked(bool isChecked)
+{
+    LOG_VAR(isChecked) << " on: " << id();
+    ExportedPlatformMenuItemPrivate::set_checked(this, isChecked);
+    Q_EMIT propertyUpdated();
+}
+
+void ExportedPlatformMenuItem::setShortcut(const QKeySequence &shortcut)
+{
+    LOG_VAR(shortcut) << " on: " << id();
+    ExportedPlatformMenuItemPrivate::set_shortcut(this, shortcut);
+    Q_EMIT propertyUpdated();
+}
+
+void ExportedPlatformMenuItem::setEnabled(bool enabled)
+{
+    LOG_VAR(enabled) << " on: " << id();
+    ExportedPlatformMenuItemPrivate::set_enabled(this, enabled);
+    Q_EMIT propertyUpdated();
+}
+
+void ExportedPlatformMenuItem::setIconSize(int size)
+{
+    LOG_VAR(size) << " on: " << id();
+    ExportedPlatformMenuItemPrivate::set_iconSize(this, size);
+    Q_EMIT propertyUpdated();
+}
+
+int ExportedPlatformMenuItem::id() const
+{
+    return d->m_id;
+}
+
+QPlatformMenu *ExportedPlatformMenuItem::menu() const
+{
+    return d->m_menu;
+}

=== added file 'src/qpa/exportedplatformmenubar.h'
--- src/qpa/exportedplatformmenubar.h	1970-01-01 00:00:00 +0000
+++ src/qpa/exportedplatformmenubar.h	2015-03-18 11:19:06 +0000
@@ -0,0 +1,136 @@
+/* This file is part of the dbusmenu-qt library
+   Copyright 2015 Canonical
+   Author: Nick Dedekind <[e-mail]>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License (LGPL) as published by the Free Software Foundation;
+   either version 2 of the License, or (at your option) any later
+   version.
+
+   This library 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
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this library; see the file COPYING.LIB.  If not, write to
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.
+*/
+#ifndef EXPORTEDPLATFORMMENUBAR_H
+#define EXPORTEDPLATFORMMENUBAR_H
+
+#include <qpa/qplatformmenu.h>
+class ExportedPlatformMenuBarPrivate;
+class ExportedPlatformMenuPrivate;
+class ExportedPlatformMenuItemPrivate;
+class ExportedPlatformMenu;
+class ExportedPlatformMenuItem;
+
+// Local
+#include <dbusmenu_export.h>
+
+class DBUSMENU_EXPORT ExportedPlatformMenuBar : public QPlatformMenuBar
+{
+    Q_OBJECT
+public:
+    ExportedPlatformMenuBar(const QString& exportPath);
+    ~ExportedPlatformMenuBar();
+
+    QString exportedPath() const;
+
+    virtual void insertMenu(QPlatformMenu *menu, QPlatformMenu* before) override;
+    virtual void removeMenu(QPlatformMenu *menu) override;
+    virtual void syncMenu(QPlatformMenu *menuItem) override;
+    virtual void handleReparent(QWindow *newParentWindow) override;
+    virtual QPlatformMenu *menuForTag(quintptr tag) const override;
+
+    QPlatformMenu *menuAt(int position) const;
+    uint menuCount();
+
+Q_SIGNALS:
+    void menuInserted(QPlatformMenu *menu);
+    void menuRemoved(QPlatformMenu *menu);
+
+private:
+    ExportedPlatformMenuBarPrivate *const d;
+    friend class ExportedPlatformMenuBarPrivate;
+};
+
+class DBUSMENU_EXPORT ExportedPlatformMenu : public QPlatformMenu
+{
+    Q_OBJECT
+public:
+    ExportedPlatformMenu();
+    ~ExportedPlatformMenu();
+
+    virtual void insertMenuItem(QPlatformMenuItem *menuItem, QPlatformMenuItem *before) override;
+    virtual void removeMenuItem(QPlatformMenuItem *menuItem) override;
+    virtual void syncMenuItem(QPlatformMenuItem *menuItem) override;
+    virtual void syncSeparatorsCollapsible(bool enable) override;
+
+    virtual void setTag(quintptr tag) override;
+    virtual quintptr tag() const override;
+
+    virtual void setText(const QString &text) override;
+    virtual void setIcon(const QIcon &icon) override;
+    virtual void setEnabled(bool isEnabled) override;
+    virtual void setVisible(bool isVisible) override;
+    virtual void setMinimumWidth(int width) override;
+    virtual void setFont(const QFont &font) override;
+
+    virtual QPlatformMenuItem *menuItemAt(int position) const override;
+    virtual QPlatformMenuItem *menuItemForTag(quintptr tag) const override;
+    uint menuItemCount();
+
+    virtual QPlatformMenuItem *createMenuItem() const override;
+
+    int id() const;
+
+Q_SIGNALS:
+    void menuItemInserted(QPlatformMenuItem *menuItem);
+    void menuItemRemoved(QPlatformMenuItem *menuItem);
+
+    void propertyUpdated();
+
+private:
+    ExportedPlatformMenuPrivate *const d;
+    friend class ExportedPlatformMenuPrivate;
+};
+
+
+class DBUSMENU_EXPORT ExportedPlatformMenuItem : public QPlatformMenuItem
+{
+    Q_OBJECT
+public:
+    ExportedPlatformMenuItem();
+    ~ExportedPlatformMenuItem();
+
+    virtual void setTag(quintptr tag) override;
+    virtual quintptr tag() const override;
+
+    virtual void setText(const QString &text) override;
+    virtual void setIcon(const QIcon &icon) override;
+    virtual void setMenu(QPlatformMenu *menu) override;
+    virtual void setVisible(bool isVisible) override;
+    virtual void setIsSeparator(bool isSeparator) override;
+    virtual void setFont(const QFont &font) override;
+    virtual void setRole(MenuRole role) override;
+    virtual void setCheckable(bool checkable) override;
+    virtual void setChecked(bool isChecked) override;
+    virtual void setShortcut(const QKeySequence& shortcut) override;
+    virtual void setEnabled(bool enabled) override;
+    virtual void setIconSize(int size) override;
+
+    int id() const;
+    QPlatformMenu* menu() const;
+
+Q_SIGNALS:
+    void propertyUpdated();
+
+private:
+    ExportedPlatformMenuItemPrivate *const d;
+    friend class ExportedPlatformMenuItemPrivate;
+};
+#endif // EXPORTEDPLATFORMMENUBAR_H

=== added file 'src/qpa/exportedplatformmenubar_p.cpp'
--- src/qpa/exportedplatformmenubar_p.cpp	1970-01-01 00:00:00 +0000
+++ src/qpa/exportedplatformmenubar_p.cpp	2015-03-18 11:19:06 +0000
@@ -0,0 +1,129 @@
+/* This file is part of the dbusmenu-qt library
+   Copyright 2015 Canonical
+   Author: Nick Dedekind <[e-mail]>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License (LGPL) as published by the Free Software Foundation;
+   either version 2 of the License, or (at your option) any later
+   version.
+
+   This library 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
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this library; see the file COPYING.LIB.  If not, write to
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.
+*/
+
+// Local
+#include "exportedplatformmenubar_p.h"
+#include "dbusmenushortcut_p.h"
+#include "debug_p.h"
+#include "utils_p.h"
+
+// Qt
+#include <QBuffer>
+
+int nextMenuId = 1;
+
+void insertIconProperty(QVariantMap *map, const QIcon& icon)
+{
+    // provide the icon name for per-theme lookups
+    const QString iconName = icon.name();
+    if (!iconName.isEmpty()) {
+        map->insert(DBusMenuProperty::IconName, iconName);
+    }
+
+    if (!icon.isNull()) {
+        QBuffer buffer;
+        icon.pixmap(16).save(&buffer, "PNG");
+        map->insert(DBusMenuProperty::IconData, buffer.data());
+    }
+}
+
+ExportedPlatformMenuBarPrivate::ExportedPlatformMenuBarPrivate()
+{
+}
+
+//////////////////////////////////////////////////////
+
+ExportedPlatformMenuPrivate::ExportedPlatformMenuPrivate()
+    : m_tag(0)
+    , m_id(nextMenuId++)
+{
+
+}
+
+QVariantMap ExportedPlatformMenuPrivate::propertiesForMenu(const ExportedPlatformMenu *menu)
+{
+    QVariantMap map;
+    map.insert(DBusMenuProperty::ChildrenDisplay, "submenu");
+    map.insert(DBusMenuProperty::Label, Utils::swapMnemonicChar(ExportedPlatformMenuPrivate::get_text(menu), '&', '_'));
+    if (!ExportedPlatformMenuPrivate::get_enabled(menu)) {
+        map.insert(DBusMenuProperty::Enabled, false);
+    }
+    if (!ExportedPlatformMenuPrivate::get_visible(menu)) {
+        map.insert(DBusMenuProperty::Visible, false);
+    }
+    insertIconProperty(&map, ExportedPlatformMenuPrivate::get_icon(menu));
+    return map;
+}
+
+//////////////////////////////////////////////////////
+
+ExportedPlatformMenuItemPrivate::ExportedPlatformMenuItemPrivate()
+    : m_id(nextMenuId++)
+    , m_menu(nullptr)
+{
+}
+
+QVariantMap ExportedPlatformMenuItemPrivate::propertiesForMenuItem(const ExportedPlatformMenuItem *menuItem)
+{
+    DMRETURN_VALUE_IF_FAIL(menuItem, QVariantMap());
+
+    if (ExportedPlatformMenuItemPrivate::get_separator(menuItem)) {
+        return propertiesForSeparatorMenuItem(menuItem);
+    } else {
+        return propertiesForStandardMenuItem(menuItem);
+    }
+}
+
+QVariantMap ExportedPlatformMenuItemPrivate::propertiesForSeparatorMenuItem(const ExportedPlatformMenuItem *menuItem)
+{
+    QVariantMap map;
+    map.insert(DBusMenuProperty::Type, "separator");
+    if (!ExportedPlatformMenuItemPrivate::get_visible(menuItem)) {
+        map.insert(DBusMenuProperty::Visible, false);
+    }
+    return map;
+}
+
+QVariantMap ExportedPlatformMenuItemPrivate::propertiesForStandardMenuItem(const ExportedPlatformMenuItem *menuItem)
+{
+    QVariantMap map;
+    map.insert(DBusMenuProperty::Label, Utils::swapMnemonicChar(ExportedPlatformMenuItemPrivate::get_text(menuItem), '&', '_'));
+    if (!ExportedPlatformMenuItemPrivate::get_enabled(menuItem)) {
+        map.insert(DBusMenuProperty::Enabled, false);
+    }
+    if (!ExportedPlatformMenuItemPrivate::get_visible(menuItem)) {
+        map.insert(DBusMenuProperty::Visible, false);
+    }
+    if (ExportedPlatformMenuItemPrivate::get_checkable(menuItem)) {
+        map.insert(DBusMenuProperty::ToggleType, "checkmark");
+        map.insert(DBusMenuProperty::ToggleState, ExportedPlatformMenuItemPrivate::get_checked(menuItem) ? 1 : 0);
+    }
+    if (menuItem->menu()) {
+        map.insert(DBusMenuProperty::ChildrenDisplay, "submenu");
+    }
+    insertIconProperty(&map, ExportedPlatformMenuItemPrivate::get_icon(menuItem));
+    QKeySequence keySequence = get_shortcut(menuItem);
+    if (!keySequence.isEmpty()) {
+        DBusMenuShortcut shortcut = DBusMenuShortcut::fromKeySequence(keySequence);
+        map.insert(DBusMenuProperty::Shortcut, QVariant::fromValue(shortcut));
+    }
+    return map;
+}

=== added file 'src/qpa/exportedplatformmenubar_p.h'
--- src/qpa/exportedplatformmenubar_p.h	1970-01-01 00:00:00 +0000
+++ src/qpa/exportedplatformmenubar_p.h	2015-03-18 11:19:06 +0000
@@ -0,0 +1,111 @@
+/* This file is part of the dbusmenu-qt library
+   Copyright 2015 Canonical
+   Author: Nick Dedekind <[e-mail]>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License (LGPL) as published by the Free Software Foundation;
+   either version 2 of the License, or (at your option) any later
+   version.
+
+   This library 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
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this library; see the file COPYING.LIB.  If not, write to
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.
+*/
+#ifndef EXPORTEDPLATFORMMENUBAR_P_H
+#define EXPORTEDPLATFORMMENUBAR_P_H
+
+// Qt
+#include <QtCore/QObject>
+#include <QtDBus/QDBusConnection>
+#include <qpa/qplatformmenu.h>
+
+// Local
+#include "dbusmenuexporterdbusinterface_p.h"
+#include "exportedplatformmenubar.h"
+
+class QAction;
+class QMenu;
+
+class ExportedPlatformMenuBar;
+class ExportedPlatformMenu;
+class ExportedPlatformMenuItem;
+class QPADBusMenuExporter;
+
+/**
+ * A QPADBusMenuExporter instance can serialize a qua menu over DBus
+ */
+class ExportedPlatformMenuBarPrivate
+{
+public:
+    ExportedPlatformMenuBarPrivate();
+
+    QString m_objectPath;
+    QList<QPlatformMenu*> m_menus;
+};
+
+class ExportedPlatformMenuPrivate
+{
+public:
+    ExportedPlatformMenuPrivate();
+
+    static QVariantMap propertiesForMenu(const ExportedPlatformMenu *menu);
+
+#define STATIC_PROPERTY(name, type, defaultValue) \
+    type m_##name = defaultValue; \
+    static type get_##name(const ExportedPlatformMenu *menu) { return menu->d->m_##name; } \
+    static void set_##name(ExportedPlatformMenu *menu, const type& value) { menu->d->m_##name = value; }
+
+    STATIC_PROPERTY(text, QString, QString())
+    STATIC_PROPERTY(visible, bool, true)
+    STATIC_PROPERTY(enabled, bool, true)
+    STATIC_PROPERTY(icon, QIcon, QIcon())
+#undef STATIC_PROPERTY
+
+    ExportedPlatformMenu* m_menu;
+    QList<QPlatformMenu*> m_menus;
+    QList<QPlatformMenuItem*> m_menuItems;
+    quintptr m_tag;
+    int m_id;
+};
+
+class ExportedPlatformMenuItemPrivate
+{
+public:
+    ExportedPlatformMenuItemPrivate();
+
+    static QVariantMap propertiesForMenuItem(const ExportedPlatformMenuItem *menuItem);
+    static QVariantMap propertiesForSeparatorMenuItem(const ExportedPlatformMenuItem *menuItem);
+    static QVariantMap propertiesForStandardMenuItem(const ExportedPlatformMenuItem *menuItem);
+
+#define STATIC_PROPERTY(name, type, defaultValue) \
+    type m_##name = defaultValue; \
+    static type get_##name(const ExportedPlatformMenuItem *menuItem) { return menuItem->d->m_##name; } \
+    static void set_##name(ExportedPlatformMenuItem *menuItem, const type& value) { menuItem->d->m_##name = value; }
+
+    STATIC_PROPERTY(separator, bool, false)
+    STATIC_PROPERTY(visible, bool, true)
+    STATIC_PROPERTY(text, QString, QString())
+    STATIC_PROPERTY(enabled, bool, true)
+    STATIC_PROPERTY(checkable, bool, false)
+    STATIC_PROPERTY(checked, bool, false)
+    STATIC_PROPERTY(shortcut, QKeySequence, QKeySequence())
+    STATIC_PROPERTY(icon, QIcon, QIcon())
+    STATIC_PROPERTY(iconSize, int, 16)
+#undef STATIC_PROPERTY
+
+    ExportedPlatformMenuItem* m_menuItem;
+    quintptr m_tag;
+    int m_id;
+    QPlatformMenu* m_menu;
+};
+
+extern int nextMenuId;
+
+#endif // EXPORTEDPLATFORMMENUBAR_P_H

=== added file 'src/qpa/logging_p.h'
--- src/qpa/logging_p.h	1970-01-01 00:00:00 +0000
+++ src/qpa/logging_p.h	2015-03-18 11:19:06 +0000
@@ -0,0 +1,38 @@
+/* This file is part of the dbusmenu-qt library
+   Copyright 2015 Canonical
+   Author: Nick Dedekind <[e-mail]>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License (LGPL) as published by the Free Software Foundation;
+   either version 2 of the License, or (at your option) any later
+   version.
+
+   This library 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
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this library; see the file COPYING.LIB.  If not, write to
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.
+*/
+#ifndef LOGGING_H
+#define LOGGING_H
+
+#include <QDebug>
+
+//#define ENABLE_DEBUG_LOGGING
+
+#ifdef ENABLE_DEBUG_LOGGING
+#define LOG qDebug() << __PRETTY_FUNCTION__
+#define LOG_VAR(x) qDebug() << __PRETTY_FUNCTION__<< #x ":" << x
+#else
+#define LOG QNoDebug()
+#define LOG_VAR(x) QNoDebug() << __PRETTY_FUNCTION__<< #x ":" << x
+#endif
+
+#define WARN qWarning() << __PRETTY_FUNCTION__
+
+#endif // LOGGING_H

=== added file 'src/qpa/qpadbusmenuexporter_p.cpp'
--- src/qpa/qpadbusmenuexporter_p.cpp	1970-01-01 00:00:00 +0000
+++ src/qpa/qpadbusmenuexporter_p.cpp	2015-03-18 11:19:06 +0000
@@ -0,0 +1,357 @@
+/* This file is part of the dbusmenu-qt library
+   Copyright 2015 Canonical
+   Author: Nick Dedekind <[e-mail]>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License (LGPL) as published by the Free Software Foundation;
+   either version 2 of the License, or (at your option) any later
+   version.
+
+   This library 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
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this library; see the file COPYING.LIB.  If not, write to
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.
+*/
+
+// Local
+#include "qpadbusmenuexporter_p.h"
+#include "exportedplatformmenubar.h"
+#include "exportedplatformmenubar_p.h"
+#include "utils_p.h"
+#include "logging_p.h"
+
+// Qt
+#include <QTimer>
+
+QPADBusMenuExporter::QPADBusMenuExporter(const QString &objectPath, ExportedPlatformMenuBar* menuBar)
+    : DBusMenuExporterDBusInterface(objectPath, menuBar)
+    , m_menuBar(menuBar)
+    , m_revision(1)
+    , m_emittedLayoutUpdatedOnce(false)
+{
+    LOG << "created exporter menu @ " << objectPath;
+
+    m_propertyTimer = new QTimer(this);
+    m_propertyTimer->setInterval(0);
+    m_propertyTimer->setSingleShot(true);
+    connect(m_propertyTimer, &QTimer::timeout, this, &QPADBusMenuExporter::doMenuPropertyUpdate);
+
+    m_layoutTimer = new QTimer(this);
+    m_layoutTimer->setInterval(0);
+    m_layoutTimer->setSingleShot(true);
+    connect(m_layoutTimer, &QTimer::timeout, this, &QPADBusMenuExporter::doMenuLayoutUpdate);
+
+    for (uint i = 0; i < m_menuBar->menuCount(); i++) {
+        auto exportedMenu = qobject_cast<ExportedPlatformMenu*>(m_menuBar->menuAt(i));
+        addMenu(exportedMenu, 0);
+    }
+
+    connect(menuBar, &ExportedPlatformMenuBar::menuInserted, this, [this](QPlatformMenu* menu) {
+        addMenu(qobject_cast<ExportedPlatformMenu*>(menu), 0);
+    });
+    connect(menuBar, &ExportedPlatformMenuBar::menuRemoved, this, [this](QPlatformMenu* menu) {
+        removeMenu(qobject_cast<ExportedPlatformMenu*>(menu), 0);
+    });
+}
+
+QPADBusMenuExporter::~QPADBusMenuExporter()
+{
+}
+
+void QPADBusMenuExporter::Event(int id, const QString &eventType, const QDBusVariant &data, uint timestamp)
+{
+    Q_UNUSED(data);
+    Q_UNUSED(timestamp);
+    LOG << " id:" << id << ", eventType:" << eventType;
+
+    ExportedPlatformMenuItem* menuItem = m_menuItemForId.value(id, nullptr);
+    if (menuItem) {
+        if (eventType == "clicked") {
+            QMetaObject::invokeMethod(menuItem, "activated");
+        } else if (eventType == "hovered") {
+            QMetaObject::invokeMethod(menuItem, "hovered");
+        }
+    }
+}
+
+QDBusVariant QPADBusMenuExporter::GetProperty(int id, const QString &property)
+{
+    if (!m_propertiesForId.contains(id)) return QDBusVariant();
+    return QDBusVariant(m_propertiesForId.value(id).value(property));
+}
+
+void QPADBusMenuExporter::fillLayout(DBusMenuLayoutItem *item, int id, int depth, const QStringList &propertyNames)
+{
+    item->id = id;
+    item->properties = getProperties(id, propertyNames);
+
+    if (depth != 0) {
+        if (id == 0) {
+            for (uint i = 0; i < m_menuBar->menuCount(); i++) {
+                auto exportedMenu = qobject_cast<ExportedPlatformMenu*>(m_menuBar->menuAt(i));
+                if (exportedMenu) {
+                    DBusMenuLayoutItem child;
+                    fillLayout(&child, exportedMenu->id(), depth - 1, propertyNames);
+                    item->children << child;
+                }
+            }
+        } else {
+            // menu with children.
+            ExportedPlatformMenu* menu = m_menuForId.value(id, nullptr);
+            if (menu) {
+                for (uint i = 0; i < menu->menuItemCount(); i++) {
+                    auto exportedMenuItem = qobject_cast<ExportedPlatformMenuItem*>(menu->menuItemAt(i));
+
+                    DBusMenuLayoutItem child;
+                    fillLayout(&child, exportedMenuItem->id(), depth-1, propertyNames);
+                    item->children << child;
+                }
+            } else {
+                // child menu items which has an attached menu
+                ExportedPlatformMenuItem* menuItem = m_menuItemForId.value(id, nullptr);
+                if (menuItem) {
+                    auto menu = qobject_cast<ExportedPlatformMenu*>(menuItem->menu());
+                    if (menu) {
+                        for (uint i = 0; i < menu->menuItemCount(); i++) {
+                            auto exportedMenuItem = qobject_cast<ExportedPlatformMenuItem*>(menu->menuItemAt(i));
+
+                            DBusMenuLayoutItem child;
+                            fillLayout(&child, exportedMenuItem->id(), depth-1, propertyNames);
+                            item->children << child;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+uint QPADBusMenuExporter::GetLayout(int parentId, int recursionDepth, const QStringList &propertyNames, DBusMenuLayoutItem &item)
+{
+    doMenuPropertyUpdate();
+
+    fillLayout(&item, parentId, recursionDepth, propertyNames);
+    return m_revision;
+}
+
+DBusMenuItemList QPADBusMenuExporter::GetGroupProperties(const QList<int> &ids, const QStringList &propertyNames)
+{
+    DBusMenuItemList list;
+    Q_FOREACH(int id, ids) {
+        DBusMenuItem item;
+        item.id = id;
+        item.properties = getProperties(item.id, propertyNames);
+        list << item;
+    }
+    return list;
+}
+
+bool QPADBusMenuExporter::AboutToShow(int id)
+{
+    return false;
+}
+
+void QPADBusMenuExporter::menuPropertyUpdated(int id)
+{
+    if (m_propertyUpdates.contains(id)) return;
+
+    m_propertyUpdates << id;
+    if (!m_propertyTimer->isActive()) m_propertyTimer->start();
+}
+
+void QPADBusMenuExporter::menuLayoutUpdated(int id)
+{
+    if (m_layoutUpdates.contains(id)) return;
+
+    m_layoutUpdates << id;
+    if (!m_layoutTimer->isActive()) m_layoutTimer->start();
+}
+
+inline void logPropertyUpdates(const DBusMenuItemList& updates, const DBusMenuItemKeysList& removals)
+{
+    Q_FOREACH(const DBusMenuItem& update, updates) {
+        qDebug() << "property updates for " << update.id << endl
+            << "         " << update.properties;
+    }
+    Q_FOREACH(const DBusMenuItemKeys& remove, removals) {
+        qDebug() << "property updates for " << remove.id << endl
+            << "         " << remove.properties;
+    }
+}
+
+void QPADBusMenuExporter::doMenuPropertyUpdate()
+{
+    if (m_propertyUpdates.isEmpty()) {
+        return;
+    }
+    DBusMenuItemList updatedList;
+    DBusMenuItemKeysList removedList;
+
+    Q_FOREACH(int id, m_propertyUpdates) {
+        QVariantMap  newProperties;
+        ExportedPlatformMenuItem* menuItem = m_menuItemForId.value(id, nullptr);
+        // no longer exists?
+        if (menuItem) {
+            newProperties = ExportedPlatformMenuItemPrivate::propertiesForMenuItem(menuItem);
+        } else {
+            ExportedPlatformMenu* menu = m_menuForId.value(id, nullptr);
+            if (menu) {
+                newProperties = ExportedPlatformMenuPrivate::propertiesForMenu(menu);
+            }
+        }
+
+        QVariantMap& oldProperties = m_propertiesForId[id];
+        QVariantMap  updatedProperties;
+        QStringList  removedProperties;
+
+        Utils::parsePropertyChanges(oldProperties, newProperties, updatedProperties, removedProperties);
+
+        // Update our data (oldProperties is a reference)
+        oldProperties = newProperties;
+
+        if (!updatedProperties.isEmpty()) {
+            DBusMenuItem item;
+            item.id = id;
+            item.properties = updatedProperties;
+            updatedList << item;
+        }
+        if (!removedProperties.isEmpty()) {
+            DBusMenuItemKeys itemKeys;
+            itemKeys.id = id;
+            itemKeys.properties = removedProperties;
+            removedList << itemKeys;
+        }
+    }
+    m_propertyUpdates.clear();
+
+    if (!m_emittedLayoutUpdatedOnce) {
+        // No need to tell the world about action changes: nobody knows the
+        // menu layout so nobody knows about the actions.
+        // Note: We still need to reach this method because we want our properties to be
+        // updated, even if we don't announce changes.
+        return;
+    }
+    if (!updatedList.isEmpty() || !removedList.isEmpty()) {
+#ifdef ENABLE_DEBUG_LOGGING
+        logPropertyUpdates(updatedList, removedList);
+#endif
+
+        Q_EMIT ItemsPropertiesUpdated(updatedList, removedList);
+    }
+}
+
+void QPADBusMenuExporter::doMenuLayoutUpdate()
+{
+    // Tell the world about the update
+    if (m_emittedLayoutUpdatedOnce) {
+        Q_FOREACH(int id, m_layoutUpdates) {
+            Q_EMIT LayoutUpdated(++m_revision, id);
+        }
+    } else {
+        // First time we emit LayoutUpdated, no need to emit several layout
+        // updates, signals the whole layout (id==0) has been updated
+        Q_EMIT LayoutUpdated(++m_revision, 0);
+        m_emittedLayoutUpdatedOnce = true;
+    }
+    m_layoutUpdates.clear();
+}
+
+void QPADBusMenuExporter::addMenu(ExportedPlatformMenu *menu, int parentId)
+{
+    if (!menu) return;
+    if (m_menuForId.contains(menu->id())) return;
+
+    for (uint i = 0; i < menu->menuItemCount(); i++) {
+        auto exportedMenuItem = qobject_cast<ExportedPlatformMenuItem*>(menu->menuItemAt(i));
+        addMenuItem(exportedMenuItem, menu->id());
+    }
+
+    m_menuForId[menu->id()] = menu;
+    m_propertiesForId[menu->id()] = ExportedPlatformMenuPrivate::propertiesForMenu(menu);
+    connect(menu, &ExportedPlatformMenu::propertyUpdated, this, [&, menu]() {
+        menuPropertyUpdated(menu->id());
+    });
+    connect(menu, &ExportedPlatformMenu::menuItemInserted, this, [&, menu](QPlatformMenuItem* menuItem) {
+        addMenuItem(qobject_cast<ExportedPlatformMenuItem*>(menuItem), menu->id());
+    });
+    connect(menu, &ExportedPlatformMenu::menuItemRemoved, this, [&, menu](QPlatformMenuItem* menuItem) {
+        removeMenuItem(qobject_cast<ExportedPlatformMenuItem*>(menuItem), menu->id());
+    });
+
+    menuLayoutUpdated(parentId);
+}
+
+void QPADBusMenuExporter::addMenuItem(ExportedPlatformMenuItem *menuItem, int parentId)
+{
+    if (!menuItem) return;
+    if (m_menuItemForId.contains(menuItem->id())) return;
+
+    m_menuItemForId[menuItem->id()] = menuItem;
+    m_propertiesForId[menuItem->id()] = ExportedPlatformMenuItemPrivate::propertiesForMenuItem(menuItem);
+
+    connect(menuItem, &ExportedPlatformMenuItem::propertyUpdated, this, [&, menuItem]() {
+        menuPropertyUpdated(menuItem->id());
+    });
+
+    auto menu = qobject_cast<ExportedPlatformMenu*>(menuItem->menu());
+    if (menu) {
+        addMenu(menu, parentId);
+    }
+    menuLayoutUpdated(parentId);
+}
+
+void QPADBusMenuExporter::removeMenu(ExportedPlatformMenu *menu, int parentId)
+{
+    if (!menu) return;
+
+    for (uint i = 0; i < menu->menuItemCount(); i++) {
+        auto exportedMenuItem = qobject_cast<ExportedPlatformMenuItem*>(menu->menuItemAt(i));
+        removeMenuItem(exportedMenuItem, parentId);
+    }
+    disconnect(menu, 0, this, 0);
+}
+
+void QPADBusMenuExporter::removeMenuItem(ExportedPlatformMenuItem *menuItem, int parentId)
+{
+    if (!menuItem) return;
+
+    auto menu = qobject_cast<ExportedPlatformMenu*>(menuItem->menu());
+    if (menu) {
+        removeMenu(menu, menuItem->id());
+    }
+
+    m_menuItemForId.remove(menuItem->id());
+    m_propertiesForId.remove(menuItem->id());
+    disconnect(menuItem, 0, this, 0);
+
+    menuLayoutUpdated(parentId);
+}
+
+QVariantMap QPADBusMenuExporter::getProperties(int id, const QStringList &names) const
+{
+    if (id == 0) {
+        QVariantMap map;
+        map.insert(DBusMenuProperty::ChildrenDisplay, "submenu");
+        return map;
+    }
+    QVariantMap all = m_propertiesForId.value(id);
+    if (names.isEmpty()) {
+        return all;
+    } else {
+        QVariantMap map;
+        Q_FOREACH(const QString &name, names) {
+            QVariant value = all.value(name);
+            if (value.isValid()) {
+                map.insert(name, value);
+            }
+        }
+        return map;
+    }
+}
+

=== added file 'src/qpa/qpadbusmenuexporter_p.h'
--- src/qpa/qpadbusmenuexporter_p.h	1970-01-01 00:00:00 +0000
+++ src/qpa/qpadbusmenuexporter_p.h	2015-03-18 11:19:06 +0000
@@ -0,0 +1,94 @@
+/* This file is part of the dbusmenu-qt library
+   Copyright 2015 Canonical
+   Author: Nick Dedekind <[e-mail]>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License (LGPL) as published by the Free Software Foundation;
+   either version 2 of the License, or (at your option) any later
+   version.
+
+   This library 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
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this library; see the file COPYING.LIB.  If not, write to
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.
+*/
+#ifndef QPADBUSMENUEXPORTER_H
+#define QPADBUSMENUEXPORTER_H
+
+// Qt
+#include <QtCore/QObject>
+#include <QtDBus/QDBusConnection>
+#include <qpa/qplatformmenu.h>
+
+// Local
+#include "dbusmenuexporterdbusinterface_p.h"
+
+class QAction;
+class QMenu;
+
+class ExportedPlatformMenuBar;
+class ExportedPlatformMenu;
+class ExportedPlatformMenuItem;
+
+/**
+ * A QPADBusMenuExporter instance can serialize a qua menu over DBus
+ */
+class QPADBusMenuExporter : public DBusMenuExporterDBusInterface
+{
+    Q_OBJECT
+    Q_CLASSINFO("D-Bus Interface", "com.canonical.dbusmenu")
+public:
+    QPADBusMenuExporter(const QString& path, ExportedPlatformMenuBar* menuBar);
+    virtual ~QPADBusMenuExporter();
+
+    // overrides
+    void Event(int id, const QString &eventId, const QDBusVariant &data, uint timestamp) override;
+    QDBusVariant GetProperty(int id, const QString &property) override;
+    uint GetLayout(int parentId, int recursionDepth, const QStringList &propertyNames, DBusMenuLayoutItem &item) override;
+    DBusMenuItemList GetGroupProperties(const QList<int> &ids, const QStringList &propertyNames) override;
+    bool AboutToShow(int id) override;
+
+private Q_SLOTS:
+    void menuPropertyUpdated(int id);
+    void menuLayoutUpdated(int id);
+
+private Q_SLOTS:
+    void doMenuPropertyUpdate();
+    void doMenuLayoutUpdate();
+
+private:
+    Q_DISABLE_COPY(QPADBusMenuExporter)
+
+    void addMenu(ExportedPlatformMenu* menu, int parentId);
+    void addMenuItem(ExportedPlatformMenuItem* menu, int parentId);
+
+    void removeMenu(ExportedPlatformMenu* menu, int parentId);
+    void removeMenuItem(ExportedPlatformMenuItem* menuItem, int parentId);
+
+    void fillLayout(DBusMenuLayoutItem *item, int id, int depth, const QStringList &propertyNames);
+    QVariantMap getProperties(int id, const QStringList &names) const;
+
+    ExportedPlatformMenuBar* m_menuBar;
+    QTimer* m_propertyTimer;
+    QTimer* m_layoutTimer;
+
+    QList<int> m_propertyUpdates;
+    QList<int> m_layoutUpdates;
+    uint m_revision;
+    bool m_emittedLayoutUpdatedOnce;
+
+    QHash<int, ExportedPlatformMenuItem*> m_menuItemForId;
+    QHash<int, ExportedPlatformMenu*> m_menuForId;
+    QHash<int, QVariantMap> m_propertiesForId;
+
+    friend class ExportedPlatformMenu;
+    friend class ExportedPlatformMenuItem;
+};
+
+#endif /* QPADBUSMENUEXPORTER_H */

=== modified file 'src/utils.cpp'
--- src/utils.cpp	2010-09-20 08:55:12 +0000
+++ src/utils.cpp	2015-03-18 11:19:06 +0000
@@ -23,7 +23,7 @@
 // Qt
 #include <QString>
 
-QString swapMnemonicChar(const QString &in, const char src, const char dst)
+QString Utils::swapMnemonicChar(const QString &in, const char src, const char dst)
 {
     QString out;
     bool mnemonicFound = false;
@@ -62,3 +62,38 @@
 
     return out;
 }
+
+
+void Utils::parsePropertyChanges(const QVariantMap &oldProperties,
+                                 const QVariantMap &newProperties,
+                                 QVariantMap &updatedProperties,
+                                 QStringList &removedProperties)
+{
+    // Find updated and removed properties
+    QVariantMap::ConstIterator newEnd = newProperties.constEnd();
+
+    QVariantMap::ConstIterator
+        oldIt = oldProperties.constBegin(),
+        oldEnd = oldProperties.constEnd();
+    for(; oldIt != oldEnd; ++oldIt) {
+        QString key = oldIt.key();
+        QVariantMap::ConstIterator newIt = newProperties.constFind(key);
+        if (newIt != newEnd) {
+            if (newIt.value() != oldIt.value()) {
+                updatedProperties.insert(key, newIt.value());
+            }
+        } else {
+            removedProperties << key;
+        }
+    }
+
+    // Find new properties (treat them as updated properties)
+    QVariantMap::ConstIterator newIt = newProperties.constBegin();
+    for (; newIt != newEnd; ++newIt) {
+        QString key = newIt.key();
+        oldIt = oldProperties.constFind(key);
+        if (oldIt == oldEnd) {
+            updatedProperties.insert(key, newIt.value());
+        }
+    }
+}

=== modified file 'src/utils_p.h'
--- src/utils_p.h	2010-09-20 08:55:12 +0000
+++ src/utils_p.h	2015-03-18 11:19:06 +0000
@@ -22,10 +22,20 @@
 #define UTILS_P_H
 
 class QString;
-
-/**
- * Swap mnemonic char: Qt uses '&', while dbusmenu uses '_'
- */
-QString swapMnemonicChar(const QString &in, const char src, const char dst);
+class QStringList;
+#include <QVariant>
+
+namespace Utils {
+
+    /**
+     * Swap mnemonic char: Qt uses '&', while dbusmenu uses '_'
+     */
+    QString swapMnemonicChar(const QString &in, const char src, const char dst);
+
+    void parsePropertyChanges(const QVariantMap& oldProperties,
+                              const QVariantMap& newProperties,
+                              QVariantMap& updatedProperties,
+                              QStringList& removedProperties);
+}
 
 #endif /* UTILS_P_H */

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2015-03-18 11:19:06 +0000
+++ tests/CMakeLists.txt	2015-03-18 11:19:06 +0000
@@ -120,5 +120,18 @@
     ${test_LIBRARIES}
     )
 
+
+# exportedplatformmenutest
+if (USE_QT5)
+    add_test_executable(exportedplatformmenutest
+                        exportedplatformmenutest.cpp
+                        testutils.cpp
+    )
+
+    target_link_libraries(exportedplatformmenutest
+        ${test_LIBRARIES}
+    )
+endif()
+
 # Keep this at the end
 create_check_target()

=== modified file 'tests/dbusmenuexportertest.cpp'
--- tests/dbusmenuexportertest.cpp	2015-03-18 11:19:06 +0000
+++ tests/dbusmenuexportertest.cpp	2015-03-18 11:19:06 +0000
@@ -31,7 +31,7 @@
 
 // DBusMenuQt
 #include <dbusmenuexporter.h>
-#include <dbusmenutypes_p.h>
+#include <dbusmenutypes.h>
 #include <dbusmenushortcut_p.h>
 #include <debug_p.h>
 
@@ -114,6 +114,7 @@
     if (enabled) {
         QVERIFY(!item.properties.contains("enabled"));
     } else {
+        QVERIFY(item.properties.contains("enabled"));
         QCOMPARE(item.properties.value("enabled").toBool(), false);
     }
     if (iconName.isEmpty()) {

=== added file 'tests/exportedplatformmenutest.cpp'
--- tests/exportedplatformmenutest.cpp	1970-01-01 00:00:00 +0000
+++ tests/exportedplatformmenutest.cpp	2015-03-18 11:19:06 +0000
@@ -0,0 +1,366 @@
+/* This file is part of the dbusmenu-qt library
+   Copyright 2015 Canonical
+   Author: Aurelien Gateau <[e-mail]>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License (LGPL) as published by the Free Software Foundation;
+   either version 2 of the License, or (at your option) any later
+   version.
+
+   This library 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
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this library; see the file COPYING.LIB.  If not, write to
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.
+*/
+// Self
+#include "exportedplatformmenutest.h"
+
+// Qt
+#include <QDBusConnection>
+#include <QDBusInterface>
+#include <QDBusReply>
+#include <QtTest>
+
+// DBusMenuQt
+#include <qpa/exportedplatformmenubar.h>
+#include <dbusmenutypes.h>
+#include <dbusmenushortcut_p.h>
+#include <debug_p.h>
+
+// Local
+#include "testutils.h"
+
+QTEST_MAIN(ExportedPlatformMenuTest)
+
+static const char *TEST_SERVICE = "org.kde.dbusmenu-qt-test";
+static const char *TEST_OBJECT_PATH = "/TestMenuBar";
+
+Q_DECLARE_METATYPE(QList<int>)
+
+static DBusMenuLayoutItemList getChildren(QDBusAbstractInterface* iface, int parentId, const QStringList &propertyNames)
+{
+    QDBusPendingReply<uint, DBusMenuLayoutItem> reply = iface->call("GetLayout", parentId, /*recursionDepth=*/ 1, propertyNames);
+    reply.waitForFinished();
+    if (!reply.isValid()) {
+        qFatal("%s", qPrintable(reply.error().message()));
+        return DBusMenuLayoutItemList();
+    }
+
+    DBusMenuLayoutItem rootItem = reply.argumentAt<1>();
+    return rootItem.children;
+}
+
+void ExportedPlatformMenuTest::init()
+{
+    QVERIFY(QDBusConnection::sessionBus().registerService(TEST_SERVICE));
+    QCoreApplication::setAttribute(Qt::AA_DontShowIconsInMenus, false);
+}
+
+void ExportedPlatformMenuTest::cleanup()
+{
+    QVERIFY(QDBusConnection::sessionBus().unregisterService(TEST_SERVICE));
+}
+
+void ExportedPlatformMenuTest::testGetSomeMenuProperties_data()
+{
+   QTest::addColumn<QString>("label");
+   QTest::addColumn<QString>("iconName");
+   QTest::addColumn<bool>("enabled");
+
+   QTest::newRow("label only")           << "label" << QString()   << true;
+   QTest::newRow("disabled, label only") << "label" << QString()   << false;
+   QTest::newRow("icon name")            << "label" << "edit-undo" << true;
+}
+
+void ExportedPlatformMenuTest::testGetSomeMenuProperties()
+{
+   QFETCH(QString, label);
+   QFETCH(QString, iconName);
+   QFETCH(bool, enabled);
+
+   // Create an exporter for a menu with one action, defined by the test data
+   ExportedPlatformMenuBar menuBar(TEST_OBJECT_PATH);
+   ExportedPlatformMenu menu;
+   menu.setText(label);
+   if (!iconName.isEmpty()) {
+       QIcon icon = QIcon::fromTheme(iconName);
+       QVERIFY(!icon.isNull());
+       menu.setIcon(icon);
+   }
+   menu.setEnabled(enabled);
+   menuBar.insertMenu(&menu, nullptr);
+
+   // Check out exporter is on DBus
+   QDBusInterface iface(TEST_SERVICE, TEST_OBJECT_PATH);
+   QVERIFY2(iface.isValid(), qPrintable(iface.lastError().message()));
+
+   // Get exported menu info
+   QStringList propertyNames = QStringList() << "type" << "enabled" << "label" << "icon-name";
+   DBusMenuLayoutItemList list = getChildren(&iface, /*parentId=*/0, propertyNames);
+   QVERIFY(!list.isEmpty());
+   DBusMenuLayoutItem item = list.first();
+
+   QVERIFY(item.id != 0);
+   QVERIFY(item.children.isEmpty());
+   QVERIFY(!item.properties.contains("type"));
+   QCOMPARE(item.properties.value("label").toString(), label);
+   if (enabled) {
+       QVERIFY(!item.properties.contains("enabled"));
+   } else {
+       QVERIFY(item.properties.contains("enabled"));
+       QCOMPARE(item.properties.value("enabled").toBool(), false);
+   }
+   if (iconName.isEmpty()) {
+       QVERIFY(!item.properties.contains("icon-name"));
+   } else {
+       QCOMPARE(item.properties.value("icon-name").toString(), iconName);
+   }
+}
+
+void ExportedPlatformMenuTest::testGetSomeMenuItemProperties_data()
+{
+   QTest::addColumn<QString>("label");
+   QTest::addColumn<QString>("iconName");
+   QTest::addColumn<bool>("enabled");
+
+   QTest::newRow("label only")           << "label" << QString()   << true;
+   QTest::newRow("disabled, label only") << "label" << QString()   << false;
+   QTest::newRow("icon name")            << "label" << "edit-undo" << true;
+}
+
+void ExportedPlatformMenuTest::testGetSomeMenuItemProperties()
+{
+   QFETCH(QString, label);
+   QFETCH(QString, iconName);
+   QFETCH(bool, enabled);
+
+   // Create an exporter for a menu with one action, defined by the test data
+   ExportedPlatformMenuBar menuBar(TEST_OBJECT_PATH);
+   ExportedPlatformMenu menu;
+   menuBar.insertMenu(&menu, nullptr);
+
+   ExportedPlatformMenuItem menuItem1;
+   menuItem1.setText(label);
+   if (!iconName.isEmpty()) {
+       QIcon icon = QIcon::fromTheme(iconName);
+       QVERIFY(!icon.isNull());
+       menuItem1.setIcon(icon);
+   }
+   menuItem1.setEnabled(enabled);
+   menu.insertMenuItem(&menuItem1, nullptr);
+
+   // Check out exporter is on DBus
+   QDBusInterface iface(TEST_SERVICE, TEST_OBJECT_PATH);
+   QVERIFY2(iface.isValid(), qPrintable(iface.lastError().message()));
+
+   // Get exported menu info
+   QStringList propertyNames = QStringList() << "type" << "enabled" << "label" << "icon-name";
+   DBusMenuLayoutItemList list = getChildren(&iface, /*parentId=*/0, propertyNames);
+   QVERIFY(!list.isEmpty());
+
+   // Now get the mennu children (menu items)
+   list = getChildren(&iface, list.first().id, QStringList());
+   QVERIFY(!list.isEmpty());
+   DBusMenuLayoutItem item = list.first();
+
+   QVERIFY(item.id != 0);
+   QVERIFY(item.children.isEmpty());
+   QVERIFY(!item.properties.contains("type"));
+   QCOMPARE(item.properties.value("label").toString(), label);
+   if (enabled) {
+       QVERIFY(!item.properties.contains("enabled"));
+   } else {
+       QVERIFY(item.properties.contains("enabled"));
+       QCOMPARE(item.properties.value("enabled").toBool(), false);
+   }
+   if (iconName.isEmpty()) {
+       QVERIFY(!item.properties.contains("icon-name"));
+   } else {
+       QCOMPARE(item.properties.value("icon-name").toString(), iconName);
+   }
+}
+
+void ExportedPlatformMenuTest::testGetAllProperties()
+{
+   // set of properties which must be returned because their values are not
+   // the default values
+   const QSet<QString> a1Properties = QSet<QString>()
+       << "label"
+       ;
+
+   const QSet<QString> separatorProperties = QSet<QString>()
+       << "type";
+
+   const QSet<QString> a2Properties = QSet<QString>()
+       << "label"
+       << "enabled"
+       << "icon-name"
+       << "icon-data" // Icon data is always provided if the icon is valid.
+       << "visible";
+
+   ExportedPlatformMenuBar menuBar(TEST_OBJECT_PATH);
+   ExportedPlatformMenu menu;
+   menuBar.insertMenu(&menu, nullptr);
+
+   ExportedPlatformMenuItem menuItem1;
+   menuItem1.setText("m1");
+   menu.insertMenuItem(&menuItem1, nullptr);
+
+   ExportedPlatformMenuItem separator;
+   separator.setIsSeparator(true);
+   menu.insertMenuItem(&separator, nullptr);
+
+   ExportedPlatformMenuItem menuItem2;
+   menuItem2.setText("m2");
+   menuItem2.setEnabled(false);
+   menuItem2.setVisible(false);
+   QIcon icon = QIcon::fromTheme("edit-undo");
+   QVERIFY(!icon.isNull());
+   menuItem2.setIcon(icon);
+   menu.insertMenuItem(&menuItem2, nullptr);
+
+   // Export them
+   QDBusInterface iface(TEST_SERVICE, TEST_OBJECT_PATH);
+   QVERIFY2(iface.isValid(), qPrintable(iface.lastError().message()));
+
+   // Get menu children
+   DBusMenuLayoutItemList list = getChildren(&iface, menu.id(), QStringList());
+   QCOMPARE(list.count(), 3);
+
+   // Check we get the right properties
+   DBusMenuLayoutItem item = list.takeFirst();
+   QCOMPARE(QSet<QString>::fromList(item.properties.keys()), a1Properties);
+
+   item = list.takeFirst();
+   QCOMPARE(QSet<QString>::fromList(item.properties.keys()), separatorProperties);
+
+   item = list.takeFirst();
+   QCOMPARE(QSet<QString>::fromList(item.properties.keys()), a2Properties);
+}
+
+void ExportedPlatformMenuTest::testGetNonExistentProperty()
+{
+   const char* NON_EXISTENT_KEY = "i-do-not-exist";
+
+   ExportedPlatformMenuBar menuBar(TEST_OBJECT_PATH);
+   ExportedPlatformMenu menu;
+   menuBar.insertMenu(&menu, nullptr);
+
+   QDBusInterface iface(TEST_SERVICE, TEST_OBJECT_PATH);
+   DBusMenuLayoutItemList list = getChildren(&iface, 0, QStringList() << NON_EXISTENT_KEY);
+   QCOMPARE(list.count(), 1);
+
+   DBusMenuLayoutItem item = list.takeFirst();
+   QVERIFY(!item.properties.contains(NON_EXISTENT_KEY));
+}
+
+void ExportedPlatformMenuTest::testClickedEvent()
+{
+   ExportedPlatformMenuBar menuBar(TEST_OBJECT_PATH);
+   ExportedPlatformMenu menu;
+   menuBar.insertMenu(&menu, nullptr);
+
+   ExportedPlatformMenuItem menuItem1;
+   menuItem1.setText("m1");
+   menu.insertMenuItem(&menuItem1, nullptr);
+
+   QSignalSpy spy(&menuItem1, SIGNAL(activated()));
+
+   QDBusInterface iface(TEST_SERVICE, TEST_OBJECT_PATH);
+   DBusMenuLayoutItemList list = getChildren(&iface, menu.id(), QStringList());
+   QCOMPARE(list.count(), 1);
+   int id = list.first().id;
+
+   QVariant empty = QVariant::fromValue(QDBusVariant(QString()));
+   uint timestamp = QDateTime::currentDateTime().toTime_t();
+   iface.call("Event", id, "clicked", empty, timestamp);
+   QTest::qWait(100);
+
+   QCOMPARE(spy.count(), 1);
+}
+
+void ExportedPlatformMenuTest::testSubMenu()
+{
+   // Root
+   // -- submenu
+   // ---- childmenu
+   // ----- hildmenu
+
+   // Create our test menu
+   ExportedPlatformMenuBar menuBar(TEST_OBJECT_PATH);
+   ExportedPlatformMenu menu;
+   menuBar.insertMenu(&menu, nullptr);
+
+   ExportedPlatformMenu subMenu;
+   ExportedPlatformMenuItem subMenuItem;
+   subMenuItem.setMenu(&subMenu);
+   menu.insertMenuItem(&subMenuItem, nullptr);
+
+   ExportedPlatformMenuItem childMenu1;
+   ExportedPlatformMenuItem childMenu2;
+   subMenu.insertMenuItem(&childMenu1, nullptr);
+   subMenu.insertMenuItem(&childMenu2, nullptr);
+
+   // Check the structure
+   QDBusInterface iface(TEST_SERVICE, TEST_OBJECT_PATH);
+   DBusMenuLayoutItemList list = getChildren(&iface, 0, QStringList());
+   QCOMPARE(list.count(), 1);
+
+   list = getChildren(&iface, list.first().id, QStringList());
+   QCOMPARE(list.count(), 1);
+
+   list = getChildren(&iface, list.first().id, QStringList());
+   QCOMPARE(list.count(), 2);
+}
+
+void ExportedPlatformMenuTest::testDynamicSubMenu()
+{
+   // Root
+   // -- childmenu
+   // -- childmenu
+
+    // Track LayoutUpdated() signal: we don't want this signal to be emitted
+    // too often because it causes refreshes
+    QDBusInterface iface(TEST_SERVICE, TEST_OBJECT_PATH);
+    ManualSignalSpy layoutUpdatedSpy;
+    QDBusConnection::sessionBus().connect(TEST_SERVICE, TEST_OBJECT_PATH, "com.canonical.dbusmenu", "LayoutUpdated", "ui", &layoutUpdatedSpy, SLOT(receiveCall(uint, int)));
+
+    // Create our test menu
+    ExportedPlatformMenuBar menuBar(TEST_OBJECT_PATH);
+    ExportedPlatformMenu menu;
+    menuBar.insertMenu(&menu, nullptr);
+
+    // LayoutUpdated should be emitted once because inputMenu is filled
+    QTest::qWait(100);
+    QCOMPARE(layoutUpdatedSpy.count(), 1);
+    QCOMPARE(layoutUpdatedSpy.takeFirst().at(1).toInt(), 0);
+
+    ExportedPlatformMenu subMenu;
+    ExportedPlatformMenuItem subMenuItem1;
+    subMenuItem1.setMenu(&subMenu);
+    ExportedPlatformMenuItem subMenuItem2;
+    subMenuItem2.setMenu(&subMenu);
+    menu.insertMenuItem(&subMenuItem1, nullptr);
+    menu.insertMenuItem(&subMenuItem2, nullptr);
+
+    QTest::qWait(100);
+    // LayoutUpdated should be emitted once more with the parent menus id
+    // because menu item was inserted.
+    QCOMPARE(layoutUpdatedSpy.count(), 1);
+    QCOMPARE(layoutUpdatedSpy.takeFirst().at(1).toInt(), menu.id());
+
+    DBusMenuLayoutItemList list = getChildren(&iface, 0, QStringList());
+    QCOMPARE(list.count(), 1);
+
+    list = getChildren(&iface, list.first().id, QStringList());
+    QCOMPARE(list.count(), 2);
+}
+
+
+#include "exportedplatformmenutest.moc"

=== added file 'tests/exportedplatformmenutest.h'
--- tests/exportedplatformmenutest.h	1970-01-01 00:00:00 +0000
+++ tests/exportedplatformmenutest.h	2015-03-18 11:19:06 +0000
@@ -0,0 +1,55 @@
+/* This file is part of the dbusmenu-qt library
+   Copyright 2015 Canonical
+   Author: Aurelien Gateau <[e-mail]>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License (LGPL) as published by the Free Software Foundation;
+   either version 2 of the License, or (at your option) any later
+   version.
+
+   This library 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
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this library; see the file COPYING.LIB.  If not, write to
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.
+*/
+#ifndef EXPORTEDPLATFORMMENUTEST_H
+#define EXPORTEDPLATFORMMENUTEST_H
+
+#define QT_GUI_LIB
+#include <QtGui>
+
+// Qt
+#include <QObject>
+
+// Local
+
+class ExportedPlatformMenuTest : public QObject
+{
+Q_OBJECT
+private Q_SLOTS:
+    // properties
+    void testGetSomeMenuProperties();
+    void testGetSomeMenuProperties_data();
+    void testGetSomeMenuItemProperties();
+    void testGetSomeMenuItemProperties_data();
+    void testGetAllProperties();
+    void testGetNonExistentProperty();
+
+    // events
+    void testClickedEvent();
+
+    // heirachy
+    void testSubMenu();
+    void testDynamicSubMenu();
+
+    void init();
+    void cleanup();
+};
+
+#endif /* EXPORTEDPLATFORMMENUTEST_H */

=== modified file 'tests/testutils.h'
--- tests/testutils.h	2011-08-29 14:51:01 +0000
+++ tests/testutils.h	2015-03-18 11:19:06 +0000
@@ -23,7 +23,7 @@
 
 // Local
 #include <debug_p.h>
-#include <dbusmenutypes_p.h>
+#include <dbusmenutypes.h>
 
 // Qt
 #include <QObject>