Merge lp:~azzar1/hud/hud-wnck-actions-menu into lp:hud

[Andrea Azzarone]

Introduce DBusMenuWindowCollector to make it possible to expose the window actions menu through dbusmenu.

Introduce DBusMenuWindowCollector to make it possible to expose the window actions menu through dbus.

[lp:~azzar1/hud/hud-wnck-actions-menu]

406. By Andrea Azzarone on 2016-04-06

Fix indent.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:406
http://jenkins.qa.ubuntu.com/job/hud-ci/307/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/hud-wily-amd64-ci/5/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/hud-wily-armhf-ci/5/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/hud-wily-i386-ci/5/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/hud-ci/307/rebuild

review: Needs Fixing (continuous-integration)

[lp:~azzar1/hud/hud-wnck-actions-menu]

407. By Andrea Azzarone on 2016-04-07

Add missing files.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:407
http://jenkins.qa.ubuntu.com/job/hud-ci/308/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/hud-wily-amd64-ci/6
    SUCCESS: http://jenkins.qa.ubuntu.com/job/hud-wily-armhf-ci/6
    SUCCESS: http://jenkins.qa.ubuntu.com/job/hud-wily-i386-ci/6

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/hud-ci/308/rebuild

review: Approve (continuous-integration)

[lp:~azzar1/hud/hud-wnck-actions-menu]

408. By Andrea Azzarone on 2016-04-07

Allow to search using the mnemonic key.

409. By Andrea Azzarone on 2016-04-07

Fix DBusMenuWindowCollector::isValid.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:409
http://jenkins.qa.ubuntu.com/job/hud-ci/309/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/hud-wily-amd64-ci/7
    SUCCESS: http://jenkins.qa.ubuntu.com/job/hud-wily-armhf-ci/7
    SUCCESS: http://jenkins.qa.ubuntu.com/job/hud-wily-i386-ci/7

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/hud-ci/309/rebuild

review: Approve (continuous-integration)

[Marco Trevisan (Treviño) (3v1n0)]

Nice!

However, since Hud already relies on BAMF and it knows the paths we're handling, there's really no reason to export _WNCK_ACTION_MENU_OBJECT_PATH on windows in BAMF side and then reading it here.

We can just use the window stack to get that.
So, please merge this with my branch, where I've implemented this: lp:~3v1n0/hud/stack-get-bus-address

[Marco Trevisan (Treviño) (3v1n0)]

Ah, about the searchByMnemonic thing... Maybe it should be enabled for all the menus?
Including the ones provided by GMenuModel (thus probably just keeping it as default, without adding a property)?

[lp:~azzar1/hud/hud-wnck-actions-menu]

410. By Andrea Azzarone on 2016-04-12

Merge with lp:~3v1n0/hud/stack-get-bus-address.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:410
http://jenkins.qa.ubuntu.com/job/hud-ci/310/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/hud-wily-amd64-ci/8/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/hud-wily-armhf-ci/8/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/hud-wily-i386-ci/8/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/hud-ci/310/rebuild

review: Needs Fixing (continuous-integration)

[Marco Trevisan (Treviño) (3v1n0)]

Ouch, forgot http://pastebin.ubuntu.com/15784656/ please apply it.

(or just bzr pull lp:~3v1n0/hud/stack-get-bus-address)

[lp:~azzar1/hud/hud-wnck-actions-menu]

411. By Andrea Azzarone on 2016-04-12

Merge with lp:~3v1n0/hud/stack-get-bus-address)

[Andrea Azzarone (azzar1)]

> Ouch, forgot http://pastebin.ubuntu.com/15784656/ please apply it.
>
> (or just bzr pull lp:~3v1n0/hud/stack-get-bus-address)

Done.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:411
http://jenkins.qa.ubuntu.com/job/hud-ci/311/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/hud-wily-amd64-ci/9/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/hud-wily-armhf-ci/9
    FAILURE: http://jenkins.qa.ubuntu.com/job/hud-wily-i386-ci/9/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/hud-ci/311/rebuild

review: Needs Fixing (continuous-integration)

[Marco Trevisan (Treviño) (3v1n0)]

CI failures are pretty random. Not nice, but nothing caused by this change.

Let's go with this.

review: Approve

[Pete Woods (pete-woods)]

If you had exported the menu as a GMenu on your end, you probably wouldn't have had to touch HUD at all, as it already supports collecting multiple GMenus.

[Andrea Azzarone (azzar1)]

