Differential D10461 Diff 27077 gmenu-dbusmenu-proxy/menuproxy.cpp

Changeset View

Standalone View

View Options

gmenu-dbusmenu-proxy/menuproxy.cpp

  • This file was added.
1​/*
2​ * Copyright (C) 2018 Kai Uwe Broulik <kde@privat.broulik.de>
3​ *
4​ * This library is free software; you can redistribute it and/or
5​ * modify it under the terms of the GNU Lesser General Public
6​ * License as published by the Free Software Foundation; either
7​ * version 2.1 of the License, or (at your option) any later version.
8​ *
9​ * This library is distributed in the hope that it will be useful,
10​ * but WITHOUT ANY WARRANTY; without even the implied warranty of
11​ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12​ * Lesser General Public License for more details.
13​ *
14​ * You should have received a copy of the GNU Lesser General Public
15​ * License along with this library; if not, write to the Free Software
16​ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17​ *
18​ */
19​
20​#include "menuproxy.h"
21​
22​#include <config-X11.h>
23​
24​#include "debug.h"
25​
26​#include <QByteArray>
27​#include <QCoreApplication>
28​#include <QDBusConnection>
29​#include <QDBusConnectionInterface>
30​#include <QDBusServiceWatcher>
31​#include <QDir>
32​#include <QFileInfo>
33​#include <QHash>
34​#include <QStandardPaths>
35​
36​#include <KConfigGroup>
37​#include <KSharedConfig>
38​#include <KWindowSystem>
39​
40​#include <QX11Info>
41​#include <xcb/xcb.h>
42​#include <xcb/xcb_atom.h>
43​
44​#include "menu.h"
45​
46​static const QString s_ourServiceName = QStringLiteral("org.kde.plasma.gmenu_dbusmenu_proxy");
47​
48​static const QString s_dbusMenuRegistrar = QStringLiteral("com.canonical.AppMenu.Registrar");
49​
50​static const QByteArray s_gtkUniqueBusName = QByteArrayLiteral("_GTK_UNIQUE_BUS_NAME");
51​
52​static const QByteArray s_gtkApplicationObjectPath = QByteArrayLiteral("_GTK_APPLICATION_OBJECT_PATH");
53​static const QByteArray s_gtkWindowObjectPath = QByteArrayLiteral("_GTK_WINDOW_OBJECT_PATH");
54​static const QByteArray s_gtkMenuBarObjectPath = QByteArrayLiteral("_GTK_MENUBAR_OBJECT_PATH");
55​// that's the generic app menu with Help and Options and will be used if window doesn't have a fully-blown menu bar
56​static const QByteArray s_gtkAppMenuObjectPath = QByteArrayLiteral("_GTK_APP_MENU_OBJECT_PATH");
57​
58​static const QByteArray s_kdeNetWmAppMenuServiceName = QByteArrayLiteral("_KDE_NET_WM_APPMENU_SERVICE_NAME");
59​static const QByteArray s_kdeNetWmAppMenuObjectPath = QByteArrayLiteral("_KDE_NET_WM_APPMENU_OBJECT_PATH");
60​
61​MenuProxy::MenuProxy()
62​ : QObject()
63​ , m_xConnection(QX11Info::connection())
64​ , m_serviceWatcher(new QDBusServiceWatcher(this))
65​{
66​ m_serviceWatcher->setConnection(QDBusConnection::sessionBus());
67​ m_serviceWatcher->setWatchMode(QDBusServiceWatcher::WatchForUnregistration |
68​ QDBusServiceWatcher::WatchForRegistration);
69​ m_serviceWatcher->addWatchedService(s_dbusMenuRegistrar);
70​
71​ connect(m_serviceWatcher, &QDBusServiceWatcher::serviceRegistered, this, [this](const QString &service) {
72​ Q_UNUSED(service);
73​ qCDebug(DBUSMENUPROXY) << "Global menu service became available, starting";
74​ init();
75​ });
76​ connect(m_serviceWatcher, &QDBusServiceWatcher::serviceUnregistered, this, [this](const QString &service) {
77​ Q_UNUSED(service);
78​ qCDebug(DBUSMENUPROXY) << "Global menu service disappeared, cleaning up";
79​ teardown();
80​ });
81​
82​ // It's fine to do a blocking call here as we're a separate binary with no UI
83​ if (QDBusConnection::sessionBus().interface()->isServiceRegistered(s_dbusMenuRegistrar)) {
84​ qCDebug(DBUSMENUPROXY) << "Global menu service is running, starting right away";
85​ init();
86​ } else {
87​ qCDebug(DBUSMENUPROXY) << "No global menu service available, waiting for it to start before doing anything";
88​
89​ // be sure when started to restore gtk menus when there's no dbus menu around in case we crashed
90​ setGtkShellShowsMenuBar(false);
91​ }
92​}
93​
94​MenuProxy::~MenuProxy()
95​{
96​ teardown();
97​}
98​
99​bool MenuProxy::init()
100​{
101​ if (!QDBusConnection::sessionBus().registerService(s_ourServiceName)) {
102​ qCWarning(DBUSMENUPROXY) << "Failed to register DBus service" << s_ourServiceName;
103​ return false;
104​ }
105​
106​ setGtkShellShowsMenuBar(true);
107​
108​ connect(KWindowSystem::self(), &KWindowSystem::windowAdded, this, &MenuProxy::onWindowAdded);
109​ connect(KWindowSystem::self(), &KWindowSystem::windowRemoved, this, &MenuProxy::onWindowRemoved);
110​
111​ const auto windows = KWindowSystem::windows();
112​ for (WId id : windows) {
113​ onWindowAdded(id);
114​ }
115​
116​ if (m_menus.isEmpty()) {
117​ qCDebug(DBUSMENUPROXY) << "Up and running but no menus in sight";
118​ }
119​
120​ return true;
121​}
122​
123​void MenuProxy::teardown()
124​{
125​ setGtkShellShowsMenuBar(false);
126​
127​ QDBusConnection::sessionBus().unregisterService(s_ourServiceName);
128​
129​ disconnect(KWindowSystem::self(), &KWindowSystem::windowAdded, this, &MenuProxy::onWindowAdded);
130​ disconnect(KWindowSystem::self(), &KWindowSystem::windowRemoved, this, &MenuProxy::onWindowRemoved);
131​
132​ qDeleteAll(m_menus);
133​ m_menus.clear();
134​}
135​
136​void MenuProxy::setGtkShellShowsMenuBar(bool show)
137​{
138​ qCDebug(DBUSMENUPROXY) << "Setting gtk-shell-shows-menu-bar to" << show << "which will" << (show ? "hide" : "show") << "menu bars in applications";
139​
140​ // mostly taken from kde-gtk-config
141​ QString root = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
142​ if (root.isEmpty()) {
143​ root = QFileInfo(QDir::home(), QStringLiteral(".config")).absoluteFilePath();
144​ }
145​
146​ const QString settingsFilePath = root + QStringLiteral("/gtk-3.0/settings.ini");
147​
148​ auto cfg = KSharedConfig::openConfig(settingsFilePath, KConfig::NoGlobals);
149​ KConfigGroup group(cfg, "Settings");
150​
151​ if (show) {
152​ group.writeEntry("gtk-shell-shows-menubar", true);
153​ } else {
154​ group.deleteEntry("gtk-shell-shows-menubar");
155​ }
156​
157​ group.sync();
158​
159​ // TODO use gconf/dconf directly or at least signal a change somehow?
160​}
161​
162​void MenuProxy::onWindowAdded(WId id)
163​{
164​ if (m_menus.contains(id)) {
165​ return;
166​ }
167​
168​ const QString serviceName = QString::fromUtf8(getWindowPropertyString(id, s_gtkUniqueBusName));
169​ const QString applicationObjectPath = QString::fromUtf8(getWindowPropertyString(id, s_gtkApplicationObjectPath));
170​ const QString windowObjectPath = QString::fromUtf8(getWindowPropertyString(id, s_gtkWindowObjectPath));
171​
172​ if (serviceName.isEmpty() || applicationObjectPath.isEmpty() || windowObjectPath.isEmpty()) {
173​ return;
174​ }
175​
176​ QString menuObjectPath = QString::fromUtf8(getWindowPropertyString(id, s_gtkMenuBarObjectPath));
177​ if (menuObjectPath.isEmpty()) {
178​ // try generic app menu
179​ menuObjectPath = QString::fromUtf8(getWindowPropertyString(id, s_gtkAppMenuObjectPath));
180​ }
181​
182​ if (menuObjectPath.isEmpty()) {
183​ return;
184​ }
185​
186​ Menu *menu = new Menu(id, serviceName, applicationObjectPath, windowObjectPath, menuObjectPath);
187​ m_menus.insert(id, menu);
188​
189​ connect(menu, &Menu::requestWriteWindowProperties, this, [this, menu] {
190​ Q_ASSERT(!menu->proxyObjectPath().isEmpty());
191​
192​ writeWindowProperty(menu->winId(), s_kdeNetWmAppMenuServiceName, s_ourServiceName.toUtf8());
193​ writeWindowProperty(menu->winId(), s_kdeNetWmAppMenuObjectPath, menu->proxyObjectPath().toUtf8());
194​ });
195​ connect(menu, &Menu::requestRemoveWindowProperties, this, [this, menu] {
196​ writeWindowProperty(menu->winId(), s_kdeNetWmAppMenuServiceName, QByteArray());
davidedmundsonUnsubmitted
Not Done

are these always set before the window is created?

davidedmundson: are these always set before the window is created?
broulikAuthorUnsubmitted
Not Done

I haven't seen it not working and wasn't really keen on playing with native event filters again as I did in appmenu applet

broulik: I haven't seen it not working and wasn't really keen on playing with native event filters again…
197​ writeWindowProperty(menu->winId(), s_kdeNetWmAppMenuObjectPath, QByteArray());
198​ });
199​}
200​
201​void MenuProxy::onWindowRemoved(WId id)
202​{
203​ // no need to cleanup() (which removes window properties) when the window is gone, delete right away
204​ delete m_menus.take(id);
205​}
206​
207​QByteArray MenuProxy::getWindowPropertyString(WId id, const QByteArray &name)
208​{
209​ auto *c = QX11Info::connection(); // FIXME cache
210​
211​ QByteArray value;
212​
213​ auto atom = getAtom(name);
214​ if (atom == XCB_ATOM_NONE) {
215​ return value;
216​ }
217​
218​ static const long MAX_PROP_SIZE = 10000;
219​ // FIXME figure out what "UT8String" is as atom type, it's 392 or 378 but I don't find that enum
220​ auto propertyCookie = xcb_get_property(c, false, id, atom, XCB_ATOM_ANY, 0, MAX_PROP_SIZE);
221​ QScopedPointer<xcb_get_property_reply_t, QScopedPointerPodDeleter> propertyReply(xcb_get_property_reply(c, propertyCookie, NULL));
222​ if (propertyReply.isNull()) {
223​ qCWarning(DBUSMENUPROXY) << "XCB property reply for atom" << name << "on" << id << "was null";
224​ return value;
225​ }
226​
227​ // FIXME Check type
228​ if (/*propertyReply->type == 392 && */propertyReply->format == 8 && propertyReply->value_len > 0) {
229​ const char *data = (const char *) xcb_get_property_value(propertyReply.data());
230​ int len = propertyReply->value_len;
231​ if (data) {
232​ value = QByteArray(data, data[len - 1] ? len : len - 1);
233​ }
234​ }
235​
236​ return value;
237​}
238​
239​void MenuProxy::writeWindowProperty(WId id, const QByteArray &name, const QByteArray &value)
240​{
241​ auto atom = getAtom(name);
242​ if (atom == XCB_ATOM_NONE) {
243​ return;
244​ }
245​
246​ if (value.isEmpty()) {
247​ xcb_delete_property(m_xConnection, id, atom);
248​ } else {
249​ xcb_change_property(m_xConnection, XCB_PROP_MODE_REPLACE, id, atom, XCB_ATOM_STRING,
250​ 8, value.length(), value.constData());
davidedmundsonUnsubmitted
Not Done

what's this about?

davidedmundson: what's this about?
broulikAuthorUnsubmitted
Not Done

KDE stuff shows up in xprop as

_KDE_NET_WM_APPMENU_OBJECT_PATH(STRING) = "/MenuBar/1"

note the STRING whereas GTK shows up as

_GTK_APPLICATION_OBJECT_PATH(UTF8_STRING)

note the UTF8_STRING. I did not find the corresponding type enum anywhere and it also seems to be different for different machines

broulik: KDE stuff shows up in `xprop` as ``` _KDE_NET_WM_APPMENU_OBJECT_PATH(STRING) = "/MenuBar/1" ```…
251​ }
252​}
253​
254​xcb_atom_t MenuProxy::getAtom(const QByteArray &name)
255​{
256​ static QHash<QByteArray, xcb_atom_t> s_atoms;
257​
258​ auto atom = s_atoms.value(name, XCB_ATOM_NONE);
259​ if (atom == XCB_ATOM_NONE) {
260​ const xcb_intern_atom_cookie_t atomCookie = xcb_intern_atom(m_xConnection, false, name.length(), name.constData());
261​ QScopedPointer<xcb_intern_atom_reply_t, QScopedPointerPodDeleter> atomReply(xcb_intern_atom_reply(m_xConnection, atomCookie, Q_NULLPTR));
262​ if (!atomReply.isNull()) {
263​ atom = atomReply->atom;
264​ if (atom != XCB_ATOM_NONE) {
265​ s_atoms.insert(name, atom);
266​ }
267​ }
268​ }
269​
270​ return atom;
271​}