Differential D10461 Diff 28836 gmenu-dbusmenu-proxy/window.cpp

Changeset View

Standalone View

View Options

gmenu-dbusmenu-proxy/window.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 "window.h"
21​
22​#include "debug.h"
23​
24​#include <QDBusConnection>
25​#include <QDBusMessage>
26​#include <QDBusPendingCallWatcher>
27​#include <QDBusPendingReply>
28​#include <QDebug>
29​#include <QList>
30​#include <QMutableListIterator>
31​#include <QVariantList>
32​
33​#include <KLocalizedString>
34​
35​#include <algorithm>
36​
37​#include "actions.h"
38​#include "dbusmenuadaptor.h"
39​#include "icons.h"
40​#include "menu.h"
41​#include "utils.h"
42​
43​#include "../libdbusmenuqt/dbusmenushortcut_p.h"
44​
45​static const QString s_orgGtkActions = QStringLiteral("org.gtk.Actions");
46​static const QString s_orgGtkMenus = QStringLiteral("org.gtk.Menus");
47​
48​static const QString s_applicationActionsPrefix = QStringLiteral("app.");
49​static const QString s_unityActionsPrefix = QStringLiteral("unity.");
50​static const QString s_windowActionsPrefix = QStringLiteral("win.");
51​
52​Window::Window(const QString &serviceName)
53​ : QObject()
54​ , m_serviceName(serviceName)
55​{
56​ qCDebug(DBUSMENUPROXY) << "Created menu on" << serviceName;
57​
58​ Q_ASSERT(!serviceName.isEmpty());
59​
60​ GDBusMenuTypes_register();
61​ DBusMenuTypes_register();
62​}
63​
64​Window::~Window() = default;
65​
66​void Window::init()
67​{
68​ qCDebug(DBUSMENUPROXY) << "Inited window with menu for" << m_winId << "on" << m_serviceName << "at app" << m_applicationObjectPath << "win" << m_windowObjectPath << "unity" << m_unityObjectPath;
69​
70​ if (!m_applicationMenuObjectPath.isEmpty()) {
71​ m_applicationMenu = new Menu(m_serviceName, m_applicationMenuObjectPath, this);
72​ connect(m_applicationMenu, &Menu::menuAppeared, this, &Window::updateWindowProperties);
73​ connect(m_applicationMenu, &Menu::menuDisappeared, this, &Window::updateWindowProperties);
74​ connect(m_applicationMenu, &Menu::subscribed, this, &Window::onMenuSubscribed);
75​ // basically so it replies on DBus no matter what
76​ connect(m_applicationMenu, &Menu::failedToSubscribe, this, &Window::onMenuSubscribed);
77​ connect(m_applicationMenu, &Menu::itemsChanged, this, &Window::menuItemsChanged);
78​ connect(m_applicationMenu, &Menu::menusChanged, this, &Window::menuChanged);
79​ }
80​
81​ if (!m_menuBarObjectPath.isEmpty()) {
82​ m_menuBar = new Menu(m_serviceName, m_menuBarObjectPath, this);
83​ connect(m_menuBar, &Menu::menuAppeared, this, &Window::updateWindowProperties);
84​ connect(m_menuBar, &Menu::menuDisappeared, this, &Window::updateWindowProperties);
85​ connect(m_menuBar, &Menu::subscribed, this, &Window::onMenuSubscribed);
86​ connect(m_menuBar, &Menu::failedToSubscribe, this, &Window::onMenuSubscribed);
87​ connect(m_menuBar, &Menu::itemsChanged, this, &Window::menuItemsChanged);
88​ connect(m_menuBar, &Menu::menusChanged, this, &Window::menuChanged);
89​ }
90​
91​ if (!m_applicationObjectPath.isEmpty()) {
92​ m_applicationActions = new Actions(m_serviceName, m_applicationObjectPath, this);
93​ connect(m_applicationActions, &Actions::actionsChanged, this, [this](const QStringList &dirtyActions) {
davidedmundsonUnsubmitted
Not Done

who owns this?

davidedmundson: who owns this?
94​ onActionsChanged(dirtyActions, s_applicationActionsPrefix);
95​ });
96​ connect(m_applicationActions, &Actions::loaded, this, [this] {
97​ if (m_menuInited) {
98​ onActionsChanged(m_applicationActions->getAll().keys(), s_applicationActionsPrefix);
99​ } else {
100​ initMenu();
101​ }
102​ });
103​ m_applicationActions->load();
104​ }
105​
106​ if (!m_unityObjectPath.isEmpty()) {
107​ m_unityActions = new Actions(m_serviceName, m_unityObjectPath, this);
108​ connect(m_unityActions, &Actions::actionsChanged, this, [this](const QStringList &dirtyActions) {
109​ onActionsChanged(dirtyActions, s_unityActionsPrefix);
110​ });
111​ connect(m_unityActions, &Actions::loaded, this, [this] {
112​ if (m_menuInited) {
113​ onActionsChanged(m_unityActions->getAll().keys(), s_unityActionsPrefix);
114​ } else {
115​ initMenu();
116​ }
117​ });
118​ m_unityActions->load();
119​ }
120​
121​ if (!m_windowObjectPath.isEmpty()) {
122​ m_windowActions = new Actions(m_serviceName, m_windowObjectPath, this);
123​ connect(m_windowActions, &Actions::actionsChanged, this, [this](const QStringList &dirtyActions) {
124​ onActionsChanged(dirtyActions, s_windowActionsPrefix);
125​ });
126​ connect(m_windowActions, &Actions::loaded, this, [this] {
127​ if (m_menuInited) {
128​ onActionsChanged(m_windowActions->getAll().keys(), s_windowActionsPrefix);
129​ } else {
130​ initMenu();
131​ }
132​ });
133​ m_windowActions->load();
134​ }
135​}
136​
137​WId Window::winId() const
138​{
139​ return m_winId;
140​}
141​
142​void Window::setWinId(WId winId)
143​{
144​ m_winId = winId;
145​}
146​
147​QString Window::serviceName() const
148​{
149​ return m_serviceName;
150​}
151​
152​QString Window::applicationObjectPath() const
153​{
154​ return m_applicationObjectPath;
155​}
156​
157​void Window::setApplicationObjectPath(const QString &applicationObjectPath)
158​{
159​ m_applicationObjectPath = applicationObjectPath;
160​}
161​
162​QString Window::unityObjectPath() const
163​{
164​ return m_unityObjectPath;
165​}
166​
167​void Window::setUnityObjectPath(const QString &unityObjectPath)
168​{
169​ m_unityObjectPath = unityObjectPath;
170​}
171​
172​QString Window::applicationMenuObjectPath() const
173​{
174​ return m_applicationMenuObjectPath;
175​}
176​
177​void Window::setApplicationMenuObjectPath(const QString &applicationMenuObjectPath)
178​{
179​ m_applicationMenuObjectPath = applicationMenuObjectPath;
180​}
181​
182​QString Window::menuBarObjectPath() const
183​{
184​ return m_menuBarObjectPath;
185​}
186​
187​void Window::setMenuBarObjectPath(const QString &menuBarObjectPath)
188​{
189​ m_menuBarObjectPath = menuBarObjectPath;
190​}
191​
192​QString Window::windowObjectPath() const
193​{
194​ return m_windowObjectPath;
195​}
196​
197​void Window::setWindowObjectPath(const QString &windowObjectPath)
198​{
199​ m_windowObjectPath = windowObjectPath;
200​}
201​
202​QString Window::currentMenuObjectPath() const
203​{
204​ return m_currentMenuObjectPath;
205​}
206​
207​QString Window::proxyObjectPath() const
208​{
209​ return m_proxyObjectPath;
210​}
211​
212​void Window::initMenu()
213​{
214​ if (m_menuInited) {
215​ return;
216​ }
217​
218​ if (!registerDBusObject()) {
219​ return;
220​ }
221​
222​ // appmenu-gtk-module always announces a menu bar on every GTK window even if there is none
223​ // so we subscribe to the menu bar as soon as it shows up so we can figure out
224​ // if we have a menu bar, an app menu, or just nothing
225​ if (m_applicationMenu) {
226​ m_applicationMenu->start(0);
227​ }
228​
229​ if (m_menuBar) {
230​ m_menuBar->start(0);
231​ }
232​
233​ m_menuInited = true;
234​}
235​
236​void Window::menuItemsChanged(const QVector<uint> &itemIds)
237​{
238​ if (qobject_cast<Menu*>(sender()) != m_currentMenu) {
239​ return;
240​ }
241​
242​ DBusMenuItemList items;
243​
244​ for (uint id : itemIds) {
245​ const auto newItem = m_currentMenu->getItem(id);
246​
247​ DBusMenuItem dBusItem{
248​ // 0 is menu, items start at 1
249​ id,
250​ gMenuToDBusMenuProperties(newItem)
251​ };
252​ items.append(dBusItem);
253​ }
254​
255​ emit ItemsPropertiesUpdated(items, {});
256​}
257​
258​void Window::menuChanged(const QVector<uint> &menuIds)
259​{
260​ if (qobject_cast<Menu*>(sender()) != m_currentMenu) {
261​ return;
262​ }
263​
264​ for (uint menu : menuIds) {
265​ emit LayoutUpdated(3 /*revision*/, menu);
266​ }
267​}
268​
269​void Window::onMenuSubscribed(uint id)
270​{
271​ // When it was a delayed GetLayout request, send the reply now
272​ const auto pendingReplies = m_pendingGetLayouts.values(id);
273​ if (!pendingReplies.isEmpty()) {
274​ for (const auto &pendingReply : pendingReplies) {
275​ if (pendingReply.type() != QDBusMessage::InvalidMessage) {
276​ auto reply = pendingReply.createReply();
277​
278​ DBusMenuLayoutItem item;
279​ uint revision = GetLayout(Utils::treeStructureToInt(id, 0, 0), 0, {}, item);
280​
281​ reply << revision << QVariant::fromValue(item);
282​
283​ QDBusConnection::sessionBus().send(reply);
284​ }
285​ }
286​ m_pendingGetLayouts.remove(id);
287​ } else {
288​ emit LayoutUpdated(2 /*revision*/, id);
289​ }
martUnsubmitted
Not Done

always 2? maybe needs a more in depth comment?

mart: always 2? maybe needs a more in depth comment?
290​}
291​
292​bool Window::getAction(const QString &name, GMenuAction &action) const
293​{
294​ QString lookupName;
295​ Actions *actions = getActionsForAction(name, lookupName);
296​
297​ if (!actions) {
298​ return false;
299​ }
300​
301​ return actions->get(lookupName, action);
302​}
303​
304​void Window::triggerAction(const QString &name, uint timestamp)
305​{
306​ QString lookupName;
307​ Actions *actions = getActionsForAction(name, lookupName);
308​
309​ if (!actions) {
310​ return;
311​ }
312​
313​ actions->trigger(lookupName, timestamp);
314​}
315​
316​Actions *Window::getActionsForAction(const QString &name, QString &lookupName) const
317​{
318​ if (name.startsWith(QLatin1String("app."))) {
319​ lookupName = name.mid(4);
320​ return m_applicationActions;
321​ } else if (name.startsWith(QLatin1String("unity."))) {
322​ lookupName = name.mid(6);
323​ return m_unityActions;
324​ } else if (name.startsWith(QLatin1String("win."))) {
325​ lookupName = name.mid(4);
326​ return m_windowActions;
327​ }
328​
329​ return nullptr;
330​}
331​
332​void Window::onActionsChanged(const QStringList &dirty, const QString &prefix)
333​{
334​ if (m_applicationMenu) {
335​ m_applicationMenu->actionsChanged(dirty, prefix);
336​ }
337​ if (m_menuBar) {
338​ m_menuBar->actionsChanged(dirty, prefix);
339​ }
340​}
341​
342​bool Window::registerDBusObject()
343​{
344​ Q_ASSERT(m_proxyObjectPath.isEmpty());
345​
346​ static int menus = 0;
347​ ++menus;
348​
349​ new DbusmenuAdaptor(this);
350​
351​ const QString objectPath = QStringLiteral("/MenuBar/%1").arg(QString::number(menus));
352​ qCDebug(DBUSMENUPROXY) << "Registering DBus object path" << objectPath;
353​
354​ if (!QDBusConnection::sessionBus().registerObject(objectPath, this)) {
355​ qCWarning(DBUSMENUPROXY) << "Failed to register object";
356​ return false;
357​ }
358​
davidedmundsonUnsubmitted
Done

I think it's safe, you'd have definitely added it before we process someone introspecting the path.

But why write it one way round and add a question when we can just move it.

davidedmundson: I think it's safe, you'd have definitely added it before we process someone introspecting the…
359​ m_proxyObjectPath = objectPath;
360​
361​ return true;
362​}
363​
364​void Window::updateWindowProperties()
365​{
366​ const bool hasMenu = ((m_applicationMenu && m_applicationMenu->hasMenu())
367​ || (m_menuBar && m_menuBar->hasMenu()));
368​
369​ if (!hasMenu) {
370​ emit requestRemoveWindowProperties();
371​ return;
372​ }
373​
374​ Menu *oldMenu = m_currentMenu;
375​ Menu *newMenu = qobject_cast<Menu*>(sender());
376​ // set current menu as needed
377​ if (!m_currentMenu) {
378​ m_currentMenu = newMenu;
379​ // Menu Bar takes precedence over application menu
380​ } else if (m_currentMenu == m_applicationMenu && newMenu == m_menuBar) {
381​ qCDebug(DBUSMENUPROXY) << "Switching from application menu to menu bar";
382​ m_currentMenu = newMenu;
383​ // TODO update layout
384​ }
385​
386​ if (m_currentMenu != oldMenu) {
387​ // update entire menu now
388​ emit LayoutUpdated(4 /*revision*/, 0);
389​ }
390​
391​ emit requestWriteWindowProperties();
392​}
393​
394​// DBus
395​bool Window::AboutToShow(int id)
396​{
397​ // We always request the first time GetLayout is called and keep up-to-date internally
398​ // No need to have us prepare anything here
399​ Q_UNUSED(id);
400​ return false;
401​}
402​
403​void Window::Event(int id, const QString &eventId, const QDBusVariant &data, uint timestamp)
404​{
405​ Q_UNUSED(data);
406​
407​ if (!m_currentMenu) {
408​ return;
409​ }
410​
411​ // GMenu dbus doesn't have any "opened" or "closed" signals, we'll only handle "clicked"
412​
413​ if (eventId == QLatin1String("clicked")) {
414​ const QString action = m_currentMenu->getItem(id).value(QStringLiteral("action")).toString();
415​ if (!action.isEmpty()) {
416​ triggerAction(action, timestamp);
417​ }
418​ }
419​
420​}
421​
422​DBusMenuItemList Window::GetGroupProperties(const QList<int> &ids, const QStringList &propertyNames)
423​{
424​ Q_UNUSED(ids);
425​ Q_UNUSED(propertyNames);
426​ return DBusMenuItemList();
427​}
428​
429​uint Window::GetLayout(int parentId, int recursionDepth, const QStringList &propertyNames, DBusMenuLayoutItem &dbusItem)
430​{
431​ Q_UNUSED(recursionDepth); // TODO
432​ Q_UNUSED(propertyNames);
433​
434​ int subscription;
435​ int sectionId;
436​ int index;
437​
438​ Utils::intToTreeStructure(parentId, subscription, sectionId, index);
439​
440​ if (!m_currentMenu) {
441​ return 1;
442​ }
443​
444​ if (!m_currentMenu->hasSubscription(subscription)) {
445​ // let's serve multiple similar requests in one go once we've processed them
446​ m_pendingGetLayouts.insertMulti(subscription, message());
447​ setDelayedReply(true);
448​
449​ m_currentMenu->start(subscription);
450​ return 1;
451​ }
452​
453​ bool ok;
454​ const GMenuItem section = m_currentMenu->getSection(subscription, sectionId, &ok);
455​
456​ if (!ok) {
457​ qCDebug(DBUSMENUPROXY) << "There is no section on" << subscription << "at" << sectionId << "with" << parentId;
458​ return 1;
459​ }
460​
461​ // If a particular entry is requested, see what it is and resolve as neccessary
462​ // for example the "File" entry on root is 0,0,1 but is a menu reference to e.g. 1,0,0
463​ // so resolve that and return the correct menu
464​ if (index > 0) {
465​ // non-zero index indicates item within a menu but the index in the list still starts at zero
466​ if (section.items.count() < index) {
467​ qCDebug(DBUSMENUPROXY) << "Requested index" << index << "on" << subscription << "at" << sectionId << "with" << parentId << "is out of bounds";
468​ return 0;
469​ }
470​
471​ const auto &requestedItem = section.items.at(index - 1);
472​
473​ auto it = requestedItem.constFind(QStringLiteral(":submenu"));
474​ if (it != requestedItem.constEnd()) {
475​ const GMenuSection gmenuSection = qdbus_cast<GMenuSection>(it->value<QDBusArgument>());
476​ return GetLayout(Utils::treeStructureToInt(gmenuSection.subscription, gmenuSection.menu, 0), recursionDepth, propertyNames, dbusItem);
477​ } else {
478​ // TODO
479​ return 0;
480​ }
481​ }
482​
483​ dbusItem.id = parentId; // TODO
484​ dbusItem.properties = {
485​ {QStringLiteral("label"), i18n("Menu")}, // TODO use application name?
486​ {QStringLiteral("children-display"), QStringLiteral("submenu")}
487​ };
488​
489​ int count = 0;
490​
491​ const auto itemsToBeAdded = section.items;
492​ for (const auto &item : itemsToBeAdded) {
493​
494​ DBusMenuLayoutItem child{
495​ Utils::treeStructureToInt(section.id, sectionId, ++count),
496​ gMenuToDBusMenuProperties(item),
497​ {} // children
498​ };
499​ dbusItem.children.append(child);
500​
501​ // Now resolve section aliases
502​ auto it = item.constFind(QStringLiteral(":section"));
503​ if (it != item.constEnd()) {
504​
505​ // references another place, add it instead
506​ GMenuSection gmenuSection = qdbus_cast<GMenuSection>(it->value<QDBusArgument>());
507​
508​ // remember where the item came from and give it an appropriate ID
509​ // so updates signalled by the app will map to the right place
510​ int originalSubscription = gmenuSection.subscription;
511​ int originalMenu = gmenuSection.menu;
512​
513​ // TODO start subscription if we don't have it
514​ auto items = m_currentMenu->getSection(gmenuSection.subscription, gmenuSection.menu).items;
515​
516​ // Check whether it's an alias to an alias
517​ // FIXME make generic/recursive
518​ if (items.count() == 1) {
519​ const auto &aliasedItem = items.constFirst();
520​ auto findIt = aliasedItem.constFind(QStringLiteral(":section"));
521​ if (findIt != aliasedItem.constEnd()) {
522​ GMenuSection gmenuSection2 = qdbus_cast<GMenuSection>(findIt->value<QDBusArgument>());
523​ items = m_currentMenu->getSection(gmenuSection2.subscription, gmenuSection2.menu).items;
524​
525​ originalSubscription = gmenuSection2.subscription;
526​ originalMenu = gmenuSection2.menu;
527​ }
528​ }
529​
530​ int aliasedCount = 0;
531​ for (const auto &aliasedItem : qAsConst(items)) {
532​ DBusMenuLayoutItem aliasedChild{
533​ Utils::treeStructureToInt(originalSubscription, originalMenu, ++aliasedCount),
534​ gMenuToDBusMenuProperties(aliasedItem),
535​ {} // children
536​ };
537​ dbusItem.children.append(aliasedChild);
538​ }
539​ }
540​ }
541​
542​ // revision, unused in libdbusmenuqt
543​ return 1;
544​}
545​
546​QDBusVariant Window::GetProperty(int id, const QString &property)
547​{
548​ Q_UNUSED(id);
549​ Q_UNUSED(property);
550​ QDBusVariant value;
551​ return value;
552​}
553​
554​QString Window::status() const
555​{
556​ return QStringLiteral("normal");
557​}
558​
559​uint Window::version() const
560​{
561​ return 4;
562​}
563​
564​QVariantMap Window::gMenuToDBusMenuProperties(const QVariantMap &source) const
565​{
566​ QVariantMap result;
567​
568​ result.insert(QStringLiteral("label"), source.value(QStringLiteral("label")).toString());
569​
570​ if (source.contains(QStringLiteral(":section"))) {
571​ result.insert(QStringLiteral("type"), QStringLiteral("separator"));
572​ }
573​
574​ const bool isMenu = source.contains(QStringLiteral(":submenu"));
575​ if (isMenu) {
576​ result.insert(QStringLiteral("children-display"), QStringLiteral("submenu"));
577​ }
578​
579​ QString accel = source.value(QStringLiteral("accel")).toString();
580​ if (!accel.isEmpty()) {
581​ QStringList shortcut;
582​
583​ // TODO use regexp or something
584​ if (accel.contains(QLatin1String("<Primary>")) || accel.contains(QLatin1String("<Control>"))) {
585​ shortcut.append(QStringLiteral("Control"));
586​ accel.remove(QLatin1String("<Primary>"));
587​ accel.remove(QLatin1String("<Control>"));
588​ }
589​
590​ if (accel.contains(QLatin1String("<Shift>"))) {
591​ shortcut.append(QStringLiteral("Shift"));
592​ accel.remove(QLatin1String("<Shift>"));
593​ }
594​
595​ if (accel.contains(QLatin1String("<Alt>"))) {
596​ shortcut.append(QStringLiteral("Alt"));
597​ accel.remove(QLatin1String("<Alt>"));
598​ }
599​
600​ if (accel.contains(QLatin1String("<Super>"))) {
601​ shortcut.append(QStringLiteral("Super"));
602​ accel.remove(QLatin1String("<Super>"));
603​ }
604​
605​ if (!accel.isEmpty()) {
606​ // TODO replace "+" by "plus" and "-" by "minus"
607​ shortcut.append(accel);
davidedmundsonUnsubmitted
Not Done

so do so?

davidedmundson: so do so?
608​
609​ // TODO does gmenu support multiple?
610​ DBusMenuShortcut dbusShortcut;
611​ dbusShortcut.append(shortcut); // don't let it unwrap the list we append
612​
613​ result.insert(QStringLiteral("shortcut"), QVariant::fromValue(dbusShortcut));
614​ }
615​ }
616​
617​ bool enabled = true;
618​
619​ const QString actionName = Utils::itemActionName(source);
620​
621​ GMenuAction action;
622​ // if no action is specified this is fine but if there is an action we don't have
623​ // disable the menu entry
624​ bool actionOk = true;
625​ if (!actionName.isEmpty()) {
626​ actionOk = getAction(actionName, action);
627​ enabled = actionOk && action.enabled;
628​ }
629​
630​ // we used to only send this if not enabled but then dbusmenuimporter does not
631​ // update the enabled state when it changes from disabled to enabled
632​ result.insert(QStringLiteral("enabled"), enabled);
633​
634​ bool visible = true;
635​ const QString hiddenWhen = source.value(QStringLiteral("hidden-when")).toString();
636​ if (hiddenWhen == QLatin1String("action-disabled") && (!actionOk || !enabled)) {
637​ visible = false;
638​ } else if (hiddenWhen == QLatin1String("action-missing") && !actionOk) {
639​ visible = false;
640​ // While we have Global Menu we don't have macOS menu (where Quit, Help, etc is separate)
641​ } else if (hiddenWhen == QLatin1String("macos-menubar")) {
642​ visible = true;
643​ }
644​
645​ result.insert(QStringLiteral("visible"), visible);
646​
647​ QString icon = source.value(QStringLiteral("icon")).toString();
648​ if (icon.isEmpty()) {
649​ icon = source.value(QStringLiteral("verb-icon")).toString();
650​ }
651​
652​ icon = Icons::actionIcon(actionName);
653​ if (!icon.isEmpty()) {
654​ result.insert(QStringLiteral("icon-name"), icon);
655​ }
656​
657​ if (actionOk) {
658​ const auto args = action.state;
659​ if (args.count() == 1) {
660​ const auto &firstArg = args.first();
661​ // assume this is a checkbox
662​ if (!isMenu) {
663​ if (firstArg.type() == QVariant::Bool) {
664​ result.insert(QStringLiteral("toggle-type"), QStringLiteral("checkbox"));
665​ result.insert(QStringLiteral("toggle-state"), firstArg.toBool() ? 1 : 0);
666​ } else if (firstArg.type() == QVariant::String) {
667​ result.insert(QStringLiteral("toggle-type"), QStringLiteral("radio"));
668​ const QString checkedAction = firstArg.toString();
669​ if (!checkedAction.isEmpty() && actionName.endsWith(checkedAction)) {
670​ result.insert(QStringLiteral("toggle-state"), 1);
671​ } else {
672​ result.insert(QStringLiteral("toggle-state"), 0);
673​ }
674​ }
675​ }
676​ }
677​ }
678​
679​ return result;
680​}