Differential D28744 Diff 80553 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​ qDebug() << pendingCalls << *pendingCalls;
76​ for (const auto &componentPath : componentPaths) {
77​ const QString path = componentPath.path();
78​ KGlobalAccelComponentInterface component(m_globalAccelInterface->service(), path, m_globalAccelInterface->connection());
79​ auto watcher = new QDBusPendingCallWatcher(component.allShortcutInfos());
80​ connect(watcher, &QDBusPendingCallWatcher::finished, this, [path, pendingCalls, this] (QDBusPendingCallWatcher *watcher){
81​ QDBusPendingReply<QList<KGlobalShortcutInfo>> reply = *watcher;
82​ if (reply.isError()) {
83​ genericErrorOccured(QStringLiteral("Error while calling allShortCutInfos of") + path, reply.error());
84​ } else {
85​ m_components.push_back(loadComponent(reply.value()));
86​ }
87​ watcher->deleteLater();
88​ if (--*pendingCalls == 0) {
89​ QCollator collator;
90​ std::sort(m_components.begin(), m_components.end(), [&](const Component &c1, const Component &c2){
91​ return c1.type != c2.type ? c1.type < c2.type : collator.compare(c1.friendlyName, c2.friendlyName) < 0;
92​ });
93​ endResetModel();
94​ delete pendingCalls;
95​ }
96​ });
97​ }
98​ });
99​}
100​
101​Component ShortcutsModel::loadComponent(const QList<KGlobalShortcutInfo> &info)
102​{
103​ const QString &componentUnique = info[0].componentUniqueName();
104​ const QString &componentFriendly = info[0].componentFriendlyName();
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​ KService::Ptr service = KService::serviceByStorageId(componentUnique);
106​ if (!service) {
107​ // Do we have an application with that name?
108​ const KService::List apps = KServiceTypeTrader::self()->query(QStringLiteral("Application"),
109​ QStringLiteral("Name == '%1' or Name == '%2'").arg(componentUnique, componentFriendly));
110​ if(!apps.isEmpty()) {
111​ service = apps[0];
112​ }
113​ }
114​ const QString type = service && service->isApplication() ? i18n("Applications") : i18n("System Services");
115​ const QString icon = service && !service->icon().isEmpty() ? service->icon() : componentUnique;
116​ Component c{componentUnique, componentFriendly, type, icon, QVector<Shortcut>(), false};
117​ for (const auto &action : info) {
118​ const QString &actionUnique = action.uniqueName();
119​ const QString &actionFriendly = action.friendlyName();
120​ Shortcut shortcut;
121​ shortcut.uniqueName = actionUnique;
122​ shortcut.friendlyName = actionFriendly;
123​ const QList<QKeySequence> defaultShortcuts = action.defaultKeys();
124​ for (const auto &keySequence : defaultShortcuts) {
125​ if (!keySequence.isEmpty()) {
126​ shortcut.defaultShortcuts.insert(keySequence);
127​ }
128​ }
129​ const QList<QKeySequence> activeShortcuts = action.keys();
130​ for (const QKeySequence &keySequence : activeShortcuts) {
131​ if (!keySequence.isEmpty()) {
broulikUnsubmitted
Done

Use QCollator

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

const

broulik: `const`
142​ return c;
143​}
144​
145​void ShortcutsModel::save()
146​{
147​ for (auto& component : m_components) {
148​ for (auto& shortcut : component.shortcuts) {
149​ if (shortcut.initialShortcuts != shortcut.activeShortcuts) {
150​ const QStringList actionId = buildActionId(component.uniqueName, component.friendlyName,
151​ shortcut.uniqueName, shortcut.friendlyName);
152​ //operator int of QKeySequence
153​ QList<int> keys(shortcut.activeShortcuts.cbegin(), shortcut.activeShortcuts.cend());
154​ qCDebug(KCMKEYS) << "Saving" << actionId << shortcut.activeShortcuts << keys;
155​ auto watcher = new QDBusPendingCallWatcher(m_globalAccelInterface->setForeignShortcut(actionId, keys));
156​ connect(watcher, &QDBusPendingCallWatcher::finished, this, [&] {
157​ QDBusPendingReply<void> reply = *watcher;
158​ if (!reply.isValid()) {
159​ qCCritical(KCMKEYS) << "Error while saving";
160​ if (reply.error().isValid()) {
161​ qCCritical(KCMKEYS) << reply.error().name() << reply.error().message();
162​ }
163​ emit errorOccured(i18nc("%1 is the name of the component, %2 is the action for which saving failed",
164​ "Error while saving shortcut %1: %2", component.friendlyName, shortcut.friendlyName));
165​ } else {
166​ shortcut.initialShortcuts = shortcut.activeShortcuts;
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​ }
168​ watcher->deleteLater();
169​ });
170​ }
171​ }
172​ }
173​}
174​
175​void ShortcutsModel::defaults() {
176​ for (auto component = m_components.begin(); component != m_components.end(); ++component) {
177​ auto componentIndex = index(component - m_components.begin(), 0);
178​ for (auto shortcut = component->shortcuts.begin(); shortcut != component->shortcuts.end(); ++shortcut) {
179​ shortcut->activeShortcuts = shortcut->defaultShortcuts;
180​ }
181​ emit dataChanged(index(0, 0, componentIndex), index(component->shortcuts.size(), 0, componentIndex),
182​ {ActiveShortcutsRole, CustomShortcutsRole});
183​ }
184​}
185​
186​bool ShortcutsModel::needsSave() const
187​{
188​ for (const auto& component : m_components) {
189​ for (const auto& shortcut : component.shortcuts) {
190​ if (shortcut.initialShortcuts != shortcut.activeShortcuts) {
191​ return true;
192​ }
193​ }
194​ }
195​ return false;
broulikUnsubmitted
Done

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

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

checkIndex()?

broulik: `checkIndex()`?
234​ if (parent.parent().isValid()) {
235​ return 0;
236​ }
237​ return m_components[parent.row()].shortcuts.size();
238​ }
239​ return m_components.size();
240​}
241​
242​int ShortcutsModel::columnCount(const QModelIndex &parent) const
243​{
244​ Q_UNUSED(parent);
245​ return 1;
246​}
247​
248​QVariant ShortcutsModel::data(const QModelIndex &index, int role) const
249​{
250​ if (!checkIndex(index)) {
251​ return QVariant();
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​
254​ if (index.parent().isValid()) {
255​ const Shortcut &shortcut = m_components[index.parent().row()].shortcuts[index.row()];
256​ switch (role) {
257​ case Qt::DisplayRole:
258​ return shortcut.friendlyName.isEmpty() ? shortcut.uniqueName : shortcut.friendlyName;
259​ case ActionRole:
260​ return shortcut.uniqueName;
261​ case ActiveShortcutsRole:
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​ return QVariant::fromValue(shortcut.activeShortcuts);
263​ case DefaultShortcutsRole:
264​ return QVariant::fromValue(shortcut.defaultShortcuts);
265​ case CustomShortcutsRole: {
266​ auto shortcuts = shortcut.activeShortcuts;
267​ return QVariant::fromValue(shortcuts.subtract(shortcut.defaultShortcuts));
268​ }
269​ }
270​ return QVariant();
271​ }
272​ const Component &component = m_components[index.row()];
273​ switch(role) {
274​ case Qt::DisplayRole:
275​ return component.friendlyName;
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​ case Qt::DecorationRole:
277​ return component.icon;
278​ case SectionRole:
279​ return component.type;
280​ case ComponentRole:
281​ return component.uniqueName;
282​ case CheckedRole:
283​ return component.checked;
284​ }
285​ return QVariant();
286​}
287​
288​bool ShortcutsModel::setData(const QModelIndex &index, const QVariant &value, int role)
289​{
290​ if (!checkIndex(index) || index.parent().isValid() || role != CheckedRole) {
291​ return false;
292​ }
293​ m_components[index.row()].checked = value.toBool();
294​ emit dataChanged(index, index, {CheckedRole});
295​ return true;
296​}
297​
298​QHash<int, QByteArray> ShortcutsModel::roleNames() const
299​{
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​ return {
301​ {Qt::DisplayRole, QByteArrayLiteral("display")},
302​ {Qt::DecorationRole, QByteArrayLiteral("decoration")},
303​ {SectionRole, QByteArrayLiteral("section")},
304​ {ComponentRole, QByteArrayLiteral("component")},
305​ {ActiveShortcutsRole, QByteArrayLiteral("activeShortcuts")},
306​ {DefaultShortcutsRole, QByteArrayLiteral("defaultShortcuts")},
307​ {CustomShortcutsRole, QByteArrayLiteral("customShortcuts")},
308​ {CheckedRole, QByteArrayLiteral("checked")}
309​ };
310​}
311​
312​void ShortcutsModel::toggleDefaultShortcut(const QModelIndex &index, const QKeySequence &shortcut, bool enabled)
313​{
314​ if (!checkIndex(index) || !index.parent().isValid()) {
315​ return;
316​ }
317​ qCDebug(KCMKEYS) << "Default shortcut" << index << shortcut << enabled;
318​ Shortcut &s = m_components[index.parent().row()].shortcuts[index.row()];
319​ if (enabled) {
320​ s.activeShortcuts.insert(shortcut);
321​ } else {
322​ s.activeShortcuts.remove(shortcut);
323​ }
324​ emit dataChanged(index, index, {ActiveShortcutsRole, DefaultShortcutsRole});
325​}
326​
327​void ShortcutsModel::addShortcut(const QModelIndex &index, const QKeySequence &shortcut)
328​{
329​ if (!checkIndex(index) || !index.parent().isValid()) {
330​ return;
331​ }
332​ if (shortcut.isEmpty()) {
333​ return;
334​ }
335​ qCDebug(KCMKEYS) << "Adding shortcut" << index << shortcut;
336​ Shortcut &s = m_components[index.parent().row()].shortcuts[index.row()];
337​ s.activeShortcuts.insert(shortcut);
338​ emit dataChanged(index, index, {ActiveShortcutsRole, CustomShortcutsRole});
339​}
340​
341​void ShortcutsModel::disableShortcut(const QModelIndex &index, const QKeySequence &shortcut)
342​{
343​ if (!checkIndex(index) || !index.parent().isValid()) {
344​ return;
345​ }
346​ qCDebug(KCMKEYS) << "Disabling shortcut" << index << shortcut;
347​ Shortcut &s = m_components[index.parent().row()].shortcuts[index.row()];
348​ s.activeShortcuts.remove(shortcut);
349​ emit dataChanged(index, index, {ActiveShortcutsRole, CustomShortcutsRole});
350​
351​}
352​
353​void ShortcutsModel::changeShortcut(const QModelIndex &index, const QKeySequence &oldShortcut, const QKeySequence &newShortcut)
354​{
355​ if (!checkIndex(index) || !index.parent().isValid()) {
356​ return;
357​ }
358​ if (newShortcut.isEmpty()) {
359​ return;
360​ }
361​ qCDebug(KCMKEYS) << "Changing Shortcut" << index << oldShortcut << " to " << newShortcut;
362​ Shortcut &s = m_components[index.parent().row()].shortcuts[index.row()];
363​ s.activeShortcuts.remove(oldShortcut);
364​ s.activeShortcuts.insert(newShortcut);
365​ emit dataChanged(index, index, {ActiveShortcutsRole, CustomShortcutsRole});
366​}
367​
368​void ShortcutsModel::setShortcuts(const KConfigBase &config)
369​{
370​ for (const auto componentGroupName : config.groupList()) {
371​ auto component = std::find_if(m_components.begin(), m_components.end(), [&] (const Component &c) {
372​ return c.uniqueName == componentGroupName;
373​ });
374​ if (component == m_components.end()) {
375​ qCWarning(KCMKEYS) << "Ignoring unknown component" << componentGroupName;
376​ continue;
377​ }
378​ KConfigGroup componentGroup(&config, componentGroupName);
379​ if (!componentGroup.hasGroup("Global Shortcuts")) {
380​ qCWarning(KCMKEYS) << "Group" << componentGroupName << "has no shortcuts group";
381​ continue;
382​ }
383​ KConfigGroup shortcutsGroup(&componentGroup, "Global Shortcuts");
384​ for (const auto& key : shortcutsGroup.keyList()) {
385​ auto shortcut = std::find_if(component->shortcuts.begin(), component->shortcuts.end(), [&] (const Shortcut &s) {
386​ return s.uniqueName == key;
387​ });
388​ if (shortcut == component->shortcuts.end()) {
389​ qCWarning(KCMKEYS) << "Ignoring unknown action" << key;
390​ }
391​ const auto shortcuts = QKeySequence::listFromString(shortcutsGroup.readEntry(key));
392​ shortcut->activeShortcuts = QSet<QKeySequence>(shortcuts.cbegin(), shortcuts.cend());
393​ }
394​ }
395​ emit dataChanged(index(0, 0), index(0, rowCount()), {ActiveShortcutsRole, CustomShortcutsRole});
396​}
397​
398​void ShortcutsModel::addApplication(const QString &desktopFileName, const QString &displayName)
399​{
400​ // Register a dummy action to trigger kglobalaccel to parse the desktop file
401​ QStringList actionId = buildActionId(desktopFileName, displayName, QString(), QString());
402​ m_globalAccelInterface->doRegister(actionId);
403​ m_globalAccelInterface->unRegister(actionId);
404​ QCollator collator;
broulikUnsubmitted
Done

perhaps "service" instead of "daemon"?

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

compile error

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