Differential D28152 Diff 78312 kcmkwin/kwinrules/rulesmodel.cpp

Changeset View

Standalone View

View Options

kcmkwin/kwinrules/rulesmodel.cpp

  • This file was added.
1​/*
2​ * Copyright (c) 2004 Lubos Lunak <l.lunak@kde.org>
3​ * Copyright (c) 2020 Ismael Asensio <isma.af@gmail.com>
4​ *
5​ * This program is free software; you can redistribute it and/or
6​ * modify it under the terms of the GNU General Public License as
7​ * published by the Free Software Foundation; either version 2 of
8​ * the License or (at your option) version 3 or any later version
9​ * accepted by the membership of KDE e.V. (or its successor approved
10​ * by the membership of KDE e.V.), which shall act as a proxy
11​ * defined in Section 14 of version 3 of the license.
12​ *
13​ * This program is distributed in the hope that it will be useful,
14​ * but WITHOUT ANY WARRANTY; without even the implied warranty of
15​ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16​ * GNU General Public License for more details.
17​ *
18​ * You should have received a copy of the GNU General Public License
19​ * along with this program. If not, see <http://www.gnu.org/licenses/>.
20​ */
21​
22​#include "rulesmodel.h"
23​#include <rules.h>
24​
25​#include <QFileInfo>
26​#include <QIcon>
27​#include <QQmlEngine>
28​#include <QTemporaryFile>
29​#include <QtDBus>
30​
31​#include <KColorSchemeManager>
32​#include <KConfig>
33​#include <KLocalizedString>
34​#include <KWindowSystem>
35​
36​
37​namespace KWin
38​{
39​
40​RulesModel::RulesModel(QObject *parent)
41​ : QAbstractListModel(parent)
42​{
43​ qmlRegisterUncreatableType<RuleItem>("org.kde.kcms.kwinrules", 1, 0, "RuleItem",
44​ QStringLiteral("Do not create objects of type RuleItem"));
broulikUnsubmitted
Not Done

I think this should be registered in the KCM constructor, not inside of another type

broulik: I think this should be registered in the KCM constructor, not inside of another type
iasensioAuthorUnsubmitted
Not Done

It's related to the 2nd entry point (kwin_rules_dialog). Since it does not include the kcm, but just the model, this is the most outer object common to both paths.

iasensio: It's related to the 2nd entry point (`kwin_rules_dialog`). Since it does not include the kcm…
45​ qmlRegisterUncreatableType<RulesModel>("org.kde.kcms.kwinrules", 1, 0, "RulesModel",
46​ QStringLiteral("Do not create objects of type RulesModel"));
47​
48​ populateRuleList();
49​}
50​
51​RulesModel::~RulesModel()
52​{
53​}
54​
55​QHash< int, QByteArray > RulesModel::roleNames() const
56​{
57​ return {
58​ {KeyRole, QByteArrayLiteral("key")},
broulikUnsubmitted
Done

No need to delete those

broulik: No need to delete those
59​ {NameRole, QByteArrayLiteral("name")},
60​ {IconRole, QByteArrayLiteral("icon")},
61​ {IconNameRole, QByteArrayLiteral("iconName")},
62​ {SectionRole, QByteArrayLiteral("section")},
63​ {DescriptionRole, QByteArrayLiteral("description")},
64​ {EnabledRole, QByteArrayLiteral("enabled")},
65​ {SelectableRole, QByteArrayLiteral("selectable")},
66​ {ValueRole, QByteArrayLiteral("value")},
67​ {TypeRole, QByteArrayLiteral("type")},
68​ {PolicyRole, QByteArrayLiteral("policy")},
69​ {PolicyModelRole, QByteArrayLiteral("policyModel")},
70​ {OptionsModelRole, QByteArrayLiteral("options")},
71​ };
72​}
73​
74​int RulesModel::rowCount(const QModelIndex &parent) const
75​{
76​ if (parent.isValid()) {
77​ return 0;
78​ }
79​ return m_ruleList.size();
80​}
81​
82​QVariant RulesModel::data(const QModelIndex &index, int role) const
83​{
84​ if (!checkIndex(index, CheckIndexOption::IndexIsValid | CheckIndexOption::ParentIsInvalid)) {
85​ return QVariant();
86​ }
87​
88​ const RuleItem *rule = m_ruleList.at(index.row());
89​
90​ switch (role) {
91​ case KeyRole:
92​ return rule->key();
93​ case NameRole:
94​ return rule->name();
95​ case IconRole:
96​ return rule->icon();
97​ case IconNameRole:
98​ return rule->iconName();
99​ case DescriptionRole:
100​ return rule->description();
101​ case SectionRole:
102​ return rule->section();
103​ case EnabledRole:
104​ return rule->isEnabled();
105​ case SelectableRole:
106​ return !rule->hasFlag(RuleItem::AlwaysEnabled);
107​ case ValueRole:
108​ return rule->value();
109​ case TypeRole:
110​ return rule->type();
111​ case PolicyRole:
112​ return rule->policy();
113​ case PolicyModelRole:
114​ return rule->policyModel();
115​ case OptionsModelRole:
116​ return rule->options();
117​ }
118​ return QVariant();
119​}
120​
121​bool RulesModel::setData(const QModelIndex &index, const QVariant &value, int role)
122​{
123​ if (!checkIndex(index, CheckIndexOption::IndexIsValid | CheckIndexOption::ParentIsInvalid)) {
124​ return false;
125​ }
126​
127​ RuleItem *rule = m_ruleList.at(index.row());
128​
129​ switch (role) {
130​ case EnabledRole:
131​ if (value.toBool() == rule->isEnabled()) {
132​ return true;
133​ }
134​ rule->setEnabled(value.toBool());
135​ break;
136​ case ValueRole:
137​ if (value == rule->value()) {
138​ return true;
139​ }
140​ rule->setValue(value);
141​ break;
142​ case PolicyRole:
143​ if (value.toInt() == rule->policy()) {
144​ return true;
145​ }
146​ rule->setPolicy(value.toInt());
147​ break;
148​ default:
149​ return false;
150​ }
broulikUnsubmitted
Done

Check if you changed the value before emitting this for optimization

broulik: Check if you changed the value before emitting this for optimization
151​
152​ emit dataChanged(index, index, QVector<int>{role});
153​
154​ if (rule->hasFlag(RuleItem::AffectsDescription)) {
155​ emit descriptionChanged();
156​ }
157​ if (rule->hasFlag(RuleItem::AffectsWarning)) {
158​ emit showWarningChanged();
159​ }
160​
161​ return true;
162​}
163​
164​RuleItem *RulesModel::addRule(RuleItem *rule)
165​{
166​ m_ruleList << rule;
167​ m_rules.insert(rule->key(), rule);
168​
169​ return rule;
170​}
171​
172​bool RulesModel::hasRule(const QString& key) const
173​{
174​ return m_rules.contains(key);
175​}
176​
177​
178​RuleItem *RulesModel::ruleItem(const QString& key) const
broulikUnsubmitted
Done

Avoid operator[] which may detach and insert new items into the list unexpectedly. (It can't here because this method is const but generally we try to avoid it)

broulik: Avoid `operator[]` which may detach and insert new items into the list unexpectedly. (It can't…
179​{
180​ return m_rules.value(key);
181​}
182​
183​QString RulesModel::description() const
184​{
185​ const QString desc = m_rules["description"]->value().toString();
186​ if (!desc.isEmpty()) {
187​ return desc;
188​ }
189​ return defaultDescription();
190​}
191​
192​QString RulesModel::defaultDescription() const
193​{
194​ const QString wmclass = m_rules["wmclass"]->value().toString();
195​ const QString title = m_rules["title"]->isEnabled() ? m_rules["title"]->value().toString() : QString();
196​
197​ if (!title.isEmpty()) {
198​ return i18n("Window settings for %1", title);
199​ }
200​ if (!wmclass.isEmpty()) {
201​ return i18n("Settings for %1", wmclass);
202​ }
203​
204​ return i18n("New window settings");
205​}
206​
207​bool RulesModel::isWarningShown() const
208​{
209​ const bool no_wmclass = !m_rules["wmclass"]->isEnabled()
210​ || m_rules["wmclass"]->policy() == Rules::UnimportantMatch;
211​ const bool alltypes = !m_rules["types"]->isEnabled()
212​ || (m_rules["types"]->value() == 0)
213​ || (m_rules["types"]->value() == NET::AllTypesMask)
214​ || ((m_rules["types"]->value().toInt() | (1 << NET::Override)) == 0x3FF);
215​
216​ return (no_wmclass && alltypes);
ngrahamUnsubmitted
Done

Maybe "Exact Match" should be the default settting so this message isn't always shown for every new rule you add

ngraham: Maybe "Exact Match" should be the default settting so this message isn't always shown for every…
iasensioAuthorUnsubmitted
Not Done

Agree. I have set it in a simple way for new rules added.

I would like though, to set this directly on the config schema defaults, but for that to work I'll need to modify some bits of the KConfigXT helper classes, which I have planned for a later patch along some other changes to improve integration.

iasensio: Agree. I have set it in a simple way for new rules added. I would like though, to set this…
217​}
218​
219​
220​void RulesModel::readFromSettings(RuleSettings *settings)
221​{
222​ beginResetModel();
223​
224​ for (RuleItem *rule : qAsConst(m_ruleList)) {
225​ const KConfigSkeletonItem *configItem = settings->findItem(rule->key());
226​ const KConfigSkeletonItem *configPolicyItem = settings->findItem(rule->policyKey());
227​
228​ if (!configItem
229​ || (configPolicyItem && configPolicyItem->property() == Rules::Unused)
230​ || (configItem->property().toString().isEmpty())) {
231​ rule->reset();
232​ continue;
233​ }
234​
235​ rule->setEnabled(true);
236​
237​ const QVariant value = configItem->property();
238​ rule->setValue(value);
239​
240​ if (rule->policyType() != RulePolicy::NoPolicy) {
241​ const int policy = configPolicyItem->property().toInt();
242​ rule->setPolicy(policy);
243​ }
244​ }
245​
246​ endResetModel();
247​
248​ emit descriptionChanged();
249​ emit showWarningChanged();
250​}
251​
252​void RulesModel::writeToSettings(RuleSettings *settings) const
253​{
254​ const QString description = m_rules["description"]->value().toString();
255​ if (description.isEmpty()) {
256​ m_rules["description"]->setValue(defaultDescription());
257​ }
258​
259​ for (const RuleItem *rule : qAsConst(m_ruleList)) {
260​ KConfigSkeletonItem *configItem = settings->findItem(rule->key());
261​ KConfigSkeletonItem *configPolicyItem = settings->findItem(rule->policyKey());
262​
263​ Q_ASSERT (configItem);
264​
265​ if (rule->isEnabled()) {
266​ configItem->setProperty(rule->value());
267​ if (configPolicyItem) {
268​ configPolicyItem->setProperty(rule->policy());
269​ }
270​ } else {
271​ if (configPolicyItem) {
272​ configPolicyItem->setProperty(Rules::Unused);
273​ } else {
274​ // Rules without policy gets deactivated by an empty string
275​ configItem->setProperty(QString());
276​ }
277​ }
278​ }
279​}
280​
281​void RulesModel::importFromRules(Rules* rules)
282​{
283​ QTemporaryFile tempFile;
284​ if (!tempFile.open()) {
285​ return;
286​ }
287​ const auto cfg = KSharedConfig::openConfig(tempFile.fileName(), KConfig::SimpleConfig);
288​ RuleSettings *settings = new RuleSettings(cfg, QStringLiteral("tempSettings"));
289​
290​ settings->setDefaults();
291​ if (rules) {
292​ rules->write(settings);
293​ }
294​ readFromSettings(settings);
295​
296​ delete(settings);
297​}
298​
299​Rules *RulesModel::exportToRules() const
300​{
301​ QTemporaryFile tempFile;
302​ if (!tempFile.open()) {
303​ return nullptr;
304​ }
305​ const auto cfg = KSharedConfig::openConfig(tempFile.fileName(), KConfig::SimpleConfig);
306​
307​ RuleSettings *settings = new RuleSettings(cfg, QStringLiteral("tempSettings"));
308​
309​ writeToSettings(settings);
310​ Rules *rules = new Rules(settings);
311​
312​ delete(settings);
313​ return rules;
314​}
315​
316​
317​void RulesModel::populateRuleList()
broulikUnsubmitted
Done

qDeleteAll(m_ruleList) before so you don't leak those rules?

broulik: `qDeleteAll(m_ruleList)` before so you don't leak those rules?
318​{
319​ qDeleteAll(m_ruleList);
320​ m_ruleList.clear();
321​
322​ //Rule description
323​ addRule(new RuleItem(QLatin1String("description"),
324​ RulePolicy::NoPolicy, RuleItem::String,
broulikUnsubmitted
Done

Just use the return value of addRule instead of looking it up in the dict again

broulik: Just use the return value of `addRule` instead of looking it up in the dict again
325​ i18n("Description"), i18n("Window matching"),
326​ QStringLiteral("entry-edit")));
327​ m_rules["description"]->setFlags(RuleItem::AlwaysEnabled | RuleItem::AffectsDescription);
328​
329​ // Window matching
330​ addRule(new RuleItem(QLatin1String("wmclass"),
331​ RulePolicy::StringMatch, RuleItem::String,
332​ i18n("Window class (application)"), i18n("Window matching"),
333​ QStringLiteral("window")));
334​ m_rules["wmclass"]->setFlags(RuleItem::AlwaysEnabled | RuleItem::AffectsWarning | RuleItem::AffectsDescription);
335​
336​ addRule(new RuleItem(QLatin1String("wmclasscomplete"),
337​ RulePolicy::NoPolicy, RuleItem::Boolean,
338​ i18n("Match whole window class"), i18n("Window matching"),
339​ QStringLiteral("window")));
340​ m_rules["wmclasscomplete"]->setFlags(RuleItem::AlwaysEnabled);
341​
342​ addRule(new RuleItem(QLatin1String("types"),
343​ RulePolicy::NoPolicy, RuleItem::FlagsOption,
344​ i18n("Window types"), i18n("Window matching"),
345​ QStringLiteral("window-duplicate"),
346​ windowTypesModelData()));
347​ m_rules["types"]->setFlags(RuleItem::AlwaysEnabled | RuleItem::AffectsWarning );
348​
349​ addRule(new RuleItem(QLatin1String("windowrole"),
350​ RulePolicy::NoPolicy, RuleItem::String,
351​ i18n("Window role"), i18n("Window matching"),
352​ QStringLiteral("dialog-object-properties")));
353​
354​ addRule(new RuleItem(QLatin1String("title"),
355​ RulePolicy::StringMatch, RuleItem::String,
356​ i18n("Window title"), i18n("Window matching"),
357​ QStringLiteral("edit-comment")));
358​ m_rules["title"]->setFlags(RuleItem::AffectsDescription);
359​
360​ addRule(new RuleItem(QLatin1String("clientmachine"),
361​ RulePolicy::StringMatch, RuleItem::String,
362​ i18n("Machine (hostname)"), i18n("Window matching"),
363​ QStringLiteral("computer")));
364​
365​ // Size & Position
366​ addRule(new RuleItem(QLatin1String("position"),
367​ RulePolicy::SetRule, RuleItem::Coordinate,
368​ i18n("Position"), i18n("Size & Position"),
369​ QStringLiteral("transform-move")));
370​
371​ addRule(new RuleItem(QLatin1String("size"),
372​ RulePolicy::SetRule, RuleItem::Coordinate,
373​ i18n("Size"), i18n("Size & Position"),
374​ QStringLiteral("image-resize-symbolic")));
375​
376​ addRule(new RuleItem(QLatin1String("maximizehoriz"),
377​ RulePolicy::SetRule, RuleItem::Boolean,
378​ i18n("Maximized horizontally"), i18n("Size & Position"),
379​ QStringLiteral("resizecol")));
380​
381​ addRule(new RuleItem(QLatin1String("maximizevert"),
382​ RulePolicy::SetRule, RuleItem::Boolean,
383​ i18n("Maximized vertically"), i18n("Size & Position"),
384​ QStringLiteral("resizerow")));
385​
386​ addRule(new RuleItem(QLatin1String("desktop"),
387​ RulePolicy::SetRule, RuleItem::Option,
388​ i18n("Virtual Desktop"), i18n("Size & Position"),
389​ QStringLiteral("virtual-desktops"),
390​ virtualDesktopsModelData()));
391​
392​#ifdef KWIN_BUILD_ACTIVITIES
393​ m_activities = new KActivities::Consumer(this);
394​
395​ addRule(new RuleItem(QLatin1String("activity"),
396​ RulePolicy::SetRule, RuleItem::Option,
397​ i18n("Activity"), i18n("Size & Position"),
398​ QStringLiteral("activities"),
399​ activitiesModelData()));
400​
401​ // Activites consumer may update the available activities later
402​ connect(m_activities, &KActivities::Consumer::activitiesChanged,
403​ this, [this] { m_rules["activity"]->setOptionsData(activitiesModelData()); });
404​ connect(m_activities, &KActivities::Consumer::serviceStatusChanged,
405​ this, [this] { m_rules["activity"]->setOptionsData(activitiesModelData()); });
406​
407​#endif
408​
409​ addRule(new RuleItem(QLatin1String("screen"),
410​ RulePolicy::SetRule, RuleItem::Integer,
411​ i18n("Screen"), i18n("Size & Position"),
412​ QStringLiteral("osd-shutd-screen")));
413​
414​ addRule(new RuleItem(QLatin1String("fullscreen"),
415​ RulePolicy::SetRule, RuleItem::Boolean,
416​ i18n("Fullscreen"), i18n("Size & Position"),
417​ QStringLiteral("view-fullscreen")));
418​
419​ addRule(new RuleItem(QLatin1String("minimize"),
420​ RulePolicy::SetRule, RuleItem::Boolean,
421​ i18n("Minimized"), i18n("Size & Position"),
422​ QStringLiteral("window-minimize")));
423​
424​ addRule(new RuleItem(QLatin1String("shade"),
425​ RulePolicy::SetRule, RuleItem::Boolean,
426​ i18n("Shaded"), i18n("Size & Position"),
427​ QStringLiteral("window-shade")));
428​
429​ addRule(new RuleItem(QLatin1String("placement"),
430​ RulePolicy::ForceRule, RuleItem::Option,
431​ i18n("Initial placement"), i18n("Size & Position"),
432​ QStringLiteral("region"),
433​ placementModelData()));
434​
435​ addRule(new RuleItem(QLatin1String("ignoregeometry"),
436​ RulePolicy::SetRule, RuleItem::Boolean,
437​ i18n("Ignore requested geometry"), i18n("Size & Position"),
438​ QStringLiteral("view-time-schedule-baselined-remove")));
439​ m_rules["ignoregeometry"]->setDescription(i18n("Windows can ask to appear in a certain position.\n"
440​ "By default this overrides the placement strategy\n"
441​ "what might be nasty if the client abuses the feature\n"
442​ "to unconditionally popup in the middle of your screen."));
443​
444​ addRule(new RuleItem(QLatin1String("minsize"),
445​ RulePolicy::ForceRule, RuleItem::Coordinate,
446​ i18n("Minimum Size"), i18n("Size & Position"),
447​ QStringLiteral("image-resize-symbolic")));
448​
449​ addRule(new RuleItem(QLatin1String("maxsize"),
450​ RulePolicy::ForceRule, RuleItem::Coordinate,
451​ i18n("Maximum Size"), i18n("Size & Position"),
452​ QStringLiteral("image-resize-symbolic")));
453​
454​ addRule(new RuleItem(QLatin1String("strictgeometry"),
455​ RulePolicy::ForceRule, RuleItem::Boolean,
456​ i18n("Obey geometry restrictions"), i18n("Size & Position"),
457​ QStringLiteral("transform-crop-and-resize")));
458​ m_rules["strictgeometry"]->setDescription(i18n("Eg. terminals or video players can ask to keep a certain aspect ratio\n"
459​ "or only grow by values larger than one\n"
460​ "(eg. by the dimensions of one character).\n"
461​ "This may be pointless and the restriction prevents arbitrary dimensions\n"
462​ "like your complete screen area."));
463​
464​ // Arrangement & Access
465​ addRule(new RuleItem(QLatin1String("above"),
466​ RulePolicy::SetRule, RuleItem::Boolean,
467​ i18n("Keep above"), i18n("Arrangement & Access"),
468​ QStringLiteral("window-keep-above")));
469​
470​ addRule(new RuleItem(QLatin1String("below"),
471​ RulePolicy::SetRule, RuleItem::Boolean,
472​ i18n("Keep below"), i18n("Arrangement & Access"),
473​ QStringLiteral("window-keep-below")));
474​
475​ addRule(new RuleItem(QLatin1String("skiptaskbar"),
476​ RulePolicy::SetRule, RuleItem::Boolean,
477​ i18n("Skip taskbar"), i18n("Arrangement & Access"),
478​ QStringLiteral("kt-show-statusbar")));
479​ m_rules["skiptaskbar"]->setDescription(i18n("Window shall (not) appear in the taskbar."));
480​
481​ addRule(new RuleItem(QLatin1String("skippager"),
482​ RulePolicy::SetRule, RuleItem::Boolean,
483​ i18n("Skip pager"), i18n("Arrangement & Access"),
484​ QStringLiteral("org.kde.plasma.pager")));
485​ m_rules["skippager"]->setDescription(i18n("Window shall (not) appear in the manager for virtual desktops"));
486​
487​ addRule(new RuleItem(QLatin1String("skipswitcher"),
488​ RulePolicy::SetRule, RuleItem::Boolean,
489​ i18n("Skip switcher"), i18n("Arrangement & Access"),
490​ QStringLiteral("preferences-system-windows-effect-flipswitch")));
491​ m_rules["skipswitcher"]->setDescription(i18n("Window shall (not) appear in the Alt+Tab list"));
492​
493​ addRule(new RuleItem(QLatin1String("shortcut"),
494​ RulePolicy::SetRule, RuleItem::Shortcut,
495​ i18n("Shortcut"), i18n("Arrangement & Access"),
496​ QStringLiteral("configure-shortcuts")));
497​
498​ // Appearance & Fixes
499​ addRule(new RuleItem(QLatin1String("noborder"),
500​ RulePolicy::SetRule, RuleItem::Boolean,
501​ i18n("No titlebar and frame"), i18n("Appearance & Fixes"),
502​ QStringLiteral("dialog-cancel")));
503​
504​ addRule(new RuleItem(QLatin1String("decocolor"),
505​ RulePolicy::ForceRule, RuleItem::Option,
506​ i18n("Titlebar color scheme"), i18n("Appearance & Fixes"),
507​ QStringLiteral("preferences-desktop-theme"),
508​ colorSchemesModelData()));
509​
510​ addRule(new RuleItem(QLatin1String("opacityactive"),
511​ RulePolicy::ForceRule, RuleItem::Percentage,
512​ i18n("Active opacity"), i18n("Appearance & Fixes"),
513​ QStringLiteral("edit-opacity")));
514​
515​ addRule(new RuleItem(QLatin1String("opacityinactive"),
516​ RulePolicy::ForceRule, RuleItem::Percentage,
517​ i18n("Inactive opacity"), i18n("Appearance & Fixes"),
518​ QStringLiteral("edit-opacity")));
519​
520​ addRule(new RuleItem(QLatin1String("fsplevel"),
521​ RulePolicy::ForceRule, RuleItem::Option,
522​ i18n("Focus stealing prevention"), i18n("Appearance & Fixes"),
523​ QStringLiteral("preferences-system-windows-effect-glide"),
524​ focusModelData()));
525​ m_rules["fsplevel"]->setDescription(i18n("KWin tries to prevent windows from taking the focus\n"
526​ "(\"activate\") while you're working in another window,\n"
527​ "but this may sometimes fail or superact.\n"
528​ "\"None\" will unconditionally allow this window to get the focus while\n"
529​ "\"Extreme\" will completely prevent it from taking the focus."));
530​
531​ addRule(new RuleItem(QLatin1String("fpplevel"),
532​ RulePolicy::ForceRule, RuleItem::Option,
533​ i18n("Focus protection"), i18n("Appearance & Fixes"),
534​ QStringLiteral("preferences-system-windows-effect-minimize"),
535​ focusModelData()));
536​ m_rules["fpplevel"]->setDescription(i18n("This controls the focus protection of the currently active window.\n"
537​ "None will always give the focus away,\n"
538​ "Extreme will keep it.\n"
539​ "Otherwise it's interleaved with the stealing prevention\n"
540​ "assigned to the window that wants the focus."));
541​
542​ addRule(new RuleItem(QLatin1String("acceptfocus"),
543​ RulePolicy::ForceRule, RuleItem::Boolean,
544​ i18n("Accept focus"), i18n("Appearance & Fixes"),
545​ QStringLiteral("preferences-desktop-cursors")));
546​ m_rules["acceptfocus"]->setDescription(i18n("Windows may prevent to get the focus (activate) when being clicked.\n"
547​ "On the other hand you might wish to prevent a window\n"
548​ "from getting focused on a mouse click."));
549​
550​ addRule(new RuleItem(QLatin1String("disableglobalshortcuts"),
551​ RulePolicy::ForceRule, RuleItem::Boolean,
552​ i18n("Ignore global shortcuts"), i18n("Appearance & Fixes"),
553​ QStringLiteral("input-keyboard-virtual-off")));
554​ m_rules["disableglobalshortcuts"]->setDescription(i18n("When used, a window will receive\n"
555​ "all keyboard inputs while it is active, including Alt+Tab etc.\n"
556​ "This is especially interesting for emulators or virtual machines.\n"
557​ "\n"
558​ "Be warned:\n"
559​ "you won't be able to Alt+Tab out of the window\n"
560​ "nor use any other global shortcut (such as Alt+F2 to show KRunner)\n"
561​ "while it's active!"));
562​
563​ addRule(new RuleItem(QLatin1String("closeable"),
564​ RulePolicy::ForceRule, RuleItem::Boolean,
565​ i18n("Closeable"), i18n("Appearance & Fixes"),
566​ QStringLiteral("dialog-close")));
567​
568​ addRule(new RuleItem(QLatin1String("type"),
569​ RulePolicy::ForceRule, RuleItem::Option,
570​ i18n("Set window type"), i18n("Appearance & Fixes"),
571​ QStringLiteral("window-duplicate"),
572​ windowTypesModelData()));
573​
574​ addRule(new RuleItem(QLatin1String("desktopfile"),
575​ RulePolicy::SetRule, RuleItem::String,
576​ i18n("Desktop file name"), i18n("Appearance & Fixes"),
577​ QStringLiteral("application-x-desktop")));
578​
579​ addRule(new RuleItem(QLatin1String("blockcompositing"),
580​ RulePolicy::ForceRule, RuleItem::Boolean,
581​ i18n("Block compositing"), i18n("Appearance & Fixes"),
582​ QStringLiteral("composite-track-on")));
583​}
584​
585​
586​const QHash<QString, QString> RulesModel::x11PropertyHash()
587​{
588​ static const auto propertyToRule = QHash<QString, QString> {
589​ /* The original detection dialog allows to choose depending on "Match complete window class":
590​ * if Match Complete == false: wmclass = "resourceClass"
591​ * if Match Complete == true: wmclass = "resourceName" + " " + "resourceClass"
592​ */
593​ { "resourceName", "wmclass" },
594​ { "caption", "title" },
595​ { "role", "windowrole" },
596​ { "clientMachine", "clientmachine" },
597​ { "x11DesktopNumber", "desktop" },
598​ { "maximizeHorizontal", "maximizehoriz" },
599​ { "maximizeVertical", "maximizevert" },
600​ { "minimized", "minimize" },
601​ { "shaded", "shade" },
602​ { "fullscreen", "fullscreen" },
603​ { "keepAbove", "above" },
604​ { "keepBelow", "below" },
605​ { "noBorder", "noborder" },
606​ { "skipTaskbar", "skiptaskbar" },
607​ { "skipPager", "skippager" },
608​ { "skipSwitcher", "skipswitcher" },
609​ { "type", "type" },
610​ { "desktopFile", "desktopfile" }
611​ };
612​ return propertyToRule;
613​};
614​
615​void RulesModel::prefillProperties(const QVariantMap &info)
616​{
617​ beginResetModel();
618​
619​ // Properties that cannot be directly applied via x11PropertyHash
620​ const QString position = QStringLiteral("%1,%2").arg(info.value("x").toInt())
621​ .arg(info.value("y").toInt());
622​ const QString size = QStringLiteral("%1,%2").arg(info.value("width").toInt())
623​ .arg(info.value("height").toInt());
624​
625​ if (!m_rules["position"]->isEnabled()) {
626​ m_rules["position"]->setValue(position);
627​ }
628​ if (!m_rules["size"]->isEnabled()) {
629​ m_rules["size"]->setValue(size);
630​ }
631​ if (!m_rules["minsize"]->isEnabled()) {
632​ m_rules["minsize"]->setValue(size);
633​ }
634​ if (!m_rules["maxsize"]->isEnabled()) {
635​ m_rules["maxsize"]->setValue(size);
636​ }
637​
638​ NET::WindowType window_type = static_cast<NET::WindowType>(info.value("type", 0).toInt());
639​ if (!m_rules["types"]->isEnabled() || m_rules["types"]->value() == 0) {
640​ if (window_type == NET::Unknown) {
641​ window_type = NET::Normal;
642​ }
643​ m_rules["types"]->setValue(1 << window_type);
644​ }
645​
646​ const auto ruleForProperty = x11PropertyHash();
647​ for (QString &property : info.keys()) {
648​ if (!ruleForProperty.contains(property)) {
649​ continue;
650​ }
651​ const QString ruleKey = ruleForProperty.value(property, QString());
652​ Q_ASSERT(hasRule(ruleKey));
653​
654​ // Only prefill disabled or empty properties
655​ if (!m_rules[ruleKey]->isEnabled() || m_rules[ruleKey]->value().toString().isEmpty()) {
656​ m_rules[ruleKey]->setValue(info.value(property));
657​ }
658​ }
659​
660​ endResetModel();
661​
662​ emit descriptionChanged();
663​ emit showWarningChanged();
664​}
665​
666​
667​QList<OptionsModel::Data> RulesModel::windowTypesModelData() const
668​{
669​ static const auto modelData = QList<OptionsModel::Data> {
670​ //TODO: Find/create better icons
671​ { NET::Normal, i18n("Normal Window") , QIcon::fromTheme("window") },
672​ { NET::Dialog, i18n("Dialog Window") , QIcon::fromTheme("window-duplicate") },
673​ { NET::Utility, i18n("Utility Window") , QIcon::fromTheme("dialog-object-properties") },
674​ { NET::Dock, i18n("Dock (panel)") , QIcon::fromTheme("list-remove") },
675​ { NET::Toolbar, i18n("Toolbar") , QIcon::fromTheme("tools") },
676​ { NET::Menu, i18n("Torn-Off Menu") , QIcon::fromTheme("overflow-menu-left") },
677​ { NET::Splash, i18n("Splash Screen") , QIcon::fromTheme("embosstool") },
678​ { NET::Desktop, i18n("Desktop") , QIcon::fromTheme("desktop") },
679​ // { NET::Override, i18n("Unmanaged Window") }, deprecated
680​ { NET::TopMenu, i18n("Standalone Menubar"), QIcon::fromTheme("open-menu-symbolic") }
681​ };
682​ return modelData;
683​}
684​
685​QList<OptionsModel::Data> RulesModel::virtualDesktopsModelData() const
686​{
687​ QList<OptionsModel::Data> modelData;
688​ for (int desktopId = 1; desktopId <= KWindowSystem::numberOfDesktops(); ++desktopId) {
689​ modelData << OptionsModel::Data{
690​ desktopId,
691​ QString::number(desktopId).rightJustified(2) + QStringLiteral(": ") + KWindowSystem::desktopName(desktopId),
692​ QIcon::fromTheme("virtual-desktops")
693​ };
694​ }
695​ modelData << OptionsModel::Data{ NET::OnAllDesktops, i18n("All Desktops"), QIcon::fromTheme("window-pin") };
696​ return modelData;
697​}
698​
699​
700​QList<OptionsModel::Data> RulesModel::activitiesModelData() const
701​{
702​#ifdef KWIN_BUILD_ACTIVITIES
703​ QList<OptionsModel::Data> modelData;
704​
705​ // NULL_ID from kactivities/src/lib/core/consumer.cpp
706​ modelData << OptionsModel::Data{
davidedmundsonUnsubmitted
Not Done

This won't work on wayland, we will want to copy whatever we do in the virtual desktop KCM.

I think this is not regression, as the current code does the same.
At which point I'm happy to merge now and revist it later.

davidedmundson: This won't work on wayland, we will want to copy whatever we do in the virtual desktop KCM. I…
iasensioAuthorUnsubmitted
Not Done

I'll look into it. Thanks!

iasensio: I'll look into it. Thanks!
707​ QString::fromLatin1("00000000-0000-0000-0000-000000000000"),
708​ i18n("All Activities"),
709​ QIcon::fromTheme("activities")
710​ };
711​
712​ const auto activities = m_activities->activities(KActivities::Info::Running);
713​ if (m_activities->serviceStatus() == KActivities::Consumer::Running) {
714​ for (const QString &activityId : activities) {
715​ const KActivities::Info info(activityId);
716​ modelData << OptionsModel::Data{ activityId, info.name(), QIcon::fromTheme(info.icon()) };
717​ }
718​ }
719​
720​ return modelData;
721​#else
722​ return {};
723​#endif
724​}
725​
726​QList<OptionsModel::Data> RulesModel::placementModelData() const
727​{
728​ // From "placement.h" : Placement rule is stored as a string, not the enum value
729​ static const auto modelData = QList<OptionsModel::Data> {
730​ { Placement::policyToString(Placement::Default), i18n("Default") },
731​ { Placement::policyToString(Placement::NoPlacement), i18n("No Placement") },
732​ { Placement::policyToString(Placement::Smart), i18n("Minimal Overlapping") },
733​ { Placement::policyToString(Placement::Maximizing), i18n("Maximized") },
734​ { Placement::policyToString(Placement::Cascade), i18n("Cascaded") },
735​ { Placement::policyToString(Placement::Centered), i18n("Centered") },
736​ { Placement::policyToString(Placement::Random), i18n("Random") },
737​ { Placement::policyToString(Placement::ZeroCornered), i18n("In Top-Left Corner") },
738​ { Placement::policyToString(Placement::UnderMouse), i18n("Under Mouse") },
739​ { Placement::policyToString(Placement::OnMainWindow), i18n("On Main Window") }
740​ };
741​ return modelData;
742​}
743​
744​QList<OptionsModel::Data> RulesModel::focusModelData() const
745​{
746​ static const auto modelData = QList<OptionsModel::Data> {
747​ { 0, i18n("None") },
748​ { 1, i18n("Low") },
749​ { 2, i18n("Normal") },
750​ { 3, i18n("High") },
751​ { 4, i18n("Extreme") }
752​ };
753​ return modelData;
754​}
755​
756​QList<OptionsModel::Data> RulesModel::colorSchemesModelData() const
757​{
758​ QList<OptionsModel::Data> modelData;
759​
760​ KColorSchemeManager schemes;
761​ QAbstractItemModel *schemesModel = schemes.model();
762​
763​ // Skip row 0, which is Default scheme
764​ for (int r = 1; r < schemesModel->rowCount(); r++) {
765​ const QModelIndex index = schemesModel->index(r, 0);
766​ modelData << OptionsModel::Data{
767​ QFileInfo(index.data(Qt::UserRole).toString()).baseName(),
768​ index.data(Qt::DisplayRole).toString(),
769​ index.data(Qt::DecorationRole).value<QIcon>()
770​ };
771​ }
772​
773​ return modelData;
774​}
broulikUnsubmitted
Done

There's now a KSortFilterProxyModel in KItemModels you can use from QML for simple filtering like this. Just a suggestion.

broulik: There's now a `KSortFilterProxyModel` in `KItemModels` you can use from QML for simple…
iasensioAuthorUnsubmitted
Done

That seems very handy. I've been trying to, but apparently there is no way to invalidateFilter() from the QML side, to add the showAll condition.
Maybe can it be extended on KItemModels?

iasensio: That seems very handy. I've been trying to, but apparently there is no way to `invalidateFilter…
775​
776​void RulesModel::detectWindowProperties(int secs)
broulikUnsubmitted
Done

I probably would have stored the search string in a member and done the filtering fully custom here rather than relying on filterFixedString

broulik: I probably would have stored the search string in a member and done the filtering fully custom…
iasensioAuthorUnsubmitted
Done

Added fully custom search, to include name and value properties

iasensio: Added fully custom search, to include `name` and `value` properties
777​{
778​ QTimer::singleShot(secs*1000, this, &RulesModel::selectX11Window);
779​}
780​
781​void RulesModel::selectX11Window()
782​{
783​ QDBusMessage message = QDBusMessage::createMethodCall(QStringLiteral("org.kde.KWin"),
784​ QStringLiteral("/KWin"),
broulikUnsubmitted
Done

You can also do QModelIndex::data()

broulik: You can also do `QModelIndex::data()`
785​ QStringLiteral("org.kde.KWin"),
786​ QStringLiteral("queryWindowInfo"));
787​
788​ QDBusPendingReply<QVariantMap> async = QDBusConnection::sessionBus().asyncCall(message);
789​
790​ QDBusPendingCallWatcher *callWatcher = new QDBusPendingCallWatcher(async, this);
791​ connect(callWatcher, &QDBusPendingCallWatcher::finished, this,
792​ [this](QDBusPendingCallWatcher *self) {
793​ QDBusPendingReply<QVariantMap> reply = *self;
794​ self->deleteLater();
795​ if (!reply.isValid()) {
796​ return;
797​ }
798​ const QVariantMap windowInfo = reply.value();
799​ //TODO: Improve UI to suggest/select the detected properties.
800​ // For now, just prefill unused rules
801​ prefillProperties(windowInfo);
broulikUnsubmitted
Done

Generally we check if a property has actually changed before emitting a change:

if (m_showAll == showAll) {
    return;
}
...
broulik: Generally we check if a property has actually changed before emitting a change: ``` if…
802​ }
803​ );
804​}
805​
806​} //namespace