Merge into trunk : menuTheme : Code : qtubuntu

Status:	Merged
Approved by:	Gerry Boland on 2017-01-11
Approved revision:	319
Merged at revision:	362
Proposed branch:	lp:~nick-dedekind/qtubuntu/menuTheme
Merge into:	lp:qtubuntu
Diff against target:	2206 lines (+1850/-36) 28 files modified README (+3/-2) debian/control (+12/-0) debian/gles-patches/convert-to-gles.patch (+23/-10) debian/qtubuntu-appmenutheme.install (+1/-0) debian/rules (+1/-0) src/src.pro (+1/-1) src/ubuntuappmenu/com.ubuntu.MenuRegistrar.xml (+83/-0) src/ubuntuappmenu/gmenumodelexporter.cpp (+350/-0) src/ubuntuappmenu/gmenumodelexporter.h (+83/-0) src/ubuntuappmenu/gmenumodelplatformmenu.cpp (+526/-0) src/ubuntuappmenu/gmenumodelplatformmenu.h (+181/-0) src/ubuntuappmenu/logging.h (+27/-0) src/ubuntuappmenu/menuregistrar.cpp (+137/-0) src/ubuntuappmenu/menuregistrar.h (+59/-0) src/ubuntuappmenu/registry.cpp (+97/-0) src/ubuntuappmenu/registry.h (+56/-0) src/ubuntuappmenu/theme.cpp (+46/-13) src/ubuntuappmenu/theme.h (+9/-4) src/ubuntuappmenu/themeplugin.cpp (+36/-0) src/ubuntuappmenu/themeplugin.h (+34/-0) src/ubuntuappmenu/ubuntuappmenu.json (+3/-0) src/ubuntuappmenu/ubuntuappmenu.pro (+41/-0) src/ubuntumirclient/integration.cpp (+24/-3) src/ubuntumirclient/nativeinterface.cpp (+3/-0) src/ubuntumirclient/plugin.cpp (+3/-0) src/ubuntumirclient/ubuntumirclient.pro (+4/-3) src/ubuntumirclient/window.cpp (+5/-0) src/ubuntumirclient/window.h (+2/-0)
To merge this branch:	bzr merge lp:~nick-dedekind/qtubuntu/menuTheme
Related bugs:	Link a bug report

Reviewer	Review Type	Date Requested	Status
Gerry Boland		2016-06-09	Approve on 2017-01-11
Unity8 CI Bot	continuous-integration		Approve on 2017-01-11
Timo Jyrinki			Approve on 2017-01-03
Review via email: mp+296997@code.launchpad.net

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-06-09:

#

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/74/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-06-09:

#

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/75/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-06-09:

#

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/76/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-06-10:

#

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/77/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-06-17:

#

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/79/rebuild

review: Approve (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-06-20:

#

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/84/rebuild

review: Approve (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-06-21:

#

FAILED: Continuous integration, rev:295
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/86/
Executed test runs:
FAILURE: https://unity8-jenkins.ubuntu.com/job/build/2105/console
FAILURE: https://unity8-jenkins.ubuntu.com/job/build-0-fetch/2133/console

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/86/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-06-21:

#

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/87/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-06-22:

#

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/88/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-06-22:

#

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/89/rebuild

review: Approve (continuous-integration)

Gerry Boland (gerboland) wrote on 2016-08-11:

#

Hey,
this was bigger than I was expecting!

Questions:
1. how do I test this?
2. is the theme plugin totally independent from the QPA plugin? I see you moved the QPA's theme code into the Integration code. Why? Just to indicate the majority of the theming is elsewhere?

~/dev/projects/qtubuntu/menuTheme/src ⮀ l
src.pro ubuntuappmenu/ ubuntumirclient/
~/dev/projects/qtubuntu/menuTheme/src ⮀ cd ubuntu<TAB><TAB>
ubuntuappmenu/ ubuntumirclient/
/me hating how we prefix everything with "ubuntu".

I'm just looking at the QPA for now
- you add persistentSurfaceId - can it be a QByteArray instead of QString?

+ // queue the windowPropertyChanged signal. If it's emitted directly, the platformWindow will not yet be set for the window.
+ QMetaObject::invokeMethod(mNativeInterface, "windowPropertyChanged", Qt::QueuedConnection,
+ Q_ARG(QPlatformWindow*, this),
+ Q_ARG(QString, "persistentSurfaceId"));
How does a persistent Surface ID ever change?

+ return QStringList("ubuntuappmenu");
QStringLiteral please.

-Q_LOGGING_CATEGORY(ubuntumirclientInput, "ubuntumirclient.input", QtWarningMsg)
+Q_LOGGING_CATEGORY(ubuntumirclientInput, "ubuntu.mirclient.input", QtWarningMsg)
Why? This breaks the standard elsewhere in the code. Check the README too.

review: Needs Fixing

Gerry Boland (gerboland) wrote on 2016-08-12:

#

=== modified file 'debian/control'
What dependency will pull in this new qtubuntu-appmenutheme? The QPAs?

+Build-Depends: ${misc:Depends},
+ ${shlibs:Depends},
bad indent

Nick Dedekind (nick-dedekind) wrote on 2016-08-23:

#

> === modified file 'debian/control'
> What dependency will pull in this new qtubuntu-appmenutheme? The QPAs?

I would probably say it's whatever pulls in unity8/qtubuntu. unity8-desktop-session/ubuntu-touch-session?

>
> +Build-Depends: ${misc:Depends},
> + ${shlibs:Depends},
> bad indent

Fixed.

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-08-23:

#

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/107/rebuild

review: Approve (continuous-integration)

Nick Dedekind (nick-dedekind) wrote on 2016-08-23:

#

>
> I'm just looking at the QPA for now
> - you add persistentSurfaceId - can it be a QByteArray instead of QString?

Done.

>
> + // queue the windowPropertyChanged signal. If it's emitted directly, the
> platformWindow will not yet be set for the window.
> + QMetaObject::invokeMethod(mNativeInterface, "windowPropertyChanged",
> Qt::QueuedConnection,
> + Q_ARG(QPlatformWindow*, this),
> + Q_ARG(QString, "persistentSurfaceId"));
> How does a persistent Surface ID ever change?

It doesn't change but the platform window is created after the QWindow, and therefore could be created after an attached menubar; so when the exporter initially asks for the surface id, it wont be set yet, therefore we need to be notified when it is.

>
> + return QStringList("ubuntuappmenu");
> QStringLiteral please.

Done

>
> -Q_LOGGING_CATEGORY(ubuntumirclientInput, "ubuntumirclient.input",
> QtWarningMsg)
> +Q_LOGGING_CATEGORY(ubuntumirclientInput, "ubuntu.mirclient.input",
> QtWarningMsg)
> Why? This breaks the standard elsewhere in the code. Check the README too.

I've changed it everywhere in the code now. Since it's kind of like a url i think it should be this way for better "domain" control.
We also have "ubuntu.appmenu" so to get all the logging from qtubuntu, we can do "QT_LOGGING_RULES=ubuntu.*=true"

* I think it should really be "qtubuntu.mirclient/appmenu"

Nick Dedekind (nick-dedekind) wrote on 2016-08-23:

#

If you'd rather just leave the log categories as ubuntumirclient/ubuntuappmenu, let me know and i'll change them all back.

Nick Dedekind (nick-dedekind) wrote on 2016-08-23:

#

> Hey,
> this was bigger than I was expecting!
>
> Questions:
> 1. how do I test this?

I'll sort out something to test with.

> 2. is the theme plugin totally independent from the QPA plugin? I see you
> moved the QPA's theme code into the Integration code. Why? Just to indicate
> the majority of the theming is elsewhere?

They're both independent of each other, but ubuntuappmenu relies on a persistent surface id to be set to work correctly, so there is a "soft" dependence their.

The theme in the integration is just a fallback theme in case ubuntuappmenu isn't installed. I didn't think it really needed it's own files since it isn't instantiable outside the integration (No QT_QPA_PLATFORMTHEME option).
The reason for separating the theme into a different package was so that it is very easy to revert or replace. Just uninstall the package.

>
>
> ~/dev/projects/qtubuntu/menuTheme/src ⮀ l
> src.pro ubuntuappmenu/ ubuntumirclient/
> ~/dev/projects/qtubuntu/menuTheme/src ⮀ cd ubuntu<TAB><TAB>
> ubuntuappmenu/ ubuntumirclient/
> /me hating how we prefix everything with "ubuntu".
>

yes...

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-08-24:

#

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/109/rebuild

review: Approve (continuous-integration)

Nick Dedekind (nick-dedekind) wrote on 2016-08-24:

#

Righty'O

I've added a testing file to https://code.launchpad.net/~nick-dedekind/unity8/menus.
You'll need to build this because it has the server side of the menu registry, but otherwise the test file sits in isolation to any thing else.
The test file is in "qml/ApplicationMenus/Test.qml"

So:
1) Get and build deps for unity8 branch.
lp:~unity-team/unity-api/persistent_surface_id
2) Get and build lp:~nick-dedekind/unity8/menus.
3) Start test with: QML2_IMPORT_PATH=./builddir/plugins qmlscene qml/ApplicationMenus/Test.qml

4) new term
5) mir_demo_server

6) new term
7) create a qml example with menus. (MenuAPI.qml example graciously provided by dednick http://pastebin.ubuntu.com/23084706/)
8) Build and install this qtubuntu branch
9) QT_LOGGING_RULES=ubuntu.appmenu*=true QT_QPA_PLATFORMTHEME= QT_QPA_PLATFORM=ubuntumirclient qmlscene MenuAPI.qml

Tadaa. hopefully. you should see a bunch of log output from ubuntu.appmenu, and from ubuntu.appmenu.registrar if it successfully connected to the registry.
The Test.qml should also contain a pretty printed output of the exported menus it's picked up from dbus.

Gerry Boland (gerboland) wrote on 2016-09-28:

#

=== modified file 'README'
+ * ubuntu.mirclient - For all other messages frm the ubuntumirclient QPA.
+ * ubuntu.appmenu - For all messages frm the ubuntuappmenu QPA theme.
typo: "from"

=== modified file 'debian/control'
+ appmenutheme provides you with an integrated application menu in your global
+ menu bar. It functions as a QPA platformtheme plugin.
I just want to edit this to remove the subject from the sentence:
Appmenutheme enables the export of application menus to a global menu bar. It is implemented in a QPA platform theme plugin.

=== added file 'src/ubuntuappmenu/com.ubuntu.MenuRegistrar.xml'
+ main interface is docuemented here: @ref com::ubuntu::MenuRegistrar.
typo: "documented"

+ ensure this method is called with the same connection that implmenets the object.
and one more "implements"

+ Associates a gmenumodel with a application
typo: "an application"

+ <arg name="menuObjectPath" type="o" direction="in">
+ <dox:d>The object on the dbus interface implementing the gmenumodel interface</dox:d>
+ </arg>
+ <arg name="actionObjectPath" type="o" direction="in">
+ <dox:d>The object on the dbus interface implementing the gmenumodel interface</dox:d>
Documentation text could be slightly better (in both RegisterAppMenu and RegisterSurfaceMenu)

+ A method to allow removing a application menu from the database.
same typo: "an application"

+ ensure this method is called with the same connection that implmenets the object.
"implements" again

review: Needs Fixing

Gerry Boland (gerboland) wrote on 2016-09-28:

#

Download full text (3.8 KiB)

+++ src/ubuntuappmenu/gmenumodelexporter.h
+class GMenuModelExporter : public QObject
I was curious if this really needed to be a QObject, but you do use that fact to ensure lifetimes of the objects in signal/lambda connections are correct. So it's ok.

+ QList<QMetaObject::Connection> m_propertyConnections;
I understand why you do this, because QObject::disconnect must have a sender (i.e. first argument) set.

But GMenuModelPlatformMenuItem are QObjects, so on deletion they will clean up their connections. Is that not enough? Do they clean up too late?

