Differential D28744 Diff 80672 kcms/keys/shortcutsmodel.cpp

Changeset View

Standalone View

View Options

kcms/keys/shortcutsmodel.cpp

  • This file was added.
1​/*
2​ * Copyright (C) 2020 David Redondo <david@david-redondo.de>
3​ *
4​ * This program is free software; you can redistribute it and/or modify
5​ * it under the terms of the GNU General Public License as published by
6​ * the Free Software Foundation; either version 2 of the License, or
7​ * (at your option) any later version.
8​ *
9​ * This program 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
12​ * GNU General Public License for more details.
13​ *
14​ * You should have received a copy of the GNU General Public License along
15​ * with this program; if not, write to the Free Software Foundation, Inc.,
16​ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17​ */
18​
19​#include "shortcutsmodel.h"
20​
21​#include <algorithm>
22​
23​#include <QIcon>
24​#include <QDBusPendingCallWatcher>
25​
26​#include <KDesktopFile>
27​#include <KConfigGroup>
28​#include <KGlobalAccel>
29​#include <kglobalaccel_interface.h>
30​#include <kglobalaccel_component_interface.h>
31​#include <KGlobalShortcutInfo>
32​#include <KLocalizedString>
33​#include <KService>
34​#include <KServiceTypeTrader>
35​
36​#include "kcmkeys_debug.h"
37​
38​static QStringList buildActionId(const QString &componentUnique, const QString &componentFriendly,
39​ const QString &actionUnique, const QString &actionFriendly)
broulikUnsubmitted
Done

Hmm...
how about

QStringList actionId;
actionId.reserve(4);
broulik: Hmm... how about ``` QStringList actionId; actionId.reserve(4); ```
davidreAuthorUnsubmitted
Not Done

This actually crashes now