> If you had exported the menu as a GMenu on your end, you probably wouldn't
> have had to touch HUD at all, as it already supports collecting multiple
> GMenus.

It was not possible to do so without an API break for libwnck.

=== modified file 'data/com.canonical.Unity.WindowStack.xml'
--- data/com.canonical.Unity.WindowStack.xml	2013-12-18 10:12:17 +0000
+++ data/com.canonical.Unity.WindowStack.xml	2016-04-12 11:12:57 +0000
@@ -22,6 +22,10 @@
       <arg name="app_id" type="s" direction="in"/>
       <arg name="property_names" type="as" direction="in"/>
     </method>
+    <method name="GetWindowBusAddress">
+      <arg name="address_path" type="as" direction="out"/>
+      <arg name="window_id" type="u" direction="in"/>
+    </method>
     <method name="GetAppIdFromPid">
       <arg name="app_id" type="s" direction="out"/>
       <arg name="pid" type="u" direction="in"/>

=== modified file 'service/CMakeLists.txt'
--- service/CMakeLists.txt	2015-08-20 13:44:43 +0000
+++ service/CMakeLists.txt	2016-04-12 11:12:57 +0000
@@ -16,6 +16,7 @@
   ApplicationListImpl.cpp
   Collector.cpp
   DBusMenuCollector.cpp
+  DBusMenuWindowCollector.cpp
   Factory.cpp
   GMenuCollector.cpp
   GMenuWindowCollector.cpp

=== modified file 'service/DBusMenuCollector.cpp'
--- service/DBusMenuCollector.cpp	2014-05-13 10:23:56 +0000
+++ service/DBusMenuCollector.cpp	2016-04-12 11:12:57 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Canonical, Ltd.
+ * Copyright (C) 2013-2016 Canonical, Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 3, as published
@@ -14,63 +14,28 @@
  * with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Author: Pete Woods <[e-mail]>
+ *         Andrea Azzarone <[e-mail]>
  */
 
-#include <common/DBusTypes.h>
-#include <common/Localisation.h>
 #include <service/DBusMenuCollector.h>
-#include <service/AppmenuRegistrarInterface.h>
 
 #include <dbusmenuimporter.h>
+#include <QDebug>
 #include <QMenu>
 #include <stdexcept>
 
-using namespace hud::common;
 using namespace hud::service;
 
-DBusMenuCollector::DBusMenuCollector(unsigned int windowId,
-		QSharedPointer<ComCanonicalAppMenuRegistrarInterface> registrar) :
-		m_windowId(windowId), m_registrar(registrar) {
-
-	connect(registrar.data(),
-	SIGNAL(WindowRegistered(uint, const QString &, const QDBusObjectPath &)),
-			this,
-			SLOT( WindowRegistered(uint, const QString &, const QDBusObjectPath &)));
-
-	QDBusPendingReply<QString, QDBusObjectPath> windowReply =
-			registrar->GetMenuForWindow(m_windowId);
-
-	windowReply.waitForFinished();
-	if (windowReply.isError()) {
-		return;
-	}
-
-	windowRegistered(windowReply.argumentAt<0>(), windowReply.argumentAt<1>());
-}
-
-DBusMenuCollector::~DBusMenuCollector() {
-}
-
-void DBusMenuCollector::windowRegistered(const QString &service,
-		const QDBusObjectPath &menuObjectPath) {
-
-	if (service.isEmpty()) {
-		return;
-	}
-
-	m_service = service;
-	m_path = menuObjectPath;
-
-	disconnect(m_registrar.data(),
-			SIGNAL(
-					WindowRegistered(uint, const QString &, const QDBusObjectPath &)),
-			this,
-			SLOT(
-					WindowRegistered(uint, const QString &, const QDBusObjectPath &)));
+DBusMenuCollector::DBusMenuCollector(const QString &service,
+		const QDBusObjectPath &menuObjectPath) :
+		m_service(service), m_path(menuObjectPath) {
+
+	if (m_service.isEmpty()) {
+		return;
+	}
 
 	m_menuImporter.reset(
-			new DBusMenuImporter(m_service, m_path.path(),
-					DBusMenuImporterType::SYNCHRONOUS));
+		new DBusMenuImporter(m_service, m_path.path(), DBusMenuImporterType::SYNCHRONOUS));
 
 	CollectorToken::Ptr collectorToken(m_collectorToken);
 	if(collectorToken) {
@@ -78,6 +43,9 @@
 	}
 }
 