+++ src/ubuntuappmenu/gmenumodelexporter.cpp
+inline QString getActionString(const QString& label) {
opening brace on newline - just for consistency.

+ for(auto iter = parts.begin(); iter != parts.end(); ++iter) {
space after the "for" - could you not use Q_FOREACH(const auto &part, parts) and save messing with iterators?

I'd also appreciate an explanatory comment of what "getActionString" is doing.

+ auto item = (GMenuModelPlatformMenuItem*)user_data;
Use C++ static_cast<> please

+#define MENU_OBJECT_PATH QString("/com/ubuntu/Menu/%1")
QStringLiteral would work. But odd to define more than a character constant here,
#define MENU_OBJECT_PATH "/com/ubuntu/Menu/%1"
would be more typical

+ GMenuModelBarExporter::GMenuModelBarExporter(GMenuModelPlatformMenuBar * bar)
+ auto iter = bar->menus().begin();
+ for (; iter != bar->menus().end(); ++iter) {
Q_FOREACH nicer, no? You use these style loops everywhere, any reason?

Also, a quick comment explaining the purpose of these classes and each method would help other readers. I'm especially obsessed with documenting methods that return GThing* pointers, to clearly indicate if or how the returned GThings* should be cleaned up by the consumer.

+ GError *error = NULL;
I see lots of NULL here, can we not use nullptr, or is G stuff incompatible with it? /me obsessed with C++11 goodies

+ bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
leak, is never unref-ed.

+ m_exportedModel = g_dbus_connection_export_menu_model(bus, menuPath.constData(), G_MENU_MODEL(m_gmainMenu), &error);
g_dbus_connection_export_menu_model returns a guint, unsigned int. m_exportedModel is an int. Implicit lossy conversion here, definitely safe?

+ error = NULL;
Leak, you should be doing g_error_free (err)

+ GMenuModelPlatformMenu* gplatformMenu = qobject_cast<GMenuModelPlatformMenu*>(platformMenu);
I see this a bunch of places, it can be simpler:
auto gplatformMenu = static_cast<GMenuModelPlatformMenu*>(platformMenu);

+void GMenuModelExporter::addSubmenuItems(GMenuModelPlatformMenu* gplatformMenu, GMenu* menu)
There's a lot going on here, quick comment explaining the intention would be good. I'm just looking at the code, it appears fine. Q_FOREACH not suitable, but you can use static_cast instead of qobject_cast here.

+ bool checkable(GMenuModelPlatformMenuItem::get_checkable(gplatformMenuItem));
I prefer = instead of () assignment for simple types - same line could be misinterpreted as a function declaration
same for "checked" inside the conditional.

+ std::function<void(bool)> updateChecked = [gplatformMenuItem, action](bool checked) {
perf...

Nick Dedekind (nick-dedekind) wrote on 2016-09-29:

#

> === added file 'src/ubuntuappmenu/gmenumodelplatformmenu.h'
>
> + GMenuModelExporter* m_exporter;
> + MenuRegistrar* m_registrar;
> If you used QScopedPointer, you would not need to worry about deleting them in
> a destructor. And then can have a trivial destructor
>
> +class Q_DECL_EXPORT GMenuModelPlatformMenu : public QPlatformMenu
> + GMenuModelExporter* m_exporter;
> + MenuRegistrar* m_registrar;
> same as above, but you'll need to set them with reset(). Note you're leaking
> these currently.
>
>
>
> === added file 'src/ubuntuappmenu/gmenumodelplatformmenu.cpp'
> +int logRecusion = 0;
> polluting the global namespace, please stuck in an anonymous NS.
>
> + connect(menu, SIGNAL(structureChanged()), this, SIGNAL(structureChanged()));
> new style connect statement gives us compile-time checking of this, please
> convert. I see this 2 times
>
>
> for (auto iter = m_menus.begin(); iter != m_menus.end(); ++iter) {
> I think there's the odd loop you could convert to Q_FOREACH. menuForTag &
> menuItemForTag anyway
>
> +QDebug GMenuModelPlatformMenuBar::operator<<(QDebug stream)
> + auto myMenu = qobject_cast<GMenuModelPlatformMenu*>(menu);
> static_cast works
>
> +void GMenuModelPlatformMenuBar::setReady(bool _ready)
> underscore, yuk! :) Just "ready" please
>
>
> === added file 'src/ubuntuappmenu/menuregistrar.cpp'
> +bool isMirClient() {
> + return qgetenv("QT_QPA_PLATFORM") == "ubuntumirclient";
> +}
> move to anonymous NS please, and qGuiApp->platformName() would be a safer
> thing to check.
>
>
> + : m_registeredProcessId(~0)
> Putting my security hat on for a second, it is not impossible for an
> application to have a pid ~0, and also pid 0 (I believe pids can wrap around).
> Highly unlikely, but an attack vector. Consequences here aren't dire, so I'm
> ok with it.
>
> std::optional is nice to avoid such munging of set/unset with value.
>

C++17 only.

>
> + bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
> leaked again here. NULLs!
>
> + if (!bus) {
> + qCWarning(ubuntuappmenuRegistrar, "Failed to retreive session bus - %s",
> error ? error->message : "unknown error");
> error leaked here
>
> +void MenuRegistrar::unregisterApplicationMenu()
> +{
> + if (!UbuntuMenuRegistry::instance()->isConnected()) {
> + m_registeredProcessId = ~0;
> + return;
> + }
> + UbuntuMenuRegistry::instance()->unregisterApplicationMenu(m_registeredPro
> cessId, m_path);
> + m_registeredProcessId = ~0;
> +}
>
> m_registeredProcessId = ~0; happens nonetheless, an if/else would save the
> duplicate line.

Done.

Nick Dedekind (nick-dedekind) wrote on 2016-09-29:

#

Think I got everything.

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-09-29:

#

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/133/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-09-29:

#

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/134/rebuild

review: Needs Fixing (continuous-integration)

Nick Dedekind (nick-dedekind) wrote on 2016-09-30:

#

I'll sort out the namespacing in another MP I; along with changes to the logging categories. For now i've just left them in the current format.

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-09-30:

#

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/135/rebuild

review: Approve (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-09-30:

#

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/136/rebuild

review: Approve (continuous-integration)

Gerry Boland (gerboland) wrote on 2016-09-30:

#

> > std::optional is nice to avoid such munging of set/unset with value.
> >
>
> C++17 only.

Damnit yes.

> I'll sort out the namespacing in another MP I; along with changes to
> the logging categories. For now i've just left them in the current format.

Ok.

Gerry Boland (gerboland) wrote on 2016-09-30:

#

Only 1 thing missed:

=== added file 'src/ubuntuappmenu/menuregistrar.cpp'
+bool isMirClient() {
+ return qgetenv("QT_QPA_PLATFORM") == "ubuntumirclient";
+}
qGuiApp->platformName() would be a safer thing to check.

You've addressed everything else

review: Needs Fixing

Nick Dedekind (nick-dedekind) wrote on 2016-09-30:

#

> Only 1 thing missed:
>
> === added file 'src/ubuntuappmenu/menuregistrar.cpp'
> +bool isMirClient() {
> + return qgetenv("QT_QPA_PLATFORM") == "ubuntumirclient";
> +}
> qGuiApp->platformName() would be a safer thing to check.
>
> You've addressed everything else

Fixed.

Nick Dedekind (nick-dedekind) wrote on 2016-09-30:

#

You will also need lp:~nick-dedekind/qmenumodel/desktop_menus to test.

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-09-30:

#

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/137/rebuild

review: Approve (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-09-30:

#

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/138/rebuild

review: Approve (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-10-05:

#

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/141/rebuild

review: Approve (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-10-10:

#

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/142/rebuild

review: Approve (continuous-integration)

Timo Jyrinki (timo-jyrinki) wrote on 2016-10-12:

#

The gles version of qtubuntu-appmenutheme should only build for amd64 and i386 like the others.

review: Needs Fixing

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-10-12:

#

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/143/rebuild

review: Approve (continuous-integration)

Gerry Boland (gerboland) wrote on 2016-10-26:

#

Overall this looks good, can approve

review: Approve

Timo Jyrinki (timo-jyrinki) wrote on 2017-01-03:

#

Looks fine to me too.

review: Approve

Unity8 CI Bot (unity8-ci-bot) wrote on 2017-01-04:

#

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/167/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2017-01-11:

#

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/168/rebuild

review: Approve (continuous-integration)

Gerry Boland (gerboland) on 2017-01-11:

#

review: Approve

qtubuntu

Merge lp:~nick-dedekind/qtubuntu/menuTheme into lp:qtubuntu

Commit Message

Description of the Change

Preview Diff

Subscribers

 === modified file 'README'
 --- README	2016-06-22 17:16:33 +0000
 +++ README	2016-12-09 17:04:44 +0000
@@ -48,7 +48,9 @@
    * ubuntumirclient.input       - Messages related to input and other Mir events.
    * ubuntumirclient.graphics    - Messages related to graphics, GL and EGL.
    * ubuntumirclient.swapBuffers - Messages related to surface buffer swapping.
--  * ubuntumirclient             - For all other messages.
++  * ubuntumirclient             - For all other messages form the ubuntumirclient QPA.
++  * ubuntuappmenu.registrar     - Messages related to application menu registration.
++  * ubuntuappmenu               - For all other messages form the ubuntuappmenu QPA theme.
    The QT_QPA_EGLFS_DEBUG environment variable prints a little more information
    from Qt's internals.
@@ -99,4 +101,3 @@
    [1] http://doc-snapshot.qt-project.org/5.0/qabstractnativeeventfilter.html
    [2] http://doc-snapshot.qt-project.org/5.0/qcoreapplication.html#installNativeEventFilter
--
 === modified file 'debian/control'
 --- debian/control	2016-09-22 19:45:30 +0000
 +++ debian/control	2016-12-09 17:04:44 +0000
@@ -66,3 +66,15 @@
   plugins.
+  .
   This variant of the package is for GNU-based desktops.
++
++Package: qtubuntu-appmenutheme
++Architecture: any
++Multi-Arch: same
++Depends: ${misc:Depends},
++         ${shlibs:Depends},
++Description: Qt platform theme for exported application menus
++ Appmenutheme enables the export of application menus to a global menu bar.
++ It is implemented in a QPA platform theme plugin.
++ .
++ This package will work for applications designed for Qt5, as well as QML
++ applications
 === modified file 'debian/gles-patches/convert-to-gles.patch'
 --- debian/gles-patches/convert-to-gles.patch	2016-06-03 10:36:39 +0000
 +++ debian/gles-patches/convert-to-gles.patch	2016-12-09 17:04:44 +0000
@@ -1,14 +1,14 @@
--Index: cross-build-support/debian/control
++Index: qtubuntu/debian/control
  ===================================================================
----- cross-build-support.orig/debian/control
--+++ cross-build-support/debian/control
++--- qtubuntu.orig/debian/control
+++++ qtubuntu/debian/control
@@ -1,4 +1,4 @@
  -Source: qtubuntu
  +Source: qtubuntu-gles
   Priority: optional
   Maintainer: Ubuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>
   Build-Depends: debhelper (>= 9),
--@@ -11,11 +11,20 @@ Build-Depends: debhelper (>= 9),
++@@ -12,11 +12,20 @@ Build-Depends: debhelper (>= 9),
                  libinput-dev,
                  libmirclient-dev (>= 0.13.0),
                  libmtdev-dev,
@@ -29,7 +29,7 @@
                  quilt,
   # if you don't have have commit access to this branch but would like to upload
   # directly to Ubuntu, don't worry: your changes will be merged back into the
--@@ -25,7 +34,7 @@ Standards-Version: 3.9.6
++@@ -26,7 +35,7 @@ Standards-Version: 3.9.6
   Section: libs
   Package: qtubuntu-android
@@ -38,7 +38,7 @@
   Multi-Arch: same
   Conflicts: qtubuntu-desktop,
   Replaces: qtubuntu (<< 0.52),
--@@ -36,31 +45,12 @@ Provides: qtubuntu,
++@@ -37,43 +46,12 @@ Provides: qtubuntu,
   Depends: ubuntu-application-api3-touch,
            ${misc:Depends},
            ${shlibs:Depends},
@@ -71,13 +71,25 @@
  - plugins.
  - .
  - This variant of the package is for GNU-based desktops.
++-
++-Package: qtubuntu-appmenutheme
++-Architecture: any
++-Multi-Arch: same
++-Depends: ${misc:Depends},
++-         ${shlibs:Depends},
++-Description: Qt platform theme for exported application menus
++- Appmenutheme enables the export of application menus to a global menu bar.
++- It is implemented in a QPA platform theme plugin.
++- .
++- This package will work for applications designed for Qt5, as well as QML
++- applications
  + This variant of the package is for Android-based phones and tablets (built
  + against the OpenGLES variant of qtbase).
--Index: cross-build-support/debian/rules
++Index: qtubuntu/debian/rules
  ===================================================================
----- cross-build-support.orig/debian/rules
--+++ cross-build-support/debian/rules
--@@ -5,60 +5,35 @@ export DPKG_GENSYMBOLS_CHECK_LEVEL=4
++--- qtubuntu.orig/debian/rules
+++++ qtubuntu/debian/rules
++@@ -5,61 +5,35 @@ export DPKG_GENSYMBOLS_CHECK_LEVEL=4
   export QT_SELECT=5
   ANDROID_DIR = build-android
@@ -139,3 +151,4 @@
   	dh_install --sourcedir=$(TMP1_DIR) -pqtubuntu-android
  -endif
  -	dh_install --sourcedir=$(TMP2_DIR) -pqtubuntu-desktop
++-	dh_install --sourcedir=$(TMP2_DIR) -pqtubuntu-appmenutheme
 === added file 'debian/qtubuntu-appmenutheme.install'
 --- debian/qtubuntu-appmenutheme.install	1970-01-01 00:00:00 +0000
 +++ debian/qtubuntu-appmenutheme.install	2016-12-09 17:04:44 +0000
@@ -0,0 +1,1 @@
++usr/lib/*/qt5/plugins/platformthemes/*
 === modified file 'debian/rules'
 --- debian/rules	2016-06-03 09:38:55 +0000
 +++ debian/rules	2016-12-09 17:04:44 +0000
@@ -62,3 +62,4 @@
  	dh_install --sourcedir=$(TMP1_DIR) -pqtubuntu-android
  endif
  	dh_install --sourcedir=$(TMP2_DIR) -pqtubuntu-desktop
++	dh_install --sourcedir=$(TMP2_DIR) -pqtubuntu-appmenutheme
 === modified file 'src/src.pro'
 --- src/src.pro	2014-06-18 23:10:00 +0000
 +++ src/src.pro	2016-12-09 17:04:44 +0000
@@ -1,3 +1,3 @@
  TEMPLATE = subdirs
--SUBDIRS += ubuntumirclient
++SUBDIRS += ubuntumirclient ubuntuappmenu
 === added directory 'src/ubuntuappmenu'
 === added file 'src/ubuntuappmenu/com.ubuntu.MenuRegistrar.xml'
 --- src/ubuntuappmenu/com.ubuntu.MenuRegistrar.xml	1970-01-01 00:00:00 +0000
 +++ src/ubuntuappmenu/com.ubuntu.MenuRegistrar.xml	2016-12-09 17:04:44 +0000
@@ -0,0 +1,83 @@
++<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN" "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
++<node xmlns:dox="http://www.ayatana.org/dbus/dox.dtd">
++        <dox:d><![CDATA[
++          @mainpage
++
++          An interface to register menus that are associated with a window in an application.  The
++          main interface is documented here: @ref com::ubuntu::MenuRegistrar.
++
++          The actual menus are transported using the gmenumodel protocol
++        ]]></dox:d>
++        <interface name="com.ubuntu.MenuRegistrar" xmlns:dox="http://www.ayatana.org/dbus/dox.dtd">
++                <dox:d>
++                  An interface to register a menu from an application to be displayed in another
++                  window.  This manages that association between processes and/or Mir surface IDs and the dbus
++                  address and object that provides the menus using the  org.gtk.Menus interface.
++                </dox:d>
++                <method name="RegisterAppMenu">
++                        <dox:d><![CDATA[
++                          Associates a gmenumodel with an application
++
++                          /note this method assumes that the connection from the caller is the DBus connection
++                            to use for the object.  Applications that use multiple DBus connections will need to
++                            ensure this method is called with the same connection that implements the object.
++                        ]]></dox:d>
++                        <arg name="pid" type="u" direction="in">
++                                <dox:d>The process ID of the application for which the menu is associated</dox:d>
++                        </arg>
++                        <arg name="menuObjectPath" type="o" direction="in">
++                                <dox:d>The dbus path where the gmenumodel interface for the application menu has been exported</dox:d>
++                        </arg>
++                        <arg name="actionObjectPath" type="o" direction="in">
++                                <dox:d>The dbus path where the gactionmenu interface for the application menu actions has been exported</dox:d>
++                        </arg>
++                        <arg name="service" type="s" direction="in">
++                            <dox:d>The dbus conection name of the client application to be registered (e.g. :1.23 or org.example.service)</dox:d>
++                        </arg>
++                </method>
++                <method name="UnregisterAppMenu">
++                        <dox:d>
++                          A method to allow removing an application menu from the database.
++                        </dox:d>
++                        <arg name="pid" type="u" direction="in">
++                                <dox:d>The process id of the application</dox:d>
++                        </arg>
++                        <arg name="menuObjectPath" type="o" direction="in">
++                                <dox:d>The dbus path for the registered application menu to be unregistered</dox:d>
++                        </arg>
++                </method>
++
++                <method name="RegisterSurfaceMenu">
++                        <dox:d><![CDATA[
++                          Associates a gmenumodel with a surface
++
++                          /note this method assumes that the connection from the caller is the DBus connection
++                            to use for the object.  Applications that use multiple DBus connections will need to
++                            ensure this method is called with the same connection that implements the object.
++                        ]]></dox:d>
++                        <arg name="surface" type="s" direction="in">
++                                <dox:d>The surface ID of the surface</dox:d>
++                        </arg>
++                        <arg name="menuObjectPath" type="o" direction="in">
++                                <dox:d>The dbus path where the gmenumodel interface for the surface menu has been exported</dox:d>
++                        </arg>
++                        <arg name="actionObjectPath" type="o" direction="in">
++                                <dox:d>The dbus path where the gactionmenu interface for the surface menu actions has been exported</dox:d>
++                        </arg>
++                        <arg name="service" type="s" direction="in">
++                            <dox:d>The dbus conection name of the client application to be registered (e.g. :1.23 or org.example.service)</dox:d>
++                        </arg>
++                </method>
++                <method name="UnregisterSurfaceMenu">
++                        <dox:d>
++                          A method to allow removing a surface menu from the database.
++                        </dox:d>
++                        <arg name="surfaceId" type="s" direction="in">
++                                <dox:d>The surface id of the surface</dox:d>
++                        </arg>
++                        <arg name="menuObjectPath" type="o" direction="in">
++                                <dox:d>The dbus path for the registered surface menu to be unregistered</dox:d>
++                        </arg>
++                </method>
++        </interface>
++</node>
 === added file 'src/ubuntuappmenu/gmenumodelexporter.cpp'
 --- src/ubuntuappmenu/gmenumodelexporter.cpp	1970-01-01 00:00:00 +0000
 +++ src/ubuntuappmenu/gmenumodelexporter.cpp	2016-12-09 17:04:44 +0000
@@ -0,0 +1,350 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it under
++ * the terms of the GNU Lesser General Public License version 3, as published by
++ * the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
++ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++ * Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++// Local
++#include "gmenumodelexporter.h"
++#include "registry.h"
++#include "logging.h"
++
++#include <QDebug>
++
++#include <functional>
++
++namespace {
++
++// Derive an action name from the label by removing spaces and Capitilizing the words.
++// Also remove mnemonics from the label.
++inline QString getActionString(QString label)
++{
++    QRegExp re("\\W");
++    label = label.replace(QRegExp("(&|_)"), "");
++    QStringList parts = label.split(re, QString::SkipEmptyParts);
++
++    QString result;
++    Q_FOREACH(const QString& part, parts) {
++        result += part[0].toUpper();
++        result += part.right(part.length()-1);
++    }
++    return result;
++}
++
++static void activate_cb(GSimpleAction *action, GVariant *, gpointer user_data)
++{
++    qCDebug(ubuntuappmenu, "Activate menu action '%s'", g_action_get_name(G_ACTION(action)));
++    auto item = static_cast<UbuntuPlatformMenuItem*>(user_data);
++    item->activated();
++}
++
++static uint s_menuId = 0;
++
++#define MENU_OBJECT_PATH "/com/ubuntu/Menu/%1"
++
++} // namespace
++
++
++UbuntuMenuBarExporter::UbuntuMenuBarExporter(UbuntuPlatformMenuBar * bar)
++    : UbuntuGMenuModelExporter(bar)
++{
++    qCDebug(ubuntuappmenu, "UbuntuMenuBarExporter::UbuntuMenuBarExporter");
++
++    connect(bar, &UbuntuPlatformMenuBar::structureChanged, this, [this]() {
++        m_structureTimer.start();
++    });
++    connect(&m_structureTimer, &QTimer::timeout, this, [this, bar]() {
++        clear();
++        Q_FOREACH(QPlatformMenu *platformMenu, bar->menus()) {
++            GMenuItem* item = createSubmenu(platformMenu, nullptr);
++            if (item) {
++                g_menu_append_item(m_gmainMenu, item);
++                g_object_unref(item);
++            }
++        }
++    });
++
++    connect(bar, &UbuntuPlatformMenuBar::ready, this, [this]() {
++        exportModels();
++    });
++}
++
++UbuntuMenuBarExporter::~UbuntuMenuBarExporter()
++{
++    qCDebug(ubuntuappmenu, "UbuntuMenuBarExporter::~UbuntuMenuBarExporter");
++}
++
++UbuntuMenuExporter::UbuntuMenuExporter(UbuntuPlatformMenu *menu)
++    : UbuntuGMenuModelExporter(menu)
++{
++    qCDebug(ubuntuappmenu, "UbuntuMenuExporter::UbuntuMenuExporter");
++
++    connect(menu, &UbuntuPlatformMenu::structureChanged, this, [this]() {
++        m_structureTimer.start();
++    });
++    connect(&m_structureTimer, &QTimer::timeout, this, [this, menu]() {
++        clear();
++        addSubmenuItems(menu, m_gmainMenu);
++    });
++    addSubmenuItems(menu, m_gmainMenu);
++}
++
++UbuntuMenuExporter::~UbuntuMenuExporter()
++{
++    qCDebug(ubuntuappmenu, "UbuntuMenuExporter::~UbuntuMenuExporter");
++}
++
++UbuntuGMenuModelExporter::UbuntuGMenuModelExporter(QObject *parent)
++    : QObject(parent)
++    , m_connection(nullptr)
++    , m_gmainMenu(g_menu_new())
++    , m_gactionGroup(g_simple_action_group_new())
++    , m_exportedModel(0)
++    , m_exportedActions(0)
++    , m_menuPath(QStringLiteral(MENU_OBJECT_PATH).arg(s_menuId++))
++{
++    m_structureTimer.setSingleShot(true);
++    m_structureTimer.setInterval(0);
++}
++
++UbuntuGMenuModelExporter::~UbuntuGMenuModelExporter()
++{
++    unexportModels();
++    clear();
++
++    g_object_unref(m_gmainMenu);
++    g_object_unref(m_gactionGroup);
++}
++
++// Clear the menu and actions that have been created.
++void UbuntuGMenuModelExporter::clear()
++{
++    Q_FOREACH(const QMetaObject::Connection& connection, m_propertyConnections) {
++        QObject::disconnect(connection);
++    }
++
++    g_menu_remove_all(m_gmainMenu);
++
++    Q_FOREACH(const QByteArray& action, m_actions) {
++        g_action_map_remove_action(G_ACTION_MAP(m_gactionGroup), action.constData());
++    }
++    m_actions.clear();
++}
++
++// Export the model on dbus
++void UbuntuGMenuModelExporter::exportModels()
++{
++    GError *error = nullptr;
++    m_connection = g_bus_get_sync (G_BUS_TYPE_SESSION, nullptr, &error);
++    if (!m_connection) {
++        qCWarning(ubuntuappmenu, "Failed to retreive session bus - %s", error ? error->message : "unknown error");
++        g_error_free (error);
++        return;
++    }
++
++    QByteArray menuPath(m_menuPath.toUtf8());
++
++    if (m_exportedModel == 0) {
++        m_exportedModel = g_dbus_connection_export_menu_model(m_connection, menuPath.constData(), G_MENU_MODEL(m_gmainMenu), &error);
++        if (m_exportedModel == 0) {
++            qCWarning(ubuntuappmenu, "Failed to export menu - %s", error ? error->message : "unknown error");
++            g_error_free (error);
++            error = nullptr;
++        } else {
++            qCDebug(ubuntuappmenu, "Exported menu on %s", g_dbus_connection_get_unique_name(m_connection));
++        }
++    }
++
++    if (m_exportedActions == 0) {
++        m_exportedActions = g_dbus_connection_export_action_group(m_connection, menuPath.constData(), G_ACTION_GROUP(m_gactionGroup), &error);
++        if (m_exportedActions == 0) {
++            qCWarning(ubuntuappmenu, "Failed to export actions - %s", error ? error->message : "unknown error");
++            g_error_free (error);
++            error = nullptr;
++        } else {
++            qCDebug(ubuntuappmenu, "Exported actions on %s", g_dbus_connection_get_unique_name(m_connection));
++        }
++    }
++}
++
++// Unexport the model
++void UbuntuGMenuModelExporter::unexportModels()
++{
++    GError *error = nullptr;
++    if (!m_connection) {
++        qCWarning(ubuntuappmenu, "Failed to retreive session bus - %s", error ? error->message : "unknown error");
++        return;
++    }
++
++    if (m_exportedModel != 0) {
++        g_dbus_connection_unexport_menu_model(m_connection, m_exportedModel);
++        m_exportedModel = 0;
++    }
++    if (m_exportedActions != 0) {
++        g_dbus_connection_unexport_action_group(m_connection, m_exportedActions);
++        m_exportedActions = 0;
++    }
++    g_object_unref(m_connection);
++    m_connection = nullptr;
++}
++
++// Create a submenu for the given platform menu.
++// Returns a gmenuitem entry for the menu, which must be cleaned up using g_object_unref.
++// If forItem is suplied, use it's label.
++GMenuItem *UbuntuGMenuModelExporter::createSubmenu(QPlatformMenu *platformMenu, UbuntuPlatformMenuItem *forItem)
++{
++    UbuntuPlatformMenu* gplatformMenu = static_cast<UbuntuPlatformMenu*>(platformMenu);
++    if (!gplatformMenu) return nullptr;
++    GMenu* menu = g_menu_new();
++
++    QByteArray label;
++    if (forItem) {
++        label = UbuntuPlatformMenuItem::get_text(forItem).toUtf8();
++    } else {
++        label = UbuntuPlatformMenu::get_text(gplatformMenu).toUtf8();
++    }
++
++    addSubmenuItems(gplatformMenu, menu);
++
++    GMenuItem* gmenuItem = g_menu_item_new_submenu(label.constData(), G_MENU_MODEL(menu));
++    g_object_unref(menu);
++    return gmenuItem;
++}
++
++// Add a platform menu's items to the given gmenu.
++// The items are inserted into menus sections, split by the menu separators.
++void UbuntuGMenuModelExporter::addSubmenuItems(UbuntuPlatformMenu* gplatformMenu, GMenu* menu)
++{
++    auto iter = gplatformMenu->menuItems().begin();
++    auto lastSectionStart = iter;
++    // Iterate through all the menu items adding sections when a separator is found.
++    for (; iter != gplatformMenu->menuItems().end(); ++iter) {
++        UbuntuPlatformMenuItem* gplatformMenuItem = static_cast<UbuntuPlatformMenuItem*>(*iter);
++        if (!gplatformMenuItem) continue;
++
++        // don't add a section until we have separator
++        if (UbuntuPlatformMenuItem::get_separator(gplatformMenuItem)) {
++            if (lastSectionStart != gplatformMenu->menuItems().begin()) {
++                GMenuItem* section = createSection(lastSectionStart, iter);
++                g_menu_append_item(menu, section);
++                g_object_unref(section);
++            }
++            lastSectionStart = iter + 1;
++        } else if (lastSectionStart == gplatformMenu->menuItems().begin()) {
++            processItemForGMenu(gplatformMenuItem, menu);
++        }
++    }
++
++    // Add the last section
++    if (lastSectionStart != gplatformMenu->menuItems().begin() &&
++            lastSectionStart != gplatformMenu->menuItems().end()) {
++        GMenuItem* gsectionItem = createSection(lastSectionStart, gplatformMenu->menuItems().end());
++        g_menu_append_item(menu, gsectionItem);
++        g_object_unref(gsectionItem);
++    }
++}
++
++// Create and return a gmenu item for the given platform menu item.
++// Returned GMenuItem must be cleaned up using g_object_unref
++GMenuItem *UbuntuGMenuModelExporter::createMenuItem(QPlatformMenuItem *platformMenuItem)
++{
++    UbuntuPlatformMenuItem* gplatformMenuItem = static_cast<UbuntuPlatformMenuItem*>(platformMenuItem);
++    if (!gplatformMenuItem) return nullptr;
++
++    QByteArray label(UbuntuPlatformMenuItem::get_text(gplatformMenuItem).toUtf8());
++    QByteArray actionLabel(getActionString(UbuntuPlatformMenuItem::get_text(gplatformMenuItem)).toUtf8());
++    QByteArray shortcut(UbuntuPlatformMenuItem::get_shortcut(gplatformMenuItem).toString(QKeySequence::NativeText).toUtf8());
++
++    GMenuItem* gmenuItem = g_menu_item_new(label.constData(), nullptr);
++    g_menu_item_set_attribute(gmenuItem, "accel", "s", shortcut.constData());
++    g_menu_item_set_detailed_action(gmenuItem, ("unity." + actionLabel).constData());
++
++    addAction(actionLabel, gplatformMenuItem);
++    return gmenuItem;
++}
++
++// Create a menu section for a section of separated menu items.
++// Returned GMenuItem must be cleaned up using g_object_unref
++GMenuItem *UbuntuGMenuModelExporter::createSection(QList<QPlatformMenuItem *>::const_iterator iter, QList<QPlatformMenuItem *>::const_iterator end)
++{
++    GMenu* gsectionMenu = g_menu_new();
++    for (; iter != end; ++iter) {
++        processItemForGMenu(*iter, gsectionMenu);
++    }
++    GMenuItem* gsectionItem = g_menu_item_new_section("", G_MENU_MODEL(gsectionMenu));
++    g_object_unref(gsectionMenu);
++    return gsectionItem;
++}
++
++// Add the given platform menu item to the menu.
++// If it has an attached submenu, then create and add the submenu.
++void UbuntuGMenuModelExporter::processItemForGMenu(QPlatformMenuItem *platformMenuItem, GMenu *gmenu)
++{
++    UbuntuPlatformMenuItem* gplatformMenuItem = static_cast<UbuntuPlatformMenuItem*>(platformMenuItem);
++    if (!gplatformMenuItem) return;
++
++    GMenuItem* gmenuItem = gplatformMenuItem->menu() ? createSubmenu(gplatformMenuItem->menu(), gplatformMenuItem) :
++                                                       createMenuItem(gplatformMenuItem);
++    if (gmenuItem) {
++        g_menu_append_item(gmenu, gmenuItem);
++        g_object_unref(gmenuItem);
++    }
++}
++
++// Create and add an action for a menu item.
++void UbuntuGMenuModelExporter::addAction(const QByteArray &name, UbuntuPlatformMenuItem *gplatformMenuItem)
++{
++    disconnect(gplatformMenuItem, &UbuntuPlatformMenuItem::checkedChanged, this, 0);
++    disconnect(gplatformMenuItem, &UbuntuPlatformMenuItem::enabledChanged, this, 0);
++
++    if (m_actions.contains(name)) {
++        g_action_map_remove_action(G_ACTION_MAP(m_gactionGroup), name.constData());
++        m_actions.remove(name);
++    }
++
++    bool checkable = UbuntuPlatformMenuItem::get_checkable(gplatformMenuItem);
++
++    GSimpleAction* action = nullptr;
++    if (checkable) {
++        bool checked = UbuntuPlatformMenuItem::get_checked(gplatformMenuItem);
++        action = g_simple_action_new_stateful(name.constData(), nullptr, g_variant_new_boolean(checked));
++
++        std::function<void(bool)> updateChecked = [gplatformMenuItem, action](bool checked) {
++            auto type = g_action_get_state_type(G_ACTION(action));
++            if (type && g_variant_type_equal(type, G_VARIANT_TYPE_BOOLEAN)) {
++                g_simple_action_set_state(action, g_variant_new_boolean(checked ? TRUE : FALSE));
++            }
++        };
++        // save the connection to disconnect in UbuntuGMenuModelExporter::clear()
++        m_propertyConnections << connect(gplatformMenuItem, &UbuntuPlatformMenuItem::checkedChanged, this, updateChecked);
++    } else {
++        action = g_simple_action_new(name.constData(), nullptr);
++    }
++
++    // Enabled update
++    std::function<void(bool)> updateEnabled = [gplatformMenuItem, action](bool enabled) {
++        GValue value = G_VALUE_INIT;
++        g_value_init (&value, G_TYPE_BOOLEAN);
++        g_value_set_boolean(&value, enabled ? TRUE : FALSE);
++        g_object_set_property(G_OBJECT(action), "enabled", &value);
++    };
++    updateEnabled(UbuntuPlatformMenuItem::get_enabled(gplatformMenuItem));
++    // save the connection to disconnect in UbuntuGMenuModelExporter::clear()
++    m_propertyConnections << connect(gplatformMenuItem, &UbuntuPlatformMenuItem::enabledChanged, this, updateEnabled);
++
++    g_signal_connect(action, "activate", G_CALLBACK(activate_cb), gplatformMenuItem);
++
++    m_actions.insert(name);
++    g_action_map_add_action(G_ACTION_MAP(m_gactionGroup), G_ACTION(action));
++    g_object_unref(action);
++}
 === added file 'src/ubuntuappmenu/gmenumodelexporter.h'
 --- src/ubuntuappmenu/gmenumodelexporter.h	1970-01-01 00:00:00 +0000
 +++ src/ubuntuappmenu/gmenumodelexporter.h	2016-12-09 17:04:44 +0000
@@ -0,0 +1,83 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it under
++ * the terms of the GNU Lesser General Public License version 3, as published by
++ * the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
++ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++ * Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef GMENUMODELEXPORTER_H
++#define GMENUMODELEXPORTER_H
++
++#include "gmenumodelplatformmenu.h"
++
++#include <gio/gio.h>
++
++#include <QTimer>
++#include <QSet>
++#include <QMetaObject>
++
++// Base class for a gmenumodel exporter
++class UbuntuGMenuModelExporter : public QObject
++{
++    Q_OBJECT
++public:
++    virtual ~UbuntuGMenuModelExporter();
++
++    void exportModels();
++    void unexportModels();
++
++    QString menuPath() const { return m_menuPath;}
++
++protected:
++    UbuntuGMenuModelExporter(QObject *parent);
++
++    GMenuItem *createSubmenu(QPlatformMenu* platformMenu, UbuntuPlatformMenuItem* forItem);
++    GMenuItem *createMenuItem(QPlatformMenuItem* platformMenuItem);
++    GMenuItem *createSection(QList<QPlatformMenuItem*>::const_iterator iter, QList<QPlatformMenuItem*>::const_iterator end);
++    void addAction(const QByteArray& name, UbuntuPlatformMenuItem* gplatformItem);
++
++    void addSubmenuItems(UbuntuPlatformMenu* gplatformMenu, GMenu* menu);
++    void processItemForGMenu(QPlatformMenuItem* item, GMenu* gmenu);
++
++    void clear();
++
++protected:
++    GDBusConnection *m_connection;
++    GMenu *m_gmainMenu;
++    GSimpleActionGroup *m_gactionGroup;
++    QSet<QByteArray> m_actions;
++    guint m_exportedModel;
++    guint m_exportedActions;
++    QTimer m_structureTimer;
++    QString m_menuPath;
++
++    QVector<QMetaObject::Connection> m_propertyConnections;
++};
++
++// Class which exports a qt platform menu bar.
++class UbuntuMenuBarExporter : public UbuntuGMenuModelExporter
++{
++public:
++    UbuntuMenuBarExporter(UbuntuPlatformMenuBar *parent);
++    ~UbuntuMenuBarExporter();
++};
++
++// Class which exports a qt platform menu.
++// This will allow exporting of context menus.
++class UbuntuMenuExporter : public UbuntuGMenuModelExporter
++{
++public:
++    UbuntuMenuExporter(UbuntuPlatformMenu *parent);
++    ~UbuntuMenuExporter();
++};
++
++#endif // GMENUMODELEXPORTER_H
 === added file 'src/ubuntuappmenu/gmenumodelplatformmenu.cpp'
 --- src/ubuntuappmenu/gmenumodelplatformmenu.cpp	1970-01-01 00:00:00 +0000
 +++ src/ubuntuappmenu/gmenumodelplatformmenu.cpp	2016-12-09 17:04:44 +0000
@@ -0,0 +1,526 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it under
++ * the terms of the GNU Lesser General Public License version 3, as published by
++ * the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
++ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++ * Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++// Local
++#include "gmenumodelplatformmenu.h"
++#include "gmenumodelexporter.h"
++#include "registry.h"
++#include "menuregistrar.h"
++#include "logging.h"
++
++// Qt
++#include <QDebug>
++#include <QWindow>
++#include <QCoreApplication>
++
++#define BAR_DEBUG_MSG qCDebug(ubuntuappmenu).nospace() << "UbuntuPlatformMenuBar[" << (void*)this <<"]::" << __func__
++#define MENU_DEBUG_MSG qCDebug(ubuntuappmenu).nospace() << "UbuntuPlatformMenu[" << (void*)this <<"]::" << __func__
++#define ITEM_DEBUG_MSG qCDebug(ubuntuappmenu).nospace() << "UbuntuPlatformMenuItem[" << (void*)this <<"]::" << __func__
++
++namespace {
++
++int logRecusion = 0;
++
++}
++
++QDebug operator<<(QDebug stream, UbuntuPlatformMenuBar* bar) {
++    if (bar) return bar->operator<<(stream);
++    return stream;
++}
++QDebug operator<<(QDebug stream, UbuntuPlatformMenu* menu) {
++    if (menu) return menu->operator<<(stream);
++    return stream;
++}
++QDebug operator<<(QDebug stream, UbuntuPlatformMenuItem* menuItem) {
++    if (menuItem) return menuItem->operator<<(stream);
++    return stream;
++}
++
++UbuntuPlatformMenuBar::UbuntuPlatformMenuBar()
++    : m_exporter(new UbuntuMenuBarExporter(this))
++    , m_registrar(new UbuntuMenuRegistrar())
++    , m_ready(false)
++{
++    BAR_DEBUG_MSG << "()";
++
++    connect(this, &UbuntuPlatformMenuBar::menuInserted, this, &UbuntuPlatformMenuBar::structureChanged);
++    connect(this,&UbuntuPlatformMenuBar::menuRemoved, this, &UbuntuPlatformMenuBar::structureChanged);
++}
++
++UbuntuPlatformMenuBar::~UbuntuPlatformMenuBar()
++{
++    BAR_DEBUG_MSG << "()";
++}
++
++void UbuntuPlatformMenuBar::insertMenu(QPlatformMenu *menu, QPlatformMenu *before)
++{
++    BAR_DEBUG_MSG << "(menu=" << menu << ", before=" <<  before << ")";
++
++    if (m_menus.contains(menu)) return;
++
++    if (!before) {
++        m_menus.push_back(menu);
++    } else {
++        for (auto iter = m_menus.begin(); iter != m_menus.end(); ++iter) {
++            if (*iter == before) {
++                m_menus.insert(iter, menu);
++                break;
++            }
++        }
++    }
++    connect(static_cast<UbuntuPlatformMenu*>(menu), &UbuntuPlatformMenu::structureChanged,
++            this, &UbuntuPlatformMenuBar::structureChanged);
++    Q_EMIT menuInserted(menu);
++}
++
++void UbuntuPlatformMenuBar::removeMenu(QPlatformMenu *menu)
++{
++    BAR_DEBUG_MSG << "(menu=" << menu << ")";
++
++    QMutableListIterator<QPlatformMenu*> iterator(m_menus);
++    while(iterator.hasNext()) {
++        if (iterator.next() == menu) {
++            iterator.remove();
++            break;
++        }
++    }
++    disconnect(static_cast<UbuntuPlatformMenu*>(menu), &UbuntuPlatformMenu::structureChanged,
++            this, &UbuntuPlatformMenuBar::structureChanged);
++    Q_EMIT menuRemoved(menu);
++}
++
++void UbuntuPlatformMenuBar::syncMenu(QPlatformMenu *menu)
++{
++    BAR_DEBUG_MSG << "(menu=" << menu << ")";
++
++    Q_UNUSED(menu)
++}
++
++void UbuntuPlatformMenuBar::handleReparent(QWindow *parentWindow)
++{
++    BAR_DEBUG_MSG << "(parentWindow=" << parentWindow << ")";
++
++    setReady(true);
++    m_registrar->registerMenuForWindow(parentWindow, QDBusObjectPath(m_exporter->menuPath()));
++}
++
++QPlatformMenu *UbuntuPlatformMenuBar::menuForTag(quintptr tag) const
++{
++    Q_FOREACH(QPlatformMenu* menu, m_menus) {
++        if (menu->tag() == tag) {
++            return menu;
++        }
++    }
++    return nullptr;
++}
++
++const QList<QPlatformMenu *> UbuntuPlatformMenuBar::menus() const
++{
++    return m_menus;
++}
++
++QDebug UbuntuPlatformMenuBar::operator<<(QDebug stream)
++{
++    stream.nospace().noquote() << QString("%1").arg("", logRecusion, QLatin1Char('\t'))
++            << "UbuntuPlatformMenuBar(this=" << (void*)this << ")" << endl;
++    Q_FOREACH(QPlatformMenu* menu, m_menus) {
++        auto myMenu = static_cast<UbuntuPlatformMenu*>(menu);
++        if (myMenu) {
++            logRecusion++;
++            stream << myMenu;
++            logRecusion--;
++        }
++    }
++
++    return stream;
++}
++
++#if QT_VERSION >= QT_VERSION_CHECK(5, 6, 0)
++QPlatformMenu *UbuntuPlatformMenuBar::createMenu() const
++{
++    return new UbuntuPlatformMenu();
++}
++#endif
++
++void UbuntuPlatformMenuBar::setReady(bool isReady)
++{
++    if (m_ready != isReady) {
++        m_ready = isReady;
++        Q_EMIT ready();
++    }
++}
++
++//////////////////////////////////////////////////////////////
++
++UbuntuPlatformMenu::UbuntuPlatformMenu()
++    : m_parentWindow(nullptr)
++    , m_exporter(nullptr)
++    , m_registrar(nullptr)
++{
++    MENU_DEBUG_MSG << "()";
++
++    connect(this, &UbuntuPlatformMenu::menuItemInserted, this, &UbuntuPlatformMenu::structureChanged);
++    connect(this, &UbuntuPlatformMenu::menuItemRemoved, this, &UbuntuPlatformMenu::structureChanged);
++}
++
++UbuntuPlatformMenu::~UbuntuPlatformMenu()
++{
++    MENU_DEBUG_MSG << "()";
++}
++
++void UbuntuPlatformMenu::insertMenuItem(QPlatformMenuItem *menuItem, QPlatformMenuItem *before)
++{
++    MENU_DEBUG_MSG << "(menuItem=" << menuItem << ", before=" << before << ")";
++
++    if (m_menuItems.contains(menuItem)) return;
++
++    if (!before) {
++        m_menuItems.push_back(menuItem);
++    } else {
++        for (auto iter = m_menuItems.begin(); iter != m_menuItems.end(); ++iter) {
++            if (*iter == before) {
++                m_menuItems.insert(iter, menuItem);
++                break;
++            }
++        }
++    }
++
++    Q_EMIT menuItemInserted(menuItem);
++}
++
++void UbuntuPlatformMenu::removeMenuItem(QPlatformMenuItem *menuItem)
++{
++    MENU_DEBUG_MSG << "(menuItem=" << menuItem << ")";
++
++    QMutableListIterator<QPlatformMenuItem*> iterator(m_menuItems);
++    while(iterator.hasNext()) {
++        if (iterator.next() == menuItem) {
++            iterator.remove();
++            break;
++        }
++    }
++    Q_EMIT menuItemRemoved(menuItem);
++}
++
++void UbuntuPlatformMenu::syncMenuItem(QPlatformMenuItem *menuItem)
++{
++    MENU_DEBUG_MSG << "(menuItem=" << menuItem << ")";
++
++    Q_UNUSED(menuItem)
++}
++
++void UbuntuPlatformMenu::syncSeparatorsCollapsible(bool enable)
++{
++    MENU_DEBUG_MSG << "(enable=" << enable << ")";
++    Q_UNUSED(enable)
++}
++
++void UbuntuPlatformMenu::setTag(quintptr tag)
++{
++    MENU_DEBUG_MSG << "(tag=" << tag << ")";
++    m_tag = tag;
++}
++
++quintptr UbuntuPlatformMenu::tag() const
++{
++    return m_tag;
++}
++
++void UbuntuPlatformMenu::setText(const QString &text)
++{
++    MENU_DEBUG_MSG << "(text=" << text << ")";
++    if (m_text != text) {
++        m_text = text;
++        Q_EMIT propertyChanged();
++    }
++}
++
++void UbuntuPlatformMenu::setIcon(const QIcon &icon)
++{
++    MENU_DEBUG_MSG << "(icon=" << icon.name() << ")";
++
++    if (!icon.isNull() || (!m_icon.isNull() && icon.isNull())) {
++        m_icon = icon;
++        Q_EMIT propertyChanged();
++    }
++}
++
++void UbuntuPlatformMenu::setEnabled(bool enabled)
++{
++    MENU_DEBUG_MSG << "(enabled=" << enabled << ")";
++
++    if (m_enabled != enabled) {
++        m_enabled = enabled;
++        Q_EMIT propertyChanged();
++    }
++}
++
++void UbuntuPlatformMenu::setVisible(bool isVisible)
++{
++    MENU_DEBUG_MSG << "(visible=" << isVisible << ")";
++
++    if (m_visible != isVisible) {
++        m_visible = isVisible;
++        Q_EMIT propertyChanged();
++    }
++}
++
++void UbuntuPlatformMenu::setMinimumWidth(int width)
++{
++    MENU_DEBUG_MSG << "(width=" << width << ")";
++
++    Q_UNUSED(width)
++}
++
++void UbuntuPlatformMenu::setFont(const QFont &font)
++{
++    MENU_DEBUG_MSG << "(font=" << font << ")";
++
++    Q_UNUSED(font)
++}
++
++void UbuntuPlatformMenu::showPopup(const QWindow *parentWindow, const QRect &targetRect, const QPlatformMenuItem *item)
++{
++    MENU_DEBUG_MSG << "(parentWindow=" << parentWindow << ", targetRect=" << targetRect << ", item=" << item << ")";
++
++    if (!m_exporter) {
++        m_exporter.reset(new UbuntuMenuExporter(this));
++        m_exporter->exportModels();
++    }
++
++    if (parentWindow != m_parentWindow) {
++        if (m_parentWindow) {
++            m_registrar->unregisterMenu();
++        }
++
++        m_parentWindow = parentWindow;
++
++        if (m_parentWindow) {
++            if (!m_registrar) m_registrar.reset(new UbuntuMenuRegistrar);
++            m_registrar->registerMenuForWindow(const_cast<QWindow*>(m_parentWindow),
++                                                      QDBusObjectPath(m_exporter->menuPath()));
++        }
++    }
++
++    Q_UNUSED(targetRect);
++    Q_UNUSED(item);
++    setVisible(true);
++}
++
++void UbuntuPlatformMenu::dismiss()
++{
++    MENU_DEBUG_MSG << "()";
++
++    if (m_registrar) { m_registrar->unregisterMenu(); }
++    if (m_exporter) { m_exporter->unexportModels(); }
++}
++
++QPlatformMenuItem *UbuntuPlatformMenu::menuItemAt(int position) const
++{
++    if (position < 0 || position >= m_menuItems.count()) return nullptr;
++    return m_menuItems.at(position);
++}
++
++QPlatformMenuItem *UbuntuPlatformMenu::menuItemForTag(quintptr tag) const
++{
++    Q_FOREACH(QPlatformMenuItem* menuItem, m_menuItems) {
++        if (menuItem->tag() == tag) {
++            return menuItem;
++        }
++    }
++    return nullptr;
++}
++
++QPlatformMenuItem *UbuntuPlatformMenu::createMenuItem() const
++{
++    return new UbuntuPlatformMenuItem();
++}
++
++#if QT_VERSION >= QT_VERSION_CHECK(5, 6, 0)
++QPlatformMenu *UbuntuPlatformMenu::createSubMenu() const
++{
++    return new UbuntuPlatformMenu();
++}
++#endif
++
++const QList<QPlatformMenuItem *> UbuntuPlatformMenu::menuItems() const
++{
++    return m_menuItems;
++}
++
++QDebug UbuntuPlatformMenu::operator<<(QDebug stream)
++{
++    stream.nospace().noquote() << QString("%1").arg("", logRecusion, QLatin1Char('\t'))
++            << "UbuntuPlatformMenu(this=" << (void*)this << ", text=\"" << m_text << "\")" << endl;
++    Q_FOREACH(QPlatformMenuItem* item, m_menuItems) {
++        logRecusion++;
++        auto myItem = static_cast<UbuntuPlatformMenuItem*>(item);
++        if (myItem) {
++            stream << myItem;
++        }
++        logRecusion--;
++    }
++    return stream;
++}
++
++//////////////////////////////////////////////////////////////
++
++UbuntuPlatformMenuItem::UbuntuPlatformMenuItem()
++    : m_menu(nullptr)
++{
++    ITEM_DEBUG_MSG << "()";
++}
++
++UbuntuPlatformMenuItem::~UbuntuPlatformMenuItem()
++{
++    ITEM_DEBUG_MSG << "()";
++}
++
++void UbuntuPlatformMenuItem::setTag(quintptr tag)
++{
++    ITEM_DEBUG_MSG << "(tag=" << tag << ")";
++    m_tag = tag;
++}
++
++quintptr UbuntuPlatformMenuItem::tag() const
++{
++    return m_tag;
++}
++
++void UbuntuPlatformMenuItem::setText(const QString &text)
++{
++    ITEM_DEBUG_MSG << "(text=" << text << ")";
++    if (m_text != text) {
++        m_text = text;
++        Q_EMIT propertyChanged();
++    }
++}
++
++void UbuntuPlatformMenuItem::setIcon(const QIcon &icon)
++{
++    ITEM_DEBUG_MSG << "(icon=" << icon.name() << ")";
++
++    if (!icon.isNull() || (!m_icon.isNull() && icon.isNull())) {
++        m_icon = icon;
++        Q_EMIT propertyChanged();
++    }
++}
++
++void UbuntuPlatformMenuItem::setVisible(bool isVisible)
++{
++    ITEM_DEBUG_MSG << "(visible=" << isVisible << ")";
++    if (m_visible != isVisible) {
++        m_visible = isVisible;
++        Q_EMIT propertyChanged();
++    }
++}
++
++void UbuntuPlatformMenuItem::setIsSeparator(bool isSeparator)
++{
++    ITEM_DEBUG_MSG << "(separator=" << isSeparator << ")";
++    if (m_separator != isSeparator) {
++        m_separator = isSeparator;
++        Q_EMIT propertyChanged();
++    }
++}
++
++void UbuntuPlatformMenuItem::setFont(const QFont &font)
++{
++    ITEM_DEBUG_MSG << "(font=" << font << ")";
++    Q_UNUSED(font);
++}
++
++void UbuntuPlatformMenuItem::setRole(QPlatformMenuItem::MenuRole role)
++{
++    ITEM_DEBUG_MSG << "(role=" << role << ")";
++    Q_UNUSED(role);
++}
++
++void UbuntuPlatformMenuItem::setCheckable(bool checkable)
++{
++    ITEM_DEBUG_MSG << "(checkable=" << checkable << ")";
++    if (m_checkable != checkable) {
++        m_checkable = checkable;
++        Q_EMIT propertyChanged();
++    }
++}
++
++void UbuntuPlatformMenuItem::setChecked(bool isChecked)
++{
++    ITEM_DEBUG_MSG << "(checked=" << isChecked << ")";
++    if (m_checked != isChecked) {
++        m_checked = isChecked;
++        Q_EMIT checkedChanged(isChecked);
++        Q_EMIT propertyChanged();
++    }
++}
++
++void UbuntuPlatformMenuItem::setShortcut(const QKeySequence &shortcut)
++{
++    ITEM_DEBUG_MSG << "(shortcut=" << shortcut << ")";
++    if (m_shortcut != shortcut) {
++        m_shortcut = shortcut;
++        Q_EMIT propertyChanged();
++    }
++}
++
++void UbuntuPlatformMenuItem::setEnabled(bool enabled)
++{
++    ITEM_DEBUG_MSG << "(enabled=" << enabled << ")";
++    if (m_enabled != enabled) {
++        m_enabled = enabled;
++        Q_EMIT enabledChanged(enabled);
++        Q_EMIT propertyChanged();
++    }
++}
++
++void UbuntuPlatformMenuItem::setIconSize(int size)
++{
++    ITEM_DEBUG_MSG << "(size=" << size << ")";
++    Q_UNUSED(size);
++}
++
++void UbuntuPlatformMenuItem::setMenu(QPlatformMenu *menu)
++{
++    ITEM_DEBUG_MSG << "(menu=" << menu << ")";
++    if (m_menu != menu) {
++        m_menu = menu;
++        Q_EMIT propertyChanged();
++    }
++}
++
++QPlatformMenu *UbuntuPlatformMenuItem::menu() const
++{
++    return m_menu;
++}
++
++QDebug UbuntuPlatformMenuItem::operator<<(QDebug stream)
++{
++    QString properties = "text=\"" + m_text + "\"";
++
++    stream.nospace().noquote() << QString("%1").arg("", logRecusion, QLatin1Char('\t'))
++            << "UbuntuPlatformMenuItem(this=" << (void*)this << ", "
++            << (m_separator ? "Separator" : properties) << ")" << endl;
++    if (m_menu) {
++        auto myMenu = static_cast<UbuntuPlatformMenu*>(m_menu);
++        if (myMenu) {
++            logRecusion++;
++            stream << myMenu;
++            logRecusion--;
++        }
++    }
++    return stream;
++}
 === added file 'src/ubuntuappmenu/gmenumodelplatformmenu.h'
 --- src/ubuntuappmenu/gmenumodelplatformmenu.h	1970-01-01 00:00:00 +0000
 +++ src/ubuntuappmenu/gmenumodelplatformmenu.h	2016-12-09 17:04:44 +0000
@@ -0,0 +1,181 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it under
++ * the terms of the GNU Lesser General Public License version 3, as published by
++ * the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
++ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++ * Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef EXPORTEDPLATFORMMENUBAR_H
++#define EXPORTEDPLATFORMMENUBAR_H
++
++#include <qpa/qplatformmenu.h>
++
++// Local
++class UbuntuGMenuModelExporter;
++class UbuntuMenuRegistrar;
++class QWindow;
++
++class UbuntuPlatformMenuBar : public QPlatformMenuBar
++{
++    Q_OBJECT
++public:
++    UbuntuPlatformMenuBar();
++    ~UbuntuPlatformMenuBar();
++
++    QString exportedPath() const;
++
++    virtual void insertMenu(QPlatformMenu *menu, QPlatformMenu* before) override;
++    virtual void removeMenu(QPlatformMenu *menu) override;
++    virtual void syncMenu(QPlatformMenu *menu) override;
++    virtual void handleReparent(QWindow *newParentWindow) override;
++    virtual QPlatformMenu *menuForTag(quintptr tag) const override;
++
++    const QList<QPlatformMenu*> menus() const;
++
++    QDebug operator<<(QDebug stream);
++
++#if QT_VERSION >= QT_VERSION_CHECK(5, 6, 0)
++    virtual QPlatformMenu *createMenu() const override;
++#endif
++
++Q_SIGNALS:
++    void menuInserted(QPlatformMenu *menu);
++    void menuRemoved(QPlatformMenu *menu);
++
++    void structureChanged();
++    void ready();
++
++private:
++    void setReady(bool);
++
++    QList<QPlatformMenu*> m_menus;
++    QScopedPointer<UbuntuGMenuModelExporter> m_exporter;
++    QScopedPointer<UbuntuMenuRegistrar> m_registrar;
++    bool m_ready;
++};
++
++#define MENU_PROPERTY(class, name, type, defaultValue) \
++    static type get_##name(const class *menuItem) { return menuItem->m_##name; } \
++    type m_##name = defaultValue;
++
++class Q_DECL_EXPORT UbuntuPlatformMenu : public QPlatformMenu
++{
++    Q_OBJECT
++public:
++    UbuntuPlatformMenu();
++    ~UbuntuPlatformMenu();
++
++    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 void showPopup(const QWindow *parentWindow, const QRect &targetRect, const QPlatformMenuItem *item);
++
++    virtual void dismiss(); // Closes this and all its related menu popups
++
++    virtual QPlatformMenuItem *menuItemAt(int position) const override;
++    virtual QPlatformMenuItem *menuItemForTag(quintptr tag) const override;
++
++    virtual QPlatformMenuItem *createMenuItem() const override;
++#if QT_VERSION >= QT_VERSION_CHECK(5, 6, 0)
++    virtual QPlatformMenu *createSubMenu() const override;
++#endif
++
++    int id() const;
++
++    const QList<QPlatformMenuItem*> menuItems() const;
++
++    QDebug operator<<(QDebug stream);
++
++Q_SIGNALS:
++    void menuItemInserted(QPlatformMenuItem *menuItem);
++    void menuItemRemoved(QPlatformMenuItem *menuItem);
++    void structureChanged();
++    void propertyChanged();
++
++private:
++    MENU_PROPERTY(UbuntuPlatformMenu, visible, bool, true)
++    MENU_PROPERTY(UbuntuPlatformMenu, text, QString, QString())
++    MENU_PROPERTY(UbuntuPlatformMenu, enabled, bool, true)
++    MENU_PROPERTY(UbuntuPlatformMenu, icon, QIcon, QIcon())
++
++    quintptr m_tag;
++    QList<QPlatformMenuItem*> m_menuItems;
++    const QWindow* m_parentWindow;
++    QScopedPointer<UbuntuGMenuModelExporter> m_exporter;
++    QScopedPointer<UbuntuMenuRegistrar> m_registrar;
++
++    friend class UbuntuGMenuModelExporter;
++};
++
++
++class Q_DECL_EXPORT UbuntuPlatformMenuItem : public QPlatformMenuItem
++{
++    Q_OBJECT
++public:
++    UbuntuPlatformMenuItem();
++    ~UbuntuPlatformMenuItem();
++
++    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;
++
++    QPlatformMenu* menu() const;
++
++    QDebug operator<<(QDebug stream);
++
++Q_SIGNALS:
++    void checkedChanged(bool);
++    void enabledChanged(bool);
++    void propertyChanged();
++
++private:
++    MENU_PROPERTY(UbuntuPlatformMenuItem, separator, bool, false)
++    MENU_PROPERTY(UbuntuPlatformMenuItem, visible, bool, true)
++    MENU_PROPERTY(UbuntuPlatformMenuItem, text, QString, QString())
++    MENU_PROPERTY(UbuntuPlatformMenuItem, enabled, bool, true)
++    MENU_PROPERTY(UbuntuPlatformMenuItem, checkable, bool, false)
++    MENU_PROPERTY(UbuntuPlatformMenuItem, checked, bool, false)
++    MENU_PROPERTY(UbuntuPlatformMenuItem, shortcut, QKeySequence, QKeySequence())
++    MENU_PROPERTY(UbuntuPlatformMenuItem, icon, QIcon, QIcon())
++    MENU_PROPERTY(UbuntuPlatformMenuItem, iconSize, int, 16)
++    MENU_PROPERTY(UbuntuPlatformMenuItem, menu, QPlatformMenu*, nullptr)
++
++
++    quintptr m_tag;
++    friend class UbuntuGMenuModelExporter;
++};
++
++#endif // EXPORTEDPLATFORMMENUBAR_H
 === added file 'src/ubuntuappmenu/logging.h'
 --- src/ubuntuappmenu/logging.h	1970-01-01 00:00:00 +0000
 +++ src/ubuntuappmenu/logging.h	2016-12-09 17:04:44 +0000
@@ -0,0 +1,27 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it under
++ * the terms of the GNU Lesser General Public License version 3, as published by
++ * the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
++ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++ * Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef QUBUNTUTHEMELOGGING_H
++#define QUBUNTUTHEMELOGGING_H
++
++#include <QLoggingCategory>
++
++#define ASSERT(cond) ((!(cond)) ? qt_assert(#cond,__FILE__,__LINE__) : qt_noop())
++
++Q_DECLARE_LOGGING_CATEGORY(ubuntuappmenu)
++Q_DECLARE_LOGGING_CATEGORY(ubuntuappmenuRegistrar)
++
++#endif  // QUBUNTUTHEMELOGGING_H
 === added file 'src/ubuntuappmenu/menuregistrar.cpp'
 --- src/ubuntuappmenu/menuregistrar.cpp	1970-01-01 00:00:00 +0000
 +++ src/ubuntuappmenu/menuregistrar.cpp	2016-12-09 17:04:44 +0000
@@ -0,0 +1,137 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it under
++ * the terms of the GNU Lesser General Public License version 3, as published by
++ * the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
++ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++ * Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include "menuregistrar.h"
++#include "registry.h"
++#include "logging.h"
++
++#include <QDebug>
++#include <QDBusObjectPath>
++#include <QGuiApplication>
++#include <qpa/qplatformnativeinterface.h>
++#include <qpa/qplatformwindow.h>
++
++namespace {
++
++bool isMirClient() {
++    return qGuiApp->platformName() == "ubuntumirclient";
++}
++
++}
++
++UbuntuMenuRegistrar::UbuntuMenuRegistrar()
++    : m_connection(nullptr)
++    , m_registeredProcessId(~0)
++{
++    GError *error = NULL;
++    m_connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
++    if (!m_connection) {
++        qCWarning(ubuntuappmenuRegistrar, "Failed to retreive session bus - %s", error ? error->message : "unknown error");
++        g_error_free (error);
++        return;
++    }
++    m_service = g_dbus_connection_get_unique_name(m_connection);
++    connect(UbuntuMenuRegistry::instance(), &UbuntuMenuRegistry::serviceChanged, this, &UbuntuMenuRegistrar::onRegistrarServiceChanged);
++
++    if (isMirClient()) {
++        auto nativeInterface = qGuiApp->platformNativeInterface();
++        connect(nativeInterface, &QPlatformNativeInterface::windowPropertyChanged, this, [this](QPlatformWindow* window, const QString &property) {
++            if (property != QStringLiteral("persistentSurfaceId")) {
++                return;
++            }
++            if (window->window() == m_window) {
++                registerMenuForWindow(m_window, m_path);
++            }
++        });
++    }
++}
++
++UbuntuMenuRegistrar::~UbuntuMenuRegistrar()
++{
++    if (m_connection) {
++        g_object_unref(m_connection);
++    }
++    unregisterMenu();
++}
++
++void UbuntuMenuRegistrar::registerMenuForWindow(QWindow* window, const QDBusObjectPath& path)
++{
++    unregisterMenu();
++
++    m_window = window;
++    m_path = path;
++
++    registerMenu();
++}
++
++void UbuntuMenuRegistrar::registerMenu()
++{
++    if (UbuntuMenuRegistry::instance()->isConnected() && m_window) {
++        if (isMirClient()) {
++            registerSurfaceMenu();
++        } else {
++            registerApplicationMenu();
++        }
++    }
++}
++
++void UbuntuMenuRegistrar::unregisterMenu()
++{
++    if (!m_registeredSurfaceId.isEmpty()) {
++        unregisterSurfaceMenu();
++    } else if (m_registeredProcessId != ~0) {
++        unregisterApplicationMenu();
++    }
++}
++
++void UbuntuMenuRegistrar::registerSurfaceMenu()
++{
++    auto nativeInterface = qGuiApp->platformNativeInterface();
++    QByteArray persistentSurfaceId = nativeInterface->windowProperty(m_window->handle(), "persistentSurfaceId", QByteArray()).toByteArray();
++    if (persistentSurfaceId.isEmpty()) return;
++
++    UbuntuMenuRegistry::instance()->registerSurfaceMenu(persistentSurfaceId, m_path, m_service);
++    m_registeredSurfaceId = persistentSurfaceId;
++}
++
++void UbuntuMenuRegistrar::unregisterSurfaceMenu()
++{
++    if (UbuntuMenuRegistry::instance()->isConnected()) {
++        UbuntuMenuRegistry::instance()->unregisterSurfaceMenu(m_registeredSurfaceId, m_path);
++    }
++    m_registeredSurfaceId.clear();
++}
++
++void UbuntuMenuRegistrar::registerApplicationMenu()
++{
++    pid_t pid = getpid();
++    UbuntuMenuRegistry::instance()->registerApplicationMenu(pid, m_path, m_service);
++    m_registeredProcessId = pid;
++}
++
++void UbuntuMenuRegistrar::unregisterApplicationMenu()
++{
++    if (UbuntuMenuRegistry::instance()->isConnected()) {
++        UbuntuMenuRegistry::instance()->unregisterApplicationMenu(m_registeredProcessId, m_path);
++    }
++    m_registeredProcessId = ~0;
++}
++
++void UbuntuMenuRegistrar::onRegistrarServiceChanged()
++{
++    unregisterMenu();
++    registerMenu();
++}
 === added file 'src/ubuntuappmenu/menuregistrar.h'
 --- src/ubuntuappmenu/menuregistrar.h	1970-01-01 00:00:00 +0000
 +++ src/ubuntuappmenu/menuregistrar.h	2016-12-09 17:04:44 +0000
@@ -0,0 +1,59 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it under
++ * the terms of the GNU Lesser General Public License version 3, as published by
++ * the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
++ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++ * Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef MENUREGISTRAR_H
++#define MENUREGISTRAR_H
++
++#include <QObject>
++#include <QWindow>
++#include <QPointer>
++#include <QDBusObjectPath>
++
++#include <gio/gio.h>
++
++class UbuntuMenuRegistrar : public QObject
++{
++    Q_OBJECT
++public:
++    UbuntuMenuRegistrar();
++    ~UbuntuMenuRegistrar();
++
++    void registerMenuForWindow(QWindow* window, const QDBusObjectPath& path);
++    void unregisterMenu();
++
++private Q_SLOTS:
++    void registerSurfaceMenu();
++    void onRegistrarServiceChanged();
++
++private:
++    void registerMenu();
++
++    void registerApplicationMenu();
++    void unregisterApplicationMenu();
++
++    void unregisterSurfaceMenu();
++
++    GDBusConnection *m_connection;
++    QString m_service;
++    QDBusObjectPath m_path;
++    QPointer<QWindow> m_window;
++    QString m_registeredSurfaceId;
++    pid_t m_registeredProcessId;
++};
++
++
++#endif // MENUREGISTRAR_H
++
 === added file 'src/ubuntuappmenu/registry.cpp'
 --- src/ubuntuappmenu/registry.cpp	1970-01-01 00:00:00 +0000
 +++ src/ubuntuappmenu/registry.cpp	2016-12-09 17:04:44 +0000
@@ -0,0 +1,97 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it under
++ * the terms of the GNU Lesser General Public License version 3, as published by
++ * the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
++ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++ * Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include "registry.h"
++#include "logging.h"
++#include "menuregistrar_interface.h"
++
++#include <QDBusObjectPath>
++#include <QDBusServiceWatcher>
++
++Q_LOGGING_CATEGORY(ubuntuappmenuRegistrar, "ubuntuappmenu.registrar", QtWarningMsg)
++
++#define REGISTRAR_SERVICE "com.ubuntu.MenuRegistrar"
++#define REGISTRY_OBJECT_PATH "/com/ubuntu/MenuRegistrar"
++
++UbuntuMenuRegistry *UbuntuMenuRegistry::instance()
++{
++    static UbuntuMenuRegistry* registry(new UbuntuMenuRegistry());
++    return registry;
++}
++
++UbuntuMenuRegistry::UbuntuMenuRegistry(QObject* parent)
++    : QObject(parent)
++    , m_serviceWatcher(new QDBusServiceWatcher(REGISTRAR_SERVICE, QDBusConnection::sessionBus(), QDBusServiceWatcher::WatchForOwnerChange, this))
++    , m_interface(new ComUbuntuMenuRegistrarInterface(REGISTRAR_SERVICE, REGISTRY_OBJECT_PATH, QDBusConnection::sessionBus(), this))
++    , m_connected(m_interface->isValid())
++{
++    connect(m_serviceWatcher.data(), &QDBusServiceWatcher::serviceOwnerChanged, this, &UbuntuMenuRegistry::serviceOwnerChanged);
++}
++
++UbuntuMenuRegistry::~UbuntuMenuRegistry()
++{
++}
++
++void UbuntuMenuRegistry::registerApplicationMenu(pid_t pid, QDBusObjectPath menuObjectPath, const QString &service)
++{
++    qCDebug(ubuntuappmenuRegistrar, "UbuntuMenuRegistry::registerMenu(pid=%d, menuObjectPath=%s, service=%s)",
++            pid,
++            qPrintable(menuObjectPath.path()),
++            qPrintable(service));
++
++    m_interface->RegisterAppMenu(pid, menuObjectPath, menuObjectPath, service);
++}
++
++void UbuntuMenuRegistry::unregisterApplicationMenu(pid_t pid, QDBusObjectPath menuObjectPath)
++{
++    qCDebug(ubuntuappmenuRegistrar, "UbuntuMenuRegistry::unregisterSurfaceMenu(pid=%d, menuObjectPath=%s)",
++            pid,
++            qPrintable(menuObjectPath.path()));
++
++    m_interface->UnregisterAppMenu(pid, menuObjectPath);
++}
++
++void UbuntuMenuRegistry::registerSurfaceMenu(const QString &surfaceId, QDBusObjectPath menuObjectPath, const QString &service)
++{
++    qCDebug(ubuntuappmenuRegistrar, "UbuntuMenuRegistry::registerMenu(surfaceId=%s, menuObjectPath=%s, service=%s)",
++            qPrintable(surfaceId),
++            qPrintable(menuObjectPath.path()),
++            qPrintable(service));
++
++    m_interface->RegisterSurfaceMenu(surfaceId, menuObjectPath, menuObjectPath, service);
++}
++
++void UbuntuMenuRegistry::unregisterSurfaceMenu(const QString &surfaceId, QDBusObjectPath menuObjectPath)
++{
++    qCDebug(ubuntuappmenuRegistrar, "UbuntuMenuRegistry::unregisterSurfaceMenu(surfaceId=%s, menuObjectPath=%s)",
++            qPrintable(surfaceId),
++            qPrintable(menuObjectPath.path()));
++
++    m_interface->UnregisterSurfaceMenu(surfaceId, menuObjectPath);
++}
++
++
++void UbuntuMenuRegistry::serviceOwnerChanged(const QString &serviceName, const QString& oldOwner, const QString &newOwner)
++{
++    qCDebug(ubuntuappmenuRegistrar, "UbuntuMenuRegistry::serviceOwnerChanged(newOwner=%s)", qPrintable(newOwner));
++
++    if (serviceName != REGISTRAR_SERVICE) return;
++
++    if (oldOwner != newOwner) {
++        m_connected = !newOwner.isEmpty();
++        Q_EMIT serviceChanged();
++    }
++}
 === added file 'src/ubuntuappmenu/registry.h'
 --- src/ubuntuappmenu/registry.h	1970-01-01 00:00:00 +0000
 +++ src/ubuntuappmenu/registry.h	2016-12-09 17:04:44 +0000
@@ -0,0 +1,56 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it under
++ * the terms of the GNU Lesser General Public License version 3, as published by
++ * the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
++ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++ * Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef UBUNTU_MENU_REGISTRY_H
++#define UBUNTU_MENU_REGISTRY_H
++
++#include <QObject>
++#include <QScopedPointer>
++
++class ComUbuntuMenuRegistrarInterface;
++class QDBusObjectPath;
++class QDBusServiceWatcher;
++
++class UbuntuMenuRegistry : public QObject
++{
++    Q_OBJECT
++public:
++    UbuntuMenuRegistry(QObject* parent = nullptr);
++    virtual ~UbuntuMenuRegistry();
++
++    static UbuntuMenuRegistry *instance();
++
++    void registerApplicationMenu(pid_t pid, QDBusObjectPath menuObjectPath, const QString &service);
++    void unregisterApplicationMenu(pid_t pid, QDBusObjectPath menuObjectPath);
++
++    void registerSurfaceMenu(const QString &surfaceId, QDBusObjectPath menuObjectPath, const QString &service);
++    void unregisterSurfaceMenu(const QString &surfaceId, QDBusObjectPath menuObjectPath);
++
++    bool isConnected() const { return m_connected; }
++
++Q_SIGNALS:
++    void serviceChanged();
++
++private Q_SLOTS:
++    void serviceOwnerChanged(const QString &serviceName, const QString& oldOwner, const QString &newOwner);
++
++private:
++    QScopedPointer<QDBusServiceWatcher> m_serviceWatcher;
++    QScopedPointer<ComUbuntuMenuRegistrarInterface> m_interface;
++    bool m_connected;
++};
++
++#endif // UBUNTU_MENU_REGISTRY_H
 === renamed file 'src/ubuntumirclient/theme.cpp' => 'src/ubuntuappmenu/theme.cpp'
 --- src/ubuntumirclient/theme.cpp	2014-06-18 23:10:00 +0000
 +++ src/ubuntuappmenu/theme.cpp	2016-12-09 17:04:44 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright (C) 2014 Canonical, Ltd.
++ * Copyright (C) 2016 Canonical, Ltd.
+  *
   * This program is free software: you can redistribute it and/or modify it under
   * the terms of the GNU Lesser General Public License version 3, as published by
@@ -15,20 +15,35 @@
   */
  #include "theme.h"
++#include "gmenumodelplatformmenu.h"
++#include "logging.h"
  #include <QtCore/QVariant>
--
--const char *UbuntuTheme::name = "ubuntu";
--
--UbuntuTheme::UbuntuTheme()
--{
--}
--
--UbuntuTheme::~UbuntuTheme()
--{
--}
--
--QVariant UbuntuTheme::themeHint(ThemeHint hint) const
++#include <QDebug>
++
++Q_LOGGING_CATEGORY(ubuntuappmenu, "ubuntuappmenu", QtWarningMsg)
++const char *UbuntuAppMenuTheme::name = "ubuntuappmenu";
++
++namespace {
++
++bool useLocalMenu() {
++    QByteArray menuProxy = qgetenv("UBUNTU_MENUPROXY");
++    bool menuProxyIsZero = !menuProxy.isEmpty() && menuProxy.at(0) == '0';
++    return menuProxyIsZero;
++}
++
++}
++
++UbuntuAppMenuTheme::UbuntuAppMenuTheme()
++{
++    qCDebug(ubuntuappmenu, "UbuntuAppMenuTheme::UbuntuAppMenuTheme() - useLocalMenu=%s", useLocalMenu() ? "true" : "false");
++}
++
++UbuntuAppMenuTheme::~UbuntuAppMenuTheme()
++{
++}
++
++QVariant UbuntuAppMenuTheme::themeHint(ThemeHint hint) const
+ {
      if (hint == QPlatformTheme::SystemIconThemeName) {
          QByteArray iconTheme = qgetenv("QTUBUNTU_ICON_THEME");
@@ -41,3 +56,21 @@
          return QGenericUnixTheme::themeHint(hint);
+     }
+ }
++
++QPlatformMenuItem *UbuntuAppMenuTheme::createPlatformMenuItem() const
++{
++    if (useLocalMenu()) return QGenericUnixTheme::createPlatformMenuItem();
++    return new UbuntuPlatformMenuItem();
++}
++
++QPlatformMenu *UbuntuAppMenuTheme::createPlatformMenu() const
++{
++    if (useLocalMenu()) return QGenericUnixTheme::createPlatformMenu();
++    return new UbuntuPlatformMenu();
++}
++
++QPlatformMenuBar *UbuntuAppMenuTheme::createPlatformMenuBar() const
++{
++    if (useLocalMenu()) return QGenericUnixTheme::createPlatformMenuBar();
++    return new UbuntuPlatformMenuBar();
++}
 === renamed file 'src/ubuntumirclient/theme.h' => 'src/ubuntuappmenu/theme.h'
 --- src/ubuntumirclient/theme.h	2014-06-18 23:10:00 +0000
 +++ src/ubuntuappmenu/theme.h	2016-12-09 17:04:44 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright (C) 2014 Canonical, Ltd.
++ * Copyright (C) 2016 Canonical, Ltd.
+  *
   * This program is free software: you can redistribute it and/or modify it under
   * the terms of the GNU Lesser General Public License version 3, as published by
@@ -19,15 +19,20 @@
  #include <QtPlatformSupport/private/qgenericunixthemes_p.h>
--class UbuntuTheme : public QGenericUnixTheme
++class UbuntuAppMenuTheme : public QGenericUnixTheme
+ {
  public:
      static const char* name;
--    UbuntuTheme();
--    virtual ~UbuntuTheme();
++    UbuntuAppMenuTheme();
++    virtual ~UbuntuAppMenuTheme();
      // From QPlatformTheme
      QVariant themeHint(ThemeHint hint) const override;
++
++    // For the menus
++    virtual QPlatformMenuItem* createPlatformMenuItem() const override;
++    virtual QPlatformMenu* createPlatformMenu() const override;
++    virtual QPlatformMenuBar* createPlatformMenuBar() const override;
  };
  #endif // UBUNTU_THEME_H
 === added file 'src/ubuntuappmenu/themeplugin.cpp'
 --- src/ubuntuappmenu/themeplugin.cpp	1970-01-01 00:00:00 +0000
 +++ src/ubuntuappmenu/themeplugin.cpp	2016-12-09 17:04:44 +0000
@@ -0,0 +1,36 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it under
++ * the terms of the GNU Lesser General Public License version 3, as published by
++ * the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
++ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++ * Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include "themeplugin.h"
++#include "theme.h"
++
++#include <QDebug>
++
++///////////////////////////////////////////////////////////
++
++UbuntuAppMenuThemePlugin::UbuntuAppMenuThemePlugin(QObject *parent)
++    : QPlatformThemePlugin(parent)
++{
++}
++
++QPlatformTheme *
++UbuntuAppMenuThemePlugin::create(const QString &key, const QStringList&)
++{
++    if (key.compare(QLatin1String(UbuntuAppMenuTheme::name), Qt::CaseInsensitive))
++        return 0;
++
++    return new UbuntuAppMenuTheme();
++}
 === added file 'src/ubuntuappmenu/themeplugin.h'
 --- src/ubuntuappmenu/themeplugin.h	1970-01-01 00:00:00 +0000
 +++ src/ubuntuappmenu/themeplugin.h	2016-12-09 17:04:44 +0000
@@ -0,0 +1,34 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it under
++ * the terms of the GNU Lesser General Public License version 3, as published by
++ * the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
++ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++ * Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef UBUNTUTHEMEPLUGIN_H
++#define UBUNTUTHEMEPLUGIN_H
++
++#include <qpa/qplatformthemeplugin.h>
++
++class UbuntuAppMenuThemePlugin : public QPlatformThemePlugin
++{
++    Q_OBJECT
++    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QPA.QPlatformThemeFactoryInterface.5.1" FILE "ubuntuappmenu.json")
++public:
++    UbuntuAppMenuThemePlugin(QObject *parent = 0);
++
++    virtual QPlatformTheme *create(const QString &key, const QStringList &paramList);
++
++    static const char *name;
++};
++
++#endif
 === added file 'src/ubuntuappmenu/ubuntuappmenu.json'
 --- src/ubuntuappmenu/ubuntuappmenu.json	1970-01-01 00:00:00 +0000
 +++ src/ubuntuappmenu/ubuntuappmenu.json	2016-12-09 17:04:44 +0000
@@ -0,0 +1,3 @@
++{
++    "Keys": [ "ubuntuappmenu" ]
++}
 === added file 'src/ubuntuappmenu/ubuntuappmenu.pro'
 --- src/ubuntuappmenu/ubuntuappmenu.pro	1970-01-01 00:00:00 +0000
 +++ src/ubuntuappmenu/ubuntuappmenu.pro	2016-12-09 17:04:44 +0000
@@ -0,0 +1,41 @@
++TARGET = ubuntuappmenu
++TEMPLATE = lib
++
++QT -= gui
++QT += core-private platformsupport-private dbus
++
++CONFIG += plugin no_keywords
++
++# CONFIG += c++11 # only enables C++0x
++QMAKE_CXXFLAGS += -fvisibility=hidden -fvisibility-inlines-hidden -std=c++11 -Werror -Wall
++QMAKE_LFLAGS += -std=c++11 -Wl,-no-undefined
++
++CONFIG += link_pkgconfig
++PKGCONFIG += gio-2.0
++
++DBUS_INTERFACES += com.ubuntu.MenuRegistrar.xml
++
++HEADERS += \
++    theme.h \
++    gmenumodelexporter.h \
++    gmenumodelplatformmenu.h \
++    logging.h \
++    menuregistrar.h \
++    registry.h \
++    themeplugin.h
++
++SOURCES += \
++    theme.cpp \
++    gmenumodelexporter.cpp \
++    gmenumodelplatformmenu.cpp \
++    menuregistrar.cpp \
++    registry.cpp \
++    themeplugin.cpp
++
++OTHER_FILES += \
++    ubuntuappmenu.json
++
++# Installation path
++target.path +=  $$[QT_INSTALL_PLUGINS]/platformthemes
++
++INSTALLS += target
 === modified file 'src/ubuntumirclient/integration.cpp'
 --- src/ubuntumirclient/integration.cpp	2016-12-01 22:28:20 +0000
 +++ src/ubuntumirclient/integration.cpp	2016-12-09 17:04:44 +0000
@@ -25,7 +25,6 @@
  #include "logging.h"
  #include "nativeinterface.h"
  #include "screen.h"
--#include "theme.h"
  #include "window.h"
  // Qt
@@ -39,6 +38,7 @@
  #include <QtPlatformSupport/private/qgenericunixfontdatabase_p.h>
  #include <QtPlatformSupport/private/qgenericunixeventdispatcher_p.h>
  #include <QtPlatformSupport/private/qeglpbuffer_p.h>
++#include <QtPlatformSupport/private/qgenericunixthemes_p.h>
  #include <QtPlatformSupport/private/bridge_p.h>
  #include <QOpenGLContext>
  #include <QOffscreenSurface>
@@ -48,6 +48,27 @@
  #include <ubuntu/application/id.h>
  #include <ubuntu/application/options.h>
++
++class UbuntuIconTheme : public QGenericUnixTheme
++{
++public:
++    UbuntuIconTheme() {}
++
++    // From QPlatformTheme
++    QVariant themeHint(ThemeHint hint) const override {
++        if (hint == QPlatformTheme::SystemIconThemeName) {
++            QByteArray iconTheme = qgetenv("QTUBUNTU_ICON_THEME");
++            if (iconTheme.isEmpty()) {
++                return QVariant(QStringLiteral("ubuntu-mobile"));
++            } else {
++                return QVariant(QString(iconTheme));
++            }
++        } else {
++            return QGenericUnixTheme::themeHint(hint);
++        }
++    }
++};
++
  static void resumedCallback(const UApplicationOptions */*options*/, void *context)
+ {
      auto integration = static_cast<UbuntuClientIntegration*>(context);
@@ -294,13 +315,13 @@
  QStringList UbuntuClientIntegration::themeNames() const
+ {
--    return QStringList(UbuntuTheme::name);
++    return QStringList(QStringLiteral("ubuntuappmenu"));
+ }
  QPlatformTheme* UbuntuClientIntegration::createPlatformTheme(const QString& name) const
+ {
      Q_UNUSED(name);
--    return new UbuntuTheme;
++    return new UbuntuIconTheme;
+ }
  QVariant UbuntuClientIntegration::styleHint(StyleHint hint) const
 === modified file 'src/ubuntumirclient/nativeinterface.cpp'
 --- src/ubuntumirclient/nativeinterface.cpp	2016-06-21 12:17:55 +0000
 +++ src/ubuntumirclient/nativeinterface.cpp	2016-12-09 17:04:44 +0000
@@ -162,6 +162,7 @@
      if (w) {
          propertyMap.insert("scale", w->scale());
          propertyMap.insert("formFactor", w->formFactor());
++        propertyMap.insert("persistentSurfaceId", w->persistentSurfaceId());
+     }
      return propertyMap;
+ }
@@ -177,6 +178,8 @@
          return w->scale();
      } else if (name == QStringLiteral("formFactor")) {
          return w->formFactor();
++    }  else if (name == QStringLiteral("persistentSurfaceId")) {
++        return w->persistentSurfaceId();
      } else {
          return QVariant();
+     }
 === modified file 'src/ubuntumirclient/plugin.cpp'
 --- src/ubuntumirclient/plugin.cpp	2016-06-24 12:36:24 +0000
 +++ src/ubuntumirclient/plugin.cpp	2016-12-09 17:04:44 +0000
@@ -17,6 +17,7 @@
  #include "plugin.h"
  #include "integration.h"
  #include "logging.h"
++#include "qpa/qplatformwindow.h"
  Q_LOGGING_CATEGORY(ubuntumirclient, "ubuntumirclient", QtWarningMsg)
@@ -24,6 +25,8 @@
                                                                 const QStringList &/*paramList*/,
                                                                 int &argc, char **argv)
+ {
++    qRegisterMetaType<QPlatformWindow*>("QPlatformWindow*");
++
      if (system.toLower() == QLatin1String("ubuntumirclient")) {
  #ifdef PLATFORM_API_TOUCH
          setenv("UBUNTU_PLATFORM_API_BACKEND", "touch_mirclient", 1);
 === modified file 'src/ubuntumirclient/ubuntumirclient.pro'
 --- src/ubuntumirclient/ubuntumirclient.pro	2016-11-04 13:20:58 +0000
 +++ src/ubuntumirclient/ubuntumirclient.pro	2016-12-09 17:04:44 +0000
@@ -28,7 +28,6 @@
      plugin.cpp \
      screen.cpp \
      screenobserver.cpp \
--    theme.cpp \
      window.cpp \
      appstatecontroller.cpp
@@ -41,17 +40,19 @@
      glcontext.h \
      input.h \
      integration.h \
--    logging.h \
      nativeinterface.h \
      orientationchangeevent_p.h \
      platformservices.h \
      plugin.h \
      screenobserver.h \
      screen.h \
--    theme.h \
      window.h \
++    logging.h \
      appstatecontroller.h
++OTHER_FILES += \
++    ubuntumirclient.json
++
  # Installation path
  target.path +=  $$[QT_INSTALL_PLUGINS]/platforms
 === modified file 'src/ubuntumirclient/window.cpp'
 --- src/ubuntumirclient/window.cpp	2016-11-23 12:11:14 +0000
 +++ src/ubuntumirclient/window.cpp	2016-12-09 17:04:44 +0000
@@ -712,6 +712,11 @@
              w, w->screen()->handle(), input, mSurface.get(), qPrintable(window()->title()), roleFor(window()));
      updatePanelHeightHack(mSurface->state() != mir_surface_state_fullscreen);
++
++    // queue the windowPropertyChanged signal. If it's emitted directly, the platformWindow will not yet be set for the window.
++    QMetaObject::invokeMethod(mNativeInterface, "windowPropertyChanged", Qt::QueuedConnection,
++                              Q_ARG(QPlatformWindow*, this),
++                              Q_ARG(QString, "persistentSurfaceId"));
+ }
  UbuntuWindow::~UbuntuWindow()
 === modified file 'src/ubuntumirclient/window.h'
 --- src/ubuntumirclient/window.h	2016-11-23 12:11:14 +0000
 +++ src/ubuntumirclient/window.h	2016-12-09 17:04:44 +0000
@@ -92,4 +92,6 @@
      MirFormFactor mFormFactor;
  };
++Q_DECLARE_METATYPE(QPlatformWindow*);
++
  #endif // UBUNTU_WINDOW_H