davidre: This actually crashes now
40​{
41​ QStringList actionId{"", "", "", ""};
42​ actionId[KGlobalAccel::ComponentUnique] = componentUnique;
43​ actionId[KGlobalAccel::ComponentFriendly] = componentFriendly;
44​ actionId[KGlobalAccel::ActionUnique] = actionUnique;
45​ actionId[KGlobalAccel::ActionFriendly] = actionFriendly;
46​ return actionId;
47​}
48​
49​
50​ShortcutsModel::ShortcutsModel(KGlobalAccelInterface *interface, QObject *parent)
51​ : QAbstractItemModel(parent)
52​ , m_globalAccelInterface{interface}
53​{
54​}
55​
56​void ShortcutsModel::load()
57​{
58​ if (!m_globalAccelInterface->isValid()) {
59​ return;
60​ }
61​ beginResetModel();
broulikUnsubmitted
Done

Do this asynchronously with QDBusPendingCallWatcher? Not sure if it really matters here

broulik: Do this asynchronously with `QDBusPendingCallWatcher`? Not sure if it really matters here
62​ m_components.clear();
63​ auto componentsWatcher = new QDBusPendingCallWatcher( m_globalAccelInterface->allComponents());
64​ connect(componentsWatcher, &QDBusPendingCallWatcher::finished, this, [this] (QDBusPendingCallWatcher *componentsWatcher) {
65​ QDBusPendingReply<QList<QDBusObjectPath>> componentsReply = *componentsWatcher;
66​ componentsWatcher->deleteLater();
67​ if (componentsReply.isError()) {
broulikUnsubmitted
Done

Coding style, space after for for (const auto &...)

broulik: Coding style, space after for `for (const auto &...)`
68​ genericErrorOccured(QStringLiteral("Error while calling allComponents()"), componentsReply.error());
69​ endResetModel();
70​ return;
71​ }
broulikUnsubmitted
Done

for comparing friendlyName use QCollator?

broulik: for comparing `friendlyName` use `QCollator`?
72​ const QList<QDBusObjectPath> componentPaths = componentsReply.value();
73​ int *pendingCalls = new int;
74​ *pendingCalls = componentPaths.size();
75​ for (const auto &componentPath : componentPaths) {
76​ const QString path = componentPath.path();
77​ KGlobalAccelComponentInterface component(m_globalAccelInterface->service(), path, m_globalAccelInterface->connection());
78​ auto watcher = new QDBusPendingCallWatcher(component.allShortcutInfos());
79​ connect(watcher, &QDBusPendingCallWatcher::finished, this, [path, pendingCalls, this] (QDBusPendingCallWatcher *watcher){
80​ QDBusPendingReply<QList<KGlobalShortcutInfo>> reply = *watcher;
81​ if (reply.isError()) {
82​ genericErrorOccured(QStringLiteral("Error while calling allShortCutInfos of") + path, reply.error());
83​ } else {
84​ m_components.push_back(loadComponent(reply.value()));
85​ }
86​ watcher->deleteLater();
87​ if (--*pendingCalls == 0) {
88​ QCollator collator;
89​ std::sort(m_components.begin(), m_components.end(), [&](const Component &c1, const Component &c2){
90​ return c1.type != c2.type ? c1.type < c2.type : collator.compare(c1.friendlyName, c2.friendlyName) < 0;
91​ });
92​ endResetModel();
93​ delete pendingCalls;
94​ }
95​ });
96​ }
97​ });
98​}
99​
100​Component ShortcutsModel::loadComponent(const QList<KGlobalShortcutInfo> &info)
101​{
102​ const QString &componentUnique = info[0].componentUniqueName();
103​ const QString &componentFriendly = info[0].componentFriendlyName();
104​ KService::Ptr service = KService::serviceByStorageId(componentUnique);
broulikUnsubmitted
Done

I kinda feel this should be done on demand or asynchronously as it causes a significant load time of the KCM

broulik: I kinda feel this should be done on demand or asynchronously as it causes a significant load…
105​ if (!service) {
106​ // Do we have an application with that name?
107​ const KService::List apps = KServiceTypeTrader::self()->query(QStringLiteral("Application"),
108​ QStringLiteral("Name == '%1' or Name == '%2'").arg(componentUnique, componentFriendly));
109​ if(!apps.isEmpty()) {
110​ service = apps[0];
111​ }
112​ }
113​ const QString type = service && service->isApplication() ? i18n("Applications") : i18n("System Services");
114​ const QString icon = service && !service->icon().isEmpty() ? service->icon() : componentUnique;
115​ Component c{componentUnique, componentFriendly, type, icon, QVector<Shortcut>(), false};
116​ for (const auto &action : info) {
117​ const QString &actionUnique = action.uniqueName();
118​ const QString &actionFriendly = action.friendlyName();
119​ Shortcut shortcut;
120​ shortcut.uniqueName = actionUnique;
121​ shortcut.friendlyName = actionFriendly;
122​ const QList<QKeySequence> defaultShortcuts = action.defaultKeys();
123​ for (const auto &keySequence : defaultShortcuts) {
124​ if (!keySequence.isEmpty()) {
125​ shortcut.defaultShortcuts.insert(keySequence);
126​ }
127​ }
128​ const QList<QKeySequence> activeShortcuts = action.keys();
129​ for (const QKeySequence &keySequence : activeShortcuts) {
130​ if (!keySequence.isEmpty()) {
131​ shortcut.activeShortcuts.insert(keySequence);
broulikUnsubmitted
Done

Use QCollator

broulik: Use `QCollator`
132​ }
133​ }
134​ shortcut.initialShortcuts = shortcut.activeShortcuts;
135​ c.shortcuts.push_back(shortcut);
136​ }
137​ QCollator collator;
138​ std::sort(c.shortcuts.begin(), c.shortcuts.end(), [&] (const Shortcut &s1, const Shortcut &s2) {
139​ return collator.compare(s1.friendlyName, s2.friendlyName) < 0;
140​ });
141​ return c;
broulikUnsubmitted
Done

const

broulik: `const`
142​}
143​
144​void ShortcutsModel::save()
145​{
146​ for (auto& component : m_components) {
147​ for (auto& shortcut : component.shortcuts) {
148​ if (shortcut.initialShortcuts != shortcut.activeShortcuts) {
149​ const QStringList actionId = buildActionId(component.uniqueName, component.friendlyName,
150​ shortcut.uniqueName, shortcut.friendlyName);
151​ //operator int of QKeySequence
152​ QList<int> keys(shortcut.activeShortcuts.cbegin(), shortcut.activeShortcuts.cend());
153​ qCDebug(KCMKEYS) << "Saving" << actionId << shortcut.activeShortcuts << keys;
154​ auto watcher = new QDBusPendingCallWatcher(m_globalAccelInterface->setForeignShortcut(actionId, keys));
155​ connect(watcher, &QDBusPendingCallWatcher::finished, this, [&, watcher] {
156​ QDBusPendingReply<> reply = *watcher;
157​ if (!reply.isValid()) {
158​ qCCritical(KCMKEYS) << "Error while saving";
159​ if (reply.error().isValid()) {
160​ qCCritical(KCMKEYS) << reply.error().name() << reply.error().message();
161​ }
162​ emit errorOccured(i18nc("%1 is the name of the component, %2 is the action for which saving failed",
163​ "Error while saving shortcut %1: %2", component.friendlyName, shortcut.friendlyName));
164​ } else {
165​ shortcut.initialShortcuts = shortcut.activeShortcuts;
166​ }
ngrahamUnsubmitted
Done

Clicking the Defaults button does not seem to have any effect for me

ngraham: Clicking the {nav Defaults} button does not seem to have any effect for me
167​ watcher->deleteLater();
168​ });
169​ }
170​ }
171​ }
172​}
173​
174​void ShortcutsModel::defaults() {
175​ for (auto component = m_components.begin(); component != m_components.end(); ++component) {
176​ auto componentIndex = index(component - m_components.begin(), 0);
177​ for (auto shortcut = component->shortcuts.begin(); shortcut != component->shortcuts.end(); ++shortcut) {
178​ shortcut->activeShortcuts = shortcut->defaultShortcuts;
179​ }
180​ emit dataChanged(index(0, 0, componentIndex), index(component->shortcuts.size(), 0, componentIndex),
181​ {ActiveShortcutsRole, CustomShortcutsRole});
182​ }
183​}
184​
185​bool ShortcutsModel::needsSave() const
186​{
187​ for (const auto& component : m_components) {
188​ for (const auto& shortcut : component.shortcuts) {
189​ if (shortcut.initialShortcuts != shortcut.activeShortcuts) {
190​ return true;
191​ }
192​ }
193​ }
194​ return false;
195​}
broulikUnsubmitted
Done