+DBusMenuCollector::~DBusMenuCollector() {
+}
+
 bool DBusMenuCollector::isValid() const {
 	return !m_menuImporter.isNull();
 }
@@ -173,13 +141,3 @@
 		qDebug() << e.what();
 	}
 }
-
-void DBusMenuCollector::WindowRegistered(uint windowId, const QString &service,
-		const QDBusObjectPath &menuObjectPath) {
-	// Simply ignore updates for other windows
-	if (windowId != m_windowId) {
-		return;
-	}
-
-	windowRegistered(service, menuObjectPath);
-}

=== modified file 'service/DBusMenuCollector.h'
--- service/DBusMenuCollector.h	2014-03-26 09:00:05 +0000
+++ service/DBusMenuCollector.h	2016-04-12 11:12:57 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Canonical, Ltd.
+ * Copyright (C) 2013-2016 Canonical, Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 3, as published
@@ -14,6 +14,7 @@
  * with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Author: Pete Woods <[e-mail]>
+ *         Andrea Azzarone <[e-mail]>
  */
 
 #ifndef HUD_SERVICE_DBUSMENUCOLLECTOR_H_
@@ -21,10 +22,8 @@
 
 #include <service/Collector.h>
 
-#include <QDBusConnection>
-#include <memory>
+#include <QDBusObjectPath>
 
-class ComCanonicalAppMenuRegistrarInterface;
 class DBusMenuImporter;
 
 QT_BEGIN_NAMESPACE
