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

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

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

checkIndex()?

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

perhaps "service" instead of "daemon"?

broulik: perhaps "service" instead of "daemon"?
405​ qCWarning(KCMKEYS) << "Ignoring unknown action" << key;
406​ }
407​ const auto shortcuts = QKeySequence::listFromString(shortcutsGroup.readEntry(key));
408​ shortcut->activeShortcuts = QSet<QKeySequence>(shortcuts.cbegin(), shortcuts.cend());
409​ }
410​ }
411​ emit dataChanged(index(0, 0), index(0, rowCount()), {ActiveShortcutsRole, CustomShortcutsRole});
412​}
413​
414​void ShortcutsModel::addApplication(const QString &desktopFileName, const QString &displayName)
415​{
416​ // Register a dummy action to trigger kglobalaccel to parse the desktop file
417​ QStringList actionId = buildActionId(desktopFileName, displayName, QString(), QString());
418​ m_globalAccelInterface->doRegister(actionId);
419​ m_globalAccelInterface->unRegister(actionId);
420​ QCollator collator;
421​ auto pos = std::lower_bound(m_components.begin(), m_components.end(), displayName, [&] (const Component &c, const QString &name) {
422​ return c.type != i18n("System Services") && collator.compare(c.friendlyName, name) < 0;
423​ });
424​ auto watcher = new QDBusPendingCallWatcher(m_globalAccelInterface->getComponent(desktopFileName));
425​ connect(watcher, &QDBusPendingCallWatcher::finished, this, [=] {
426​ QDBusPendingReply<QDBusObjectPath> reply = *watcher;
427​ watcher->deleteLater();
428​ if (!reply.isValid()) {
429​ genericErrorOccured(QStringLiteral("Error while calling objectPath of added application") + desktopFileName, reply.error());
430​ return;
431​ }
432​ KGlobalAccelComponentInterface component(m_globalAccelInterface->service(), reply.value().path(), m_globalAccelInterface->connection());
433​ auto infoWatcher = new QDBusPendingCallWatcher(component.allShortcutInfos());
434​ connect(infoWatcher, &QDBusPendingCallWatcher::finished, this, [=] {
435​ QDBusPendingReply<QList<KGlobalShortcutInfo>> infoReply = *infoWatcher;
436​ infoWatcher->deleteLater();
437​ if (!infoReply.isValid()) {
438​ genericErrorOccured(QStringLiteral("Error while calling allShortCutInfos on new component") + desktopFileName, infoReply.error());
439​ return;
440​ }
441​ qCDebug(KCMKEYS) << "inserting at " << pos - m_components.begin();
ngrahamUnsubmitted
Done

compile error

ngraham: compile error
442​ emit beginInsertRows(QModelIndex(), pos - m_components.begin(), pos - m_components.begin());
443​ Component c = loadComponent(infoReply.value());
444​ m_components.insert(pos, c);
445​ emit endInsertRows();
446​ });
447​ });
448​}
449​
450​void ShortcutsModel::removeComponent(const Component &component)
451​{
452​ const QString &uniqueName = component.uniqueName;
453​ auto watcher = new QDBusPendingCallWatcher(m_globalAccelInterface->getComponent(uniqueName));
454​ connect(watcher, &QDBusPendingCallWatcher::finished, this, [=] {
455​ QDBusPendingReply<QDBusObjectPath> reply = *watcher;
456​ watcher->deleteLater();
457​ if (!reply.isValid()) {
458​ genericErrorOccured(QStringLiteral("Error while calling objectPath of component") + uniqueName, reply.error());
459​ return;
460​ }
461​ KGlobalAccelComponentInterface component(m_globalAccelInterface->service(), reply.value().path(), m_globalAccelInterface->connection());
462​ qCDebug(KCMKEYS) << "Cleaning up component at" << reply.value();
463​ auto cleanUpWatcher = new QDBusPendingCallWatcher(component.cleanUp());
464​ connect(cleanUpWatcher, &QDBusPendingCallWatcher::finished, this, [=] {
465​ QDBusPendingReply<bool> reply = *cleanUpWatcher;
466​ cleanUpWatcher->deleteLater();
467​ if (!reply.isValid()) {
468​ genericErrorOccured(QStringLiteral("Error while calling cleanUp of component") + uniqueName, reply.error());
469​ return;
470​ }
471​ auto it = std::find_if(m_components.begin(), m_components.end(), [&](const Component &c) {
472​ return c.uniqueName == uniqueName;
473​ });
474​ const int row = it - m_components.begin();
475​ beginRemoveRows(QModelIndex(), row, row);
476​ m_components.remove(row);
477​ endRemoveRows();
478​ });
479​ });
480​}
481​
482​void ShortcutsModel::genericErrorOccured(const QString &description, const QDBusError &error)
483​{
484​ qCCritical(KCMKEYS) << description;
485​ if (error.isValid()) {
486​ qCCritical(KCMKEYS) << error.name() << error.message();
487​ }
488​ emit this->errorOccured(i18n("Error while communicating with the global shortcuts service"));
489​}