Also check if (column != 0) {
(Also, coding style)

broulik: Also check `if (column != 0) {` (Also, coding style)
196​
197​bool ShortcutsModel::isDefault() const
198​{
199​ for (const auto& component : m_components) {
200​ for (const auto& shortcut : component.shortcuts) {
201​ if (shortcut.defaultShortcuts != shortcut.activeShortcuts) {
202​ return false;
203​ }
204​ }
205​ }
206​ return true;
207​}
208​
209​QModelIndex ShortcutsModel::index(int row, int column, const QModelIndex &parent) const
210​{
211​ if (row < 0 || column != 0) {
212​ return QModelIndex();
213​ }
214​ if (parent.isValid() && row < rowCount(parent) && column == 0) {
215​ return createIndex(row, column, parent.row() + 1);
216​ } else if (column == 0 && row < m_components.size()) {
217​ return createIndex(row, column, nullptr);
218​ }
219​ return QModelIndex();
220​}
221​
222​QModelIndex ShortcutsModel::parent(const QModelIndex &child) const
223​{
224​ if (child.internalId()) {
225​ return createIndex(child.internalId() - 1, 0, nullptr);
226​ }
227​ return QModelIndex();
228​}
229​
230​int ShortcutsModel::rowCount(const QModelIndex &parent) const
231​{
232​ if (parent.isValid()) {
233​ if (parent.parent().isValid()) {
broulikUnsubmitted
Done

checkIndex()?

broulik: `checkIndex()`?
234​ return 0;
235​ }
236​ return m_components[parent.row()].shortcuts.size();
237​ }
238​ return m_components.size();
239​}
240​
241​int ShortcutsModel::columnCount(const QModelIndex &parent) const
242​{
243​ Q_UNUSED(parent);
244​ return 1;
245​}
246​
247​QVariant ShortcutsModel::data(const QModelIndex &index, int role) const
248​{
249​ if (!checkIndex(index)) {
250​ return QVariant();
251​ }
252​
broulikUnsubmitted
Done

No default case please in case we add new roles. Just return outside the switch, and below

broulik: No `default` case please in case we add new roles. Just `return` outside the `switch`, and below
253​ if (index.parent().isValid()) {
254​ const Shortcut &shortcut = m_components[index.parent().row()].shortcuts[index.row()];
255​ switch (role) {
256​ case Qt::DisplayRole:
257​ return shortcut.friendlyName.isEmpty() ? shortcut.uniqueName : shortcut.friendlyName;
258​ case ActionRole:
259​ return shortcut.uniqueName;
260​ case ActiveShortcutsRole:
261​ return QVariant::fromValue(shortcut.activeShortcuts);
broulikUnsubmitted
Done

Do we want a QIcon here? I guess just returning an iconName and using a Kirigami.Icon in the UI should suffice

broulik: Do we want a `QIcon` here? I guess just returning an `iconName` and using a `Kirigami.Icon` in…
262​ case DefaultShortcutsRole:
263​ return QVariant::fromValue(shortcut.defaultShortcuts);
264​ case CustomShortcutsRole: {
265​ auto shortcuts = shortcut.activeShortcuts;
266​ return QVariant::fromValue(shortcuts.subtract(shortcut.defaultShortcuts));
267​ }
268​ }
269​ return QVariant();
270​ }
271​ const Component &component = m_components[index.row()];
272​ switch(role) {
273​ case Qt::DisplayRole:
274​ return component.friendlyName;
275​ case Qt::DecorationRole:
broulikUnsubmitted
Not Done

Makes me wonder if CheckedRole should be the Qt::EditableRole

broulik: Makes me wonder if `CheckedRole` should be the `Qt::EditableRole`
276​ return component.icon;
277​ case SectionRole:
278​ return component.type;
279​ case ComponentRole:
280​ return component.uniqueName;
281​ case CheckedRole:
282​ return component.checked;
283​ }
284​ return QVariant();
285​}
286​
287​bool ShortcutsModel::setData(const QModelIndex &index, const QVariant &value, int role)
288​{
289​ if (!checkIndex(index) || index.parent().isValid() || role != CheckedRole) {
290​ return false;
291​ }
292​ m_components[index.row()].checked = value.toBool();
293​ emit dataChanged(index, index, {CheckedRole});
294​ return true;
295​}
296​
297​QHash<int, QByteArray> ShortcutsModel::roleNames() const
298​{
299​ return {
broulikUnsubmitted
Done

You can pass also ParentIsInvalid as flag to checkIndex

broulik: You can pass also `ParentIsInvalid` as flag to `checkIndex`
davidreAuthorUnsubmitted
Done

I think that's wrong way round here

davidre: I think that's wrong way round here
300​ {Qt::DisplayRole, QByteArrayLiteral("display")},
301​ {Qt::DecorationRole, QByteArrayLiteral("decoration")},
302​ {SectionRole, QByteArrayLiteral("section")},
303​ {ComponentRole, QByteArrayLiteral("component")},
304​ {ActiveShortcutsRole, QByteArrayLiteral("activeShortcuts")},
305​ {DefaultShortcutsRole, QByteArrayLiteral("defaultShortcuts")},
306​ {CustomShortcutsRole, QByteArrayLiteral("customShortcuts")},
307​ {CheckedRole, QByteArrayLiteral("checked")}
308​ };
309​}
310​
311​void ShortcutsModel::toggleDefaultShortcut(const QModelIndex &index, const QKeySequence &shortcut, bool enabled)
312​{
313​ if (!checkIndex(index) || !index.parent().isValid()) {
314​ return;
315​ }
316​ qCDebug(KCMKEYS) << "Default shortcut" << index << shortcut << enabled;
317​ Shortcut &s = m_components[index.parent().row()].shortcuts[index.row()];
318​ if (enabled) {
319​ s.activeShortcuts.insert(shortcut);
320​ } else {
321​ s.activeShortcuts.remove(shortcut);
322​ }
323​ emit dataChanged(index, index, {ActiveShortcutsRole, DefaultShortcutsRole});
324​}
325​
326​void ShortcutsModel::addShortcut(const QModelIndex &index, const QKeySequence &shortcut)
327​{
328​ if (!checkIndex(index) || !index.parent().isValid()) {
329​ return;
330​ }
331​ if (shortcut.isEmpty()) {
332​ return;
333​ }
334​ qCDebug(KCMKEYS) << "Adding shortcut" << index << shortcut;
335​ Shortcut &s = m_components[index.parent().row()].shortcuts[index.row()];
336​ s.activeShortcuts.insert(shortcut);
337​ emit dataChanged(index, index, {ActiveShortcutsRole, CustomShortcutsRole});
338​}
339​
340​void ShortcutsModel::disableShortcut(const QModelIndex &index, const QKeySequence &shortcut)
341​{
342​ if (!checkIndex(index) || !index.parent().isValid()) {
343​ return;
344​ }
345​ qCDebug(KCMKEYS) << "Disabling shortcut" << index << shortcut;
346​ Shortcut &s = m_components[index.parent().row()].shortcuts[index.row()];
347​ s.activeShortcuts.remove(shortcut);
348​ emit dataChanged(index, index, {ActiveShortcutsRole, CustomShortcutsRole});
349​
350​}
351​
352​void ShortcutsModel::changeShortcut(const QModelIndex &index, const QKeySequence &oldShortcut, const QKeySequence &newShortcut)
353​{
354​ if (!checkIndex(index) || !index.parent().isValid()) {
355​ return;
356​ }
357​ if (newShortcut.isEmpty()) {
358​ return;
359​ }
360​ qCDebug(KCMKEYS) << "Changing Shortcut" << index << oldShortcut << " to " << newShortcut;
361​ Shortcut &s = m_components[index.parent().row()].shortcuts[index.row()];
362​ s.activeShortcuts.remove(oldShortcut);
363​ s.activeShortcuts.insert(newShortcut);
364​ emit dataChanged(index, index, {ActiveShortcutsRole, CustomShortcutsRole});
365​}
366​
367​void ShortcutsModel::setShortcuts(const KConfigBase &config)
368​{
369​ for (const auto componentGroupName : config.groupList()) {
370​ auto component = std::find_if(m_components.begin(), m_components.end(), [&] (const Component &c) {
371​ return c.uniqueName == componentGroupName;
372​ });
373​ if (component == m_components.end()) {
374​ qCWarning(KCMKEYS) << "Ignoring unknown component" << componentGroupName;
375​ continue;
376​ }
377​ KConfigGroup componentGroup(&config, componentGroupName);
378​ if (!componentGroup.hasGroup("Global Shortcuts")) {
379​ qCWarning(KCMKEYS) << "Group" << componentGroupName << "has no shortcuts group";
380​ continue;
381​ }
382​ KConfigGroup shortcutsGroup(&componentGroup, "Global Shortcuts");
383​ for (const auto& key : shortcutsGroup.keyList()) {
384​ auto shortcut = std::find_if(component->shortcuts.begin(), component->shortcuts.end(), [&] (const Shortcut &s) {
385​ return s.uniqueName == key;
386​ });
387​ if (shortcut == component->shortcuts.end()) {
388​ qCWarning(KCMKEYS) << "Ignoring unknown action" << key;
389​ }
390​ const auto shortcuts = QKeySequence::listFromString(shortcutsGroup.readEntry(key));
391​ shortcut->activeShortcuts = QSet<QKeySequence>(shortcuts.cbegin(), shortcuts.cend());
392​ }
393​ }
394​ emit dataChanged(index(0, 0), index(0, rowCount()), {ActiveShortcutsRole, CustomShortcutsRole});
395​}
396​
397​void ShortcutsModel::addApplication(const QString &desktopFileName, const QString &displayName)
398​{
399​ // Register a dummy action to trigger kglobalaccel to parse the desktop file
400​ QStringList actionId = buildActionId(desktopFileName, displayName, QString(), QString());
401​ m_globalAccelInterface->doRegister(actionId);
402​ m_globalAccelInterface->unRegister(actionId);
403​ QCollator collator;
404​ auto pos = std::lower_bound(m_components.begin(), m_components.end(), displayName, [&] (const Component &c, const QString &name) {
broulikUnsubmitted
Done

perhaps "service" instead of "daemon"?

broulik: perhaps "service" instead of "daemon"?
405​ return c.type != i18n("System Services") && collator.compare(c.friendlyName, name) < 0;
406​ });
407​ auto watcher = new QDBusPendingCallWatcher(m_globalAccelInterface->getComponent(desktopFileName));
408​ connect(watcher, &QDBusPendingCallWatcher::finished, this, [=] {
409​ QDBusPendingReply<QDBusObjectPath> reply = *watcher;
410​ watcher->deleteLater();
411​ if (!reply.isValid()) {
412​ genericErrorOccured(QStringLiteral("Error while calling objectPath of added application") + desktopFileName, reply.error());
413​ return;
414​ }
415​ KGlobalAccelComponentInterface component(m_globalAccelInterface->service(), reply.value().path(), m_globalAccelInterface->connection());
416​ auto infoWatcher = new QDBusPendingCallWatcher(component.allShortcutInfos());
417​ connect(infoWatcher, &QDBusPendingCallWatcher::finished, this, [=] {
418​ QDBusPendingReply<QList<KGlobalShortcutInfo>> infoReply = *infoWatcher;
419​ infoWatcher->deleteLater();
420​ if (!infoReply.isValid()) {
421​ genericErrorOccured(QStringLiteral("Error while calling allShortCutInfos on new component") + desktopFileName, infoReply.error());
422​ return;
423​ }
424​ qCDebug(KCMKEYS) << "inserting at " << pos - m_components.begin();
425​ emit beginInsertRows(QModelIndex(), pos - m_components.begin(), pos - m_components.begin());
426​ Component c = loadComponent(infoReply.value());
427​ m_components.insert(pos, c);
428​ emit endInsertRows();
429​ });
430​ });
431​}
432​
433​void ShortcutsModel::removeComponent(const QModelIndex &index)
434​{
435​ if (!checkIndex(index) || index.parent().isValid()) {
436​ qCWarning(KCMKEYS) << "Cannot remove component - index doesn't refer to a valid component" << index;
437​ return;
438​ }
439​ const QString &uniqueName = m_components[index.row()].uniqueName;
440​ auto watcher = new QDBusPendingCallWatcher(m_globalAccelInterface->getComponent(uniqueName));
441​ connect(watcher, &QDBusPendingCallWatcher::finished, this, [=] {
ngrahamUnsubmitted
Done

compile error

ngraham: compile error
442​ QDBusPendingReply<QDBusObjectPath> reply = *watcher;
443​ watcher->deleteLater();
444​ if (!reply.isValid()) {
445​ genericErrorOccured(QStringLiteral("Error while calling objectPath of component") + uniqueName, reply.error());
446​ return;
447​ }
448​ KGlobalAccelComponentInterface component(m_globalAccelInterface->service(), reply.value().path(), m_globalAccelInterface->connection());
449​ qCDebug(KCMKEYS) << "Cleaning up component at" << reply.value();
450​ auto cleanUpWatcher = new QDBusPendingCallWatcher(component.cleanUp());
451​ connect(cleanUpWatcher, &QDBusPendingCallWatcher::finished, this, [=] {
452​ QDBusPendingReply<bool> reply = *cleanUpWatcher;
453​ cleanUpWatcher->deleteLater();
454​ if (!reply.isValid()) {
455​ genericErrorOccured(QStringLiteral("Error while calling cleanUp of component") + uniqueName, reply.error());
456​ return;
457​ }
458​ beginRemoveRows(QModelIndex(), index.row(), index.row());
459​ m_components.remove(index.row());
460​ endRemoveRows();
461​ });
462​ });
463​}
464​
465​void ShortcutsModel::genericErrorOccured(const QString &description, const QDBusError &error)
466​{
467​ qCCritical(KCMKEYS) << description;
468​ if (error.isValid()) {
469​ qCCritical(KCMKEYS) << error.name() << error.message();
470​ }
471​ emit this->errorOccured(i18n("Error while communicating with the global shortcuts service"));
472​}