@@ -34,46 +33,27 @@
 namespace hud {
 namespace service {
 
-class DBusMenuCollector: public Collector, public std::enable_shared_from_this<
-		DBusMenuCollector> {
-Q_OBJECT
+class DBusMenuCollector: public Collector,
+	public std::enable_shared_from_this<DBusMenuCollector> {
 public:
 	typedef std::shared_ptr<DBusMenuCollector> Ptr;
 
-	DBusMenuCollector(unsigned int windowId,
-			QSharedPointer<ComCanonicalAppMenuRegistrarInterface> appmenu);
-
+	DBusMenuCollector(const QString &service, const QDBusObjectPath &menuObjectPath);
 	virtual ~DBusMenuCollector();
 
 	virtual bool isValid() const override;
-
 	virtual QList<CollectorToken::Ptr> activate() override;
 
-protected Q_SLOTS:
-	void WindowRegistered(uint windowId, const QString &service,
-			const QDBusObjectPath &menuObjectPath);
-
-protected:
-	virtual void deactivate();
-
-	void windowRegistered(const QString &service,
-			const QDBusObjectPath &menuObjectPath);
-
-protected:
+protected:
+	virtual void deactivate() override;
+
 	void openMenu(QMenu *menu, unsigned int &limit);
-
 	void hideMenu(QMenu *menu, unsigned int &limit);
 
-	unsigned int m_windowId;
-
-	QSharedPointer<ComCanonicalAppMenuRegistrarInterface> m_registrar;
-
 	QWeakPointer<CollectorToken> m_collectorToken;
-
 	QSharedPointer<DBusMenuImporter> m_menuImporter;
 
 	QString m_service;
-
 	QDBusObjectPath m_path;
 };
 

=== added file 'service/DBusMenuWindowCollector.cpp'
--- service/DBusMenuWindowCollector.cpp	1970-01-01 00:00:00 +0000
+++ service/DBusMenuWindowCollector.cpp	2016-04-12 11:12:57 +0000
@@ -0,0 +1,141 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Andrea Azzarone <[e-mail]>
+ */
+
+#include <common/DBusTypes.h>
+#include <common/WindowStackInterface.h>
+#include <service/AppmenuRegistrarInterface.h>
+#include <service/DBusMenuWindowCollector.h>
+#include <service/Factory.h>
+
+#include <QStringList>
+
+using namespace hud::common;
+using namespace hud::service;
+
+DBusMenuWindowCollector::DBusMenuWindowCollector(unsigned int windowId,
+		QSharedPointer<ComCanonicalUnityWindowStackInterface> windowStack,
+		QSharedPointer<ComCanonicalAppMenuRegistrarInterface> registrar,
+		Factory &factory) :
+		m_windowId(windowId), m_registrar(registrar), m_factory(factory) {
+
+	connect(registrar.data(),
+		SIGNAL(WindowRegistered(uint, const QString &, const QDBusObjectPath &)),
+		this,
+		SLOT(WindowRegistered(uint, const QString &, const QDBusObjectPath &)));
+
+	QDBusPendingReply<QStringList> windowDBusAddressReply(
+		windowStack->GetWindowBusAddress(windowId));
+
+	// Window action menu
+	windowDBusAddressReply.waitForFinished();
+	if (!windowDBusAddressReply.isError()) {
+		QStringList windowDBusAddress(windowDBusAddressReply);
+
+		if (windowDBusAddress.size() == 2) {
+			const QString &name = windowDBusAddress.at(0);
+			const QString &path = windowDBusAddress.at(1);
+
+			if (!name.isEmpty() && !path.isEmpty())
+				m_am_collector = factory.newDBusMenuCollector(name, QDBusObjectPath(path));
+		}
+	}
+
+	// AppMenu
+	QDBusPendingReply<QString, QDBusObjectPath> windowReply =
+		registrar->GetMenuForWindow(m_windowId);
+
+	windowReply.waitForFinished();
+	if (windowReply.isError()) {
+		return;
+	}
+
+	windowRegistered(windowReply.argumentAt<0>(), windowReply.argumentAt<1>());
+}
+
+DBusMenuWindowCollector::~DBusMenuWindowCollector() {
+}
+
+bool DBusMenuWindowCollector::isValid() const {
+	return m_collector || m_am_collector;
+}
+
+static void setPropertyForAllActions(QMenu *menu) {
+	if (!menu)
+		return;
+
+	for (QAction *action : menu->actions()) {
+		if (!action->isEnabled()) {
+			continue;
+		}
+
+		if (action->isSeparator()) {
+			continue;
+		}
+
+		action->setProperty("searchByMnemonic", true);
+		setPropertyForAllActions(action->menu());
+	}
+}
+
+QList<CollectorToken::Ptr> DBusMenuWindowCollector::activate() {
+	QList<CollectorToken::Ptr> ret;
+
+	if (m_am_collector) {
+		QList<CollectorToken::Ptr> tokens = m_am_collector->activate();
+
+		for (CollectorToken::Ptr token : tokens) {
+			setPropertyForAllActions(token->menu());
+		}
+
+		ret.append(tokens);
+	}
+
+	if (m_collector) {
+		ret.append(m_collector->activate());
+	}
+
+	return ret;
+}
+
+void DBusMenuWindowCollector::deactivate() {
+}
+
+void DBusMenuWindowCollector::WindowRegistered(uint windowId, const QString &service,
+		const QDBusObjectPath &menuObjectPath) {
+	// Simply ignore updates for other windows
+	if (windowId != m_windowId) {
+		return;
+	}
+
+	windowRegistered(service, menuObjectPath);
+}
+
+void DBusMenuWindowCollector::windowRegistered(const QString &service,
+                                               const QDBusObjectPath &menuObjectPath) {
+
+	if (service.isEmpty()) {
+		return;
+	}
+
+	disconnect(m_registrar.data(),
+		SIGNAL(WindowRegistered(uint, const QString &, const QDBusObjectPath &)),
+		this,
+		SLOT(WindowRegistered(uint, const QString &, const QDBusObjectPath &)));
+
+	m_collector = m_factory.newDBusMenuCollector(service, menuObjectPath);
+}

=== added file 'service/DBusMenuWindowCollector.h'
--- service/DBusMenuWindowCollector.h	1970-01-01 00:00:00 +0000
+++ service/DBusMenuWindowCollector.h	2016-04-12 11:12:57 +0000
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Andrea Azzarone <[e-mail]>
+ */
+
+#ifndef HUD_SERVICE_DBUSMENUWINDOWCOLLECTOR_H_
+#define HUD_SERVICE_DBUSMENUWINDOWCOLLECTOR_H_
+
+#include <service/Collector.h>
+
+class ComCanonicalAppMenuRegistrarInterface;
+class ComCanonicalUnityWindowStackInterface;
+
+namespace qtgmenu {
+class QtGMenuImporter;
+}
+
+namespace hud {
+namespace service {
+
+class Factory;
+
+class DBusMenuWindowCollector: public Collector,
+		public std::enable_shared_from_this<DBusMenuWindowCollector> {
+Q_OBJECT
+public:
+	typedef std::shared_ptr<DBusMenuWindowCollector> Ptr;
+
+	DBusMenuWindowCollector(unsigned int windowId,
+		QSharedPointer<ComCanonicalUnityWindowStackInterface> windowStack,
+		QSharedPointer<ComCanonicalAppMenuRegistrarInterface> registrar,
+		Factory &factory);
+	virtual ~DBusMenuWindowCollector();
+
+	virtual bool isValid() const override;
+	virtual QList<CollectorToken::Ptr> activate() override;
+
+protected Q_SLOTS:
+	void WindowRegistered(uint windowId, const QString &service,
+		const QDBusObjectPath &menuObjectPath);
+
+protected:
+    virtual void deactivate() override;
+
+private:
+    void windowRegistered(const QString &service,
+		const QDBusObjectPath &menuObjectPath);
+
+	Collector::Ptr m_am_collector;
+	Collector::Ptr m_collector;
+	unsigned int m_windowId;
+	QSharedPointer<ComCanonicalAppMenuRegistrarInterface> m_registrar;
+	Factory &m_factory;
+};
+
+}
+}
+
+#endif /* HUD_SERVICE_DBUSMENUWINDOWCOLLECTOR_H_ */

=== modified file 'service/Factory.cpp'
--- service/Factory.cpp	2015-08-20 13:44:43 +0000
+++ service/Factory.cpp	2016-04-12 11:12:57 +0000
@@ -161,10 +161,9 @@
 	return WindowContext::Ptr(new WindowContextImpl(*this));
 }
 
-Collector::Ptr Factory::newDBusMenuCollector(unsigned int windowId,
-		const QString &applicationId) {
-	Q_UNUSED(applicationId);
-	return Collector::Ptr(new DBusMenuCollector(windowId, singletonAppmenu()));
+Collector::Ptr Factory::newDBusMenuCollector(const QString &service,
+		const QDBusObjectPath &menuObjectPath) {
+	return Collector::Ptr(new DBusMenuCollector(service, menuObjectPath));
 }
 
 Collector::Ptr Factory::newGMenuCollector(const QString &name,
@@ -187,3 +186,9 @@
 			new GMenuWindowCollector(windowId, applicationId,
 					singletonWindowStack(), *this));
 }
+
+Collector::Ptr Factory::newDBusMenuWindowCollector(unsigned int windowId) {
+	return Collector::Ptr(
+			new DBusMenuWindowCollector(windowId,
+					singletonWindowStack(), singletonAppmenu(), *this));
+}

=== modified file 'service/Factory.h'
--- service/Factory.h	2015-08-20 11:12:22 +0000
+++ service/Factory.h	2016-04-12 11:12:57 +0000
@@ -23,6 +23,7 @@
 #include <service/Application.h>
 #include <service/ApplicationList.h>
 #include <service/DBusMenuCollector.h>
+#include <service/DBusMenuWindowCollector.h>
 #include <service/GMenuWindowCollector.h>
 #include <service/GMenuCollector.h>
 #include <service/ItemStore.h>
@@ -87,8 +88,8 @@
 	virtual WindowToken::Ptr newWindowToken(const QString &applicationId,
 			QList<CollectorToken::Ptr> tokens);
 
-	virtual Collector::Ptr newDBusMenuCollector(unsigned int windowId,
-			const QString &applicationId);
+	virtual Collector::Ptr newDBusMenuCollector(const QString &service,
+		const QDBusObjectPath &menuObjectPath);
 
 	virtual Collector::Ptr newGMenuCollector(const QString &name,
 			const QMap<QString, QDBusObjectPath> &actions,
@@ -101,6 +102,8 @@
 	virtual Collector::Ptr newGMenuWindowCollector(unsigned int windowId,
 			const QString &applicationId);
 
+	virtual Collector::Ptr newDBusMenuWindowCollector(unsigned int windowId);
+
 protected:
 	QDBusConnection m_sessionBus;
 

=== modified file 'service/ItemStore.cpp'
--- service/ItemStore.cpp	2014-03-24 17:19:58 +0000
+++ service/ItemStore.cpp	2016-04-12 11:12:57 +0000
@@ -61,6 +61,16 @@
 	return action->text().remove(SINGLE_AMPERSAND).replace("&&", "&");
 }
 
+static QChar getMnemonic(const QAction *action) {
+	int ampersandIndex = action->text().indexOf(SINGLE_AMPERSAND);
+
+	if (ampersandIndex < 0 || ampersandIndex >= action->text().length() - 1) {
+		return 0;
+	}
+
+	return action->text()[ampersandIndex+1].toLower();
+}
+
 void ItemStore::indexMenu(const QMenu *menu, const QMenu *root,
 		const QStringList &stack, const QList<int> &index) {
 	int i(-1);
@@ -74,6 +84,8 @@
 			continue;
 		}
 
+		bool searchByMnemonic(action->property("searchByMnemonic").toBool());
+
 		QStringList text(
 				convertActionText(action).remove(BAD_CHARACTERS).split(
 						WHITESPACE));
@@ -91,6 +103,11 @@
 		} else {
 			Document document(m_nextId);
 
+			if (searchByMnemonic) {
+				QChar mnemonic = getMnemonic(action);
+				m_mnemonic2DocumentId[mnemonic] = m_nextId;
+			}
+
 			WordList command;
 			for (const QString &word : text) {
 				command.addWord(Word(word.toUtf8().constData()));
@@ -199,6 +216,11 @@
 
 			int queryLength(query.length());
 
+			if (queryLength == 1 && m_mnemonic2DocumentId.contains(query[0])) {
+				int docId = m_mnemonic2DocumentId[query[0]];
+				addResult(docId, stringMatcher, queryLength, 1.0, results);
+			}
+
 			size_t maxResults = std::min(matchResults.size(), size_t(20));
 
 			for (size_t i(0); i < maxResults; ++i) {

=== modified file 'service/ItemStore.h'
--- service/ItemStore.h	2014-03-19 23:26:48 +0000
+++ service/ItemStore.h	2016-04-12 11:12:57 +0000
@@ -94,6 +94,8 @@
 	QMap<DocumentID, Item::Ptr> m_items;
 
 	QMap<QString, Item::Ptr> m_toolbarItems;
+
+	QMap<QChar, int> m_mnemonic2DocumentId;
 };
 
 }

=== modified file 'service/WindowImpl.cpp'
--- service/WindowImpl.cpp	2014-03-19 23:26:48 +0000
+++ service/WindowImpl.cpp	2016-04-12 11:12:57 +0000
@@ -78,7 +78,7 @@
 		WindowContextImpl(factory), m_applicationId(applicationId), m_allWindowsContext(
 				allWindowsContext) {
 
-	m_dbusMenuCollector = factory.newDBusMenuCollector(windowId, applicationId);
+	m_dbusMenuCollector = factory.newDBusMenuWindowCollector(windowId);
 	m_gMenuCollector = factory.newGMenuWindowCollector(windowId, applicationId);
 }
 

=== modified file 'tests/unit/service/Mocks.h'
--- tests/unit/service/Mocks.h	2014-03-19 23:26:48 +0000
+++ tests/unit/service/Mocks.h	2016-04-12 11:12:57 +0000
@@ -44,7 +44,7 @@
 
 	MOCK_METHOD0(singletonUsageTracker, UsageTracker::Ptr());
 
-	MOCK_METHOD2(newDBusMenuCollector, Collector::Ptr(unsigned int, const QString &));
+	MOCK_METHOD1(newDBusMenuWindowCollector, Collector::Ptr(unsigned int));
 
 	MOCK_METHOD2(newGMenuWindowCollector, Collector::Ptr(unsigned int, const QString &));
 

=== modified file 'tests/unit/service/TestWindow.cpp'
--- tests/unit/service/TestWindow.cpp	2014-03-05 12:59:07 +0000
+++ tests/unit/service/TestWindow.cpp	2016-04-12 11:12:57 +0000
@@ -52,8 +52,8 @@
 		allWindowsCollector.reset(new NiceMock<MockCollector>());
 		ON_CALL(*allWindowsCollector, isValid()).WillByDefault(Return(true));
 
-		dbusMenuCollector.reset(new NiceMock<MockCollector>());
-		ON_CALL(*dbusMenuCollector, isValid()).WillByDefault(Return(true));
+		dbusmenuWindowCollector.reset(new NiceMock<MockCollector>());
+		ON_CALL(*dbusmenuWindowCollector, isValid()).WillByDefault(Return(true));
 
 		gmenuWindowCollector.reset(new NiceMock<MockCollector>());
 		ON_CALL(*gmenuWindowCollector, isValid()).WillByDefault(Return(true));
@@ -66,8 +66,8 @@
 	}
 
 	Window::Ptr createWindow() {
-		EXPECT_CALL(factory, newDBusMenuCollector(1234, QString("application-id"))).Times(
-				1).WillOnce(Return(dbusMenuCollector));
+		EXPECT_CALL(factory, newDBusMenuWindowCollector(1234)).Times(
+				1).WillOnce(Return(dbusmenuWindowCollector));
 		EXPECT_CALL(factory, newGMenuWindowCollector(1234, QString("application-id"))).Times(
 				1).WillOnce(Return(gmenuWindowCollector));
 
@@ -88,7 +88,7 @@
 
 	shared_ptr<MockCollector> allWindowsCollector;
 
-	shared_ptr<MockCollector> dbusMenuCollector;
+	shared_ptr<MockCollector> dbusmenuWindowCollector;
 
 	shared_ptr<MockCollector> gmenuWindowCollector;
 
@@ -106,21 +106,22 @@
 	ON_CALL(*allWindowsCollector, isValid()).WillByDefault(Return(false));
 	ON_CALL(*windowCollector, isValid()).WillByDefault(Return(false));
 
-	QMenu dbusMenuCollectorMenu;
-	CollectorToken::Ptr dbusMenuCollectorToken(
-			new CollectorToken(dbusMenuCollector, &dbusMenuCollectorMenu));
-	EXPECT_CALL(*dbusMenuCollector, activate()).Times(1).WillOnce(
-			Return(QList<CollectorToken::Ptr>() << dbusMenuCollectorToken));
+	QMenu dbusmenuWindowCollectorMenu;
+	CollectorToken::Ptr dbusmenuWindowCollectorToken(
+			new CollectorToken(dbusmenuWindowCollector,
+					&dbusmenuWindowCollectorMenu));
+	EXPECT_CALL(*dbusmenuWindowCollector, activate()).Times(1).WillOnce(
+			Return(QList<CollectorToken::Ptr>() << dbusmenuWindowCollectorToken));
 
 	WindowToken::Ptr token(window->activate());
-	EXPECT_EQ(QList<CollectorToken::Ptr>() << dbusMenuCollectorToken,
+	EXPECT_EQ(QList<CollectorToken::Ptr>() << dbusmenuWindowCollectorToken,
 			token->tokens());
 }
 
 TEST_F(TestWindow, ActivateOnlyWithGMenu) {
 	Window::Ptr window(createWindow());
 
-	ON_CALL(*dbusMenuCollector, isValid()).WillByDefault(Return(false));
+	ON_CALL(*dbusmenuWindowCollector, isValid()).WillByDefault(Return(false));
 	ON_CALL(*allWindowsCollector, isValid()).WillByDefault(Return(false));
 	ON_CALL(*windowCollector, isValid()).WillByDefault(Return(false));
 
@@ -139,7 +140,7 @@
 TEST_F(TestWindow, ActivateOnlyWithValidAllWindowsContext) {
 	Window::Ptr window(createWindow());
 
-	ON_CALL(*dbusMenuCollector, isValid()).WillByDefault(Return(false));
+	ON_CALL(*dbusmenuWindowCollector, isValid()).WillByDefault(Return(false));
 	ON_CALL(*gmenuWindowCollector, isValid()).WillByDefault(Return(false));
 	ON_CALL(*windowCollector, isValid()).WillByDefault(Return(false));
 
@@ -160,7 +161,7 @@
 TEST_F(TestWindow, ActivateOnlyWithValidWindowContext) {
 	Window::Ptr window(createWindow());
 
-	ON_CALL(*dbusMenuCollector, isValid()).WillByDefault(Return(false));
+	ON_CALL(*dbusmenuWindowCollector, isValid()).WillByDefault(Return(false));
 	ON_CALL(*gmenuWindowCollector, isValid()).WillByDefault(Return(false));
 	ON_CALL(*allWindowsCollector, isValid()).WillByDefault(Return(false));
 
@@ -201,11 +202,12 @@
 	EXPECT_CALL(*gmenuWindowCollector, activate()).Times(1).WillOnce(
 			Return(QList<CollectorToken::Ptr>() << gmenuWindowCollectorToken));
 
-	QMenu dbusMenuCollectorMenu;
-	CollectorToken::Ptr dbusMenuCollectorToken(
-			new CollectorToken(dbusMenuCollector, &dbusMenuCollectorMenu));
-	EXPECT_CALL(*dbusMenuCollector, activate()).Times(1).WillOnce(
-			Return(QList<CollectorToken::Ptr>() << dbusMenuCollectorToken));
+	QMenu dbusmenuWindowCollectorMenu;
+	CollectorToken::Ptr dbusmenuWindowCollectorToken(
+			new CollectorToken(dbusmenuWindowCollector,
+					&dbusmenuWindowCollectorMenu));
+	EXPECT_CALL(*dbusmenuWindowCollector, activate()).Times(1).WillOnce(
+			Return(QList<CollectorToken::Ptr>() << dbusmenuWindowCollectorToken));
 
 	QMenu allWindowsCollectorMenu;
 	CollectorToken::Ptr allWindowsCollectorToken(
@@ -217,7 +219,7 @@
 
 	WindowToken::Ptr token(window->activate());
 	EXPECT_EQ(
-			QList<CollectorToken::Ptr>() << dbusMenuCollectorToken
+			QList<CollectorToken::Ptr>() << dbusmenuWindowCollectorToken
 					<< gmenuWindowCollectorToken << allWindowsCollectorToken,
 			token->tokens());
 
@@ -230,8 +232,8 @@
 			Return(QList<CollectorToken::Ptr>() << gmenuWindowCollectorTokenChanged));
 
 	// Re-prime the other collectors
-	EXPECT_CALL(*dbusMenuCollector, activate()).Times(1).WillOnce(
-			Return(QList<CollectorToken::Ptr>() << dbusMenuCollectorToken));
+	EXPECT_CALL(*dbusmenuWindowCollector, activate()).Times(1).WillOnce(
+			Return(QList<CollectorToken::Ptr>() << dbusmenuWindowCollectorToken));
 	EXPECT_CALL(*allWindowsCollector, activate()).Times(1).WillOnce(
 			Return(QList<CollectorToken::Ptr>() << allWindowsCollectorToken));
 
@@ -239,7 +241,7 @@
 	EXPECT_NE(token, tokenChanged);
 
 	EXPECT_EQ(
-			QList<CollectorToken::Ptr>() << dbusMenuCollectorToken
+			QList<CollectorToken::Ptr>() << dbusmenuWindowCollectorToken
 					<< gmenuWindowCollectorTokenChanged
 					<< allWindowsCollectorToken, tokenChanged->tokens());
 }

=== modified file 'window-stack-bridge/AbstractWindowStack.h'
--- window-stack-bridge/AbstractWindowStack.h	2013-12-18 15:19:38 +0000
+++ window-stack-bridge/AbstractWindowStack.h	2016-04-12 11:12:57 +0000
@@ -52,6 +52,8 @@
 	virtual QStringList GetWindowProperties(uint windowId, const QString &appId,
 			const QStringList &names) = 0;
 
+	virtual QStringList GetWindowBusAddress(uint windowId) = 0;
+
 Q_SIGNALS:
 	void FocusedWindowChanged(uint windowId, const QString &appId, uint stage);
 

=== modified file 'window-stack-bridge/BamfWindowStack.cpp'
--- window-stack-bridge/BamfWindowStack.cpp	2013-12-18 15:19:38 +0000
+++ window-stack-bridge/BamfWindowStack.cpp	2016-04-12 11:12:57 +0000
@@ -84,6 +84,16 @@
 	return m_windowId;
 }
 
+QString BamfWindow::service() const
+{
+	return m_window.service();
+}
+
+QString BamfWindow::path() const
+{
+	return m_window.path();
+}
+
 const QString & BamfWindow::applicationId() {
 	return m_applicationId;
 }
@@ -237,6 +247,17 @@
 	return result;
 }
 
+QStringList BamfWindowStack::GetWindowBusAddress(uint windowId) {
+	const auto window = m_windowsById[windowId];
+
+	if (window == nullptr) {
+		sendErrorReply(QDBusError::InvalidArgs, "Unable to find windowId");
+		return {};
+	}
+
+	return {window->service(), window->path()};
+}
+
 void BamfWindowStack::ActiveWindowChanged(const QString &oldWindowPath,
 		const QString &newWindowPath) {
 	Q_UNUSED(oldWindowPath);

=== modified file 'window-stack-bridge/BamfWindowStack.h'
--- window-stack-bridge/BamfWindowStack.h	2013-12-18 15:19:38 +0000
+++ window-stack-bridge/BamfWindowStack.h	2016-04-12 11:12:57 +0000
@@ -34,6 +34,10 @@
 
 	unsigned int windowId();
 
+	QString service() const;
+
+	QString path() const;
+
 	const QString & applicationId();
 
 	const QString xProp(const QString &property);
@@ -70,6 +74,8 @@
 	QStringList GetWindowProperties(uint windowId, const QString &appId,
 			const QStringList &names) override;
 
+	QStringList GetWindowBusAddress(uint windowId) override;
+
 protected Q_SLOTS:
 	void ActiveWindowChanged(const QString &oldWindow,
 			const QString &newWindow);