Differential D28152 Diff 78592 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 warningMessageChanged();
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​QString RulesModel::warningMessage() const
208​{
209​ if (wmclassWarning()) {
210​ return i18n("You have specified the window class as unimportant.\n"
211​ "This means the settings will possibly apply to windows from all applications."
212​ " If you really want to create a generic setting, it is recommended"
213​ " you at least limit the window types to avoid special window types.");
214​ }
215​
216​ return QString();
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​bool RulesModel::wmclassWarning() const
221​{
222​ const bool no_wmclass = !m_rules["wmclass"]->isEnabled()
223​ || m_rules["wmclass"]->policy() == Rules::UnimportantMatch;
224​ const bool alltypes = !m_rules["types"]->isEnabled()
225​ || (m_rules["types"]->value() == 0)
226​ || (m_rules["types"]->value() == NET::AllTypesMask)
227​ || ((m_rules["types"]->value().toInt() | (1 << NET::Override)) == 0x3FF);
228​
229​ return (no_wmclass && alltypes);
230​}
231​
232​
233​void RulesModel::readFromSettings(RuleSettings *settings)
234​{
235​ beginResetModel();
236​
237​ for (RuleItem *rule : qAsConst(m_ruleList)) {
238​ const KConfigSkeletonItem *configItem = settings->findItem(rule->key());
239​ const KConfigSkeletonItem *configPolicyItem = settings->findItem(rule->policyKey());
240​
241​ if (!configItem
242​ || (configPolicyItem && configPolicyItem->property() == Rules::Unused)
243​ || (configItem->property().toString().isEmpty())) {
244​ rule->reset();
245​ continue;
246​ }
247​
248​ rule->setEnabled(true);
249​
250​ const QVariant value = configItem->property();
251​ rule->setValue(value);
252​
253​ if (rule->policyType() != RulePolicy::NoPolicy) {
254​ const int policy = configPolicyItem->property().toInt();
255​ rule->setPolicy(policy);
256​ }
257​ }
258​
259​ endResetModel();
260​
261​ emit descriptionChanged();
262​ emit warningMessageChanged();
263​}
264​
265​void RulesModel::writeToSettings(RuleSettings *settings) const
266​{
267​ const QString description = m_rules["description"]->value().toString();
268​ if (description.isEmpty()) {
269​ m_rules["description"]->setValue(defaultDescription());
270​ }
271​
272​ for (const RuleItem *rule : qAsConst(m_ruleList)) {
273​ KConfigSkeletonItem *configItem = settings->findItem(rule->key());
274​ KConfigSkeletonItem *configPolicyItem = settings->findItem(rule->policyKey());
275​
276​ Q_ASSERT (configItem);
277​
278​ if (rule->isEnabled()) {
279​ configItem->setProperty(rule->value());
280​ if (configPolicyItem) {
281​ configPolicyItem->setProperty(rule->policy());
282​ }
283​ } else {
284​ if (configPolicyItem) {
285​ configPolicyItem->setProperty(Rules::Unused);
286​ } else {
287​ // Rules without policy gets deactivated by an empty string
288​ configItem->setProperty(QString());
289​ }
290​ }
291​ }
292​}
293​
294​void RulesModel::importFromRules(Rules* rules)
295​{
296​ QTemporaryFile tempFile;
297​ if (!tempFile.open()) {
298​ return;
299​ }
300​ const auto cfg = KSharedConfig::openConfig(tempFile.fileName(), KConfig::SimpleConfig);
301​ RuleSettings *settings = new RuleSettings(cfg, QStringLiteral("tempSettings"));
302​
303​ settings->setDefaults();
304​ if (rules) {
305​ rules->write(settings);
306​ }
307​ readFromSettings(settings);
308​
309​ delete(settings);
310​}
311​
312​Rules *RulesModel::exportToRules() const
313​{
314​ QTemporaryFile tempFile;
315​ if (!tempFile.open()) {
316​ return nullptr;
317​ }
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​ const auto cfg = KSharedConfig::openConfig(tempFile.fileName(), KConfig::SimpleConfig);
319​
320​ RuleSettings *settings = new RuleSettings(cfg, QStringLiteral("tempSettings"));
321​
322​ writeToSettings(settings);
323​ Rules *rules = new Rules(settings);
324​
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​ delete(settings);
326​ return rules;
327​}
328​
329​
330​void RulesModel::populateRuleList()
331​{
332​ qDeleteAll(m_ruleList);
333​ m_ruleList.clear();
334​
335​ //Rule description
336​ auto description = addRule(new RuleItem(QLatin1String("description"),
337​ RulePolicy::NoPolicy, RuleItem::String,
338​ i18n("Description"), i18n("Window matching"),
339​ QIcon::fromTheme("entry-edit")));
340​ description->setFlag(RuleItem::AlwaysEnabled);
341​ description->setFlag(RuleItem::AffectsDescription);
342​
343​ // Window matching
344​ auto wmclass = addRule(new RuleItem(QLatin1String("wmclass"),
345​ RulePolicy::StringMatch, RuleItem::String,
346​ i18n("Window class (application)"), i18n("Window matching"),
347​ QIcon::fromTheme("window")));
348​ wmclass->setFlag(RuleItem::AlwaysEnabled);
349​ wmclass->setFlag(RuleItem::AffectsDescription);
350​ wmclass->setFlag(RuleItem::AffectsWarning);
351​
352​ auto wmclasscomplete = addRule(new RuleItem(QLatin1String("wmclasscomplete"),
353​ RulePolicy::NoPolicy, RuleItem::Boolean,
354​ i18n("Match whole window class"), i18n("Window matching"),
355​ QIcon::fromTheme("window")));
356​ wmclasscomplete->setFlag(RuleItem::AlwaysEnabled);
357​
358​ auto types = addRule(new RuleItem(QLatin1String("types"),
359​ RulePolicy::NoPolicy, RuleItem::FlagsOption,
360​ i18n("Window types"), i18n("Window matching"),
361​ QIcon::fromTheme("window-duplicate")));
362​ types->setOptionsData(windowTypesModelData());
363​ types->setFlag(RuleItem::AlwaysEnabled);
364​ types->setFlag(RuleItem::AffectsWarning);
365​
366​ addRule(new RuleItem(QLatin1String("windowrole"),
367​ RulePolicy::NoPolicy, RuleItem::String,
368​ i18n("Window role"), i18n("Window matching"),
369​ QIcon::fromTheme("dialog-object-properties")));
370​
371​ auto title = addRule(new RuleItem(QLatin1String("title"),
372​ RulePolicy::StringMatch, RuleItem::String,
373​ i18n("Window title"), i18n("Window matching"),
374​ QIcon::fromTheme("edit-comment")));
375​ title->setFlag(RuleItem::AffectsDescription);
376​
377​ addRule(new RuleItem(QLatin1String("clientmachine"),
378​ RulePolicy::StringMatch, RuleItem::String,
379​ i18n("Machine (hostname)"), i18n("Window matching"),
380​ QIcon::fromTheme("computer")));
381​
382​ // Size & Position
383​ addRule(new RuleItem(QLatin1String("position"),
384​ RulePolicy::SetRule, RuleItem::Coordinate,
385​ i18n("Position"), i18n("Size & Position"),
386​ QIcon::fromTheme("transform-move")));
387​
388​ addRule(new RuleItem(QLatin1String("size"),
389​ RulePolicy::SetRule, RuleItem::Coordinate,
390​ i18n("Size"), i18n("Size & Position"),
391​ QIcon::fromTheme("image-resize-symbolic")));
392​
393​ addRule(new RuleItem(QLatin1String("maximizehoriz"),
394​ RulePolicy::SetRule, RuleItem::Boolean,
395​ i18n("Maximized horizontally"), i18n("Size & Position"),
396​ QIcon::fromTheme("resizecol")));
397​
398​ addRule(new RuleItem(QLatin1String("maximizevert"),
399​ RulePolicy::SetRule, RuleItem::Boolean,
400​ i18n("Maximized vertically"), i18n("Size & Position"),
401​ QIcon::fromTheme("resizerow")));
402​
403​ auto desktop = addRule(new RuleItem(QLatin1String("desktop"),
404​ RulePolicy::SetRule, RuleItem::Option,
405​ i18n("Virtual Desktop"), i18n("Size & Position"),
406​ QIcon::fromTheme("virtual-desktops")));
407​ desktop->setOptionsData(virtualDesktopsModelData());
408​
409​#ifdef KWIN_BUILD_ACTIVITIES
410​ m_activities = new KActivities::Consumer(this);
411​
412​ auto activity = addRule(new RuleItem(QLatin1String("activity"),
413​ RulePolicy::SetRule, RuleItem::Option,
414​ i18n("Activity"), i18n("Size & Position"),
415​ QIcon::fromTheme("activities")));
416​ activity->setOptionsData(activitiesModelData());
417​
418​ // Activites consumer may update the available activities later
419​ connect(m_activities, &KActivities::Consumer::activitiesChanged,
420​ this, [this] { m_rules["activity"]->setOptionsData(activitiesModelData()); });
421​ connect(m_activities, &KActivities::Consumer::serviceStatusChanged,
422​ this, [this] { m_rules["activity"]->setOptionsData(activitiesModelData()); });
423​
424​#endif
425​
426​ addRule(new RuleItem(QLatin1String("screen"),
427​ RulePolicy::SetRule, RuleItem::Integer,
428​ i18n("Screen"), i18n("Size & Position"),
429​ QIcon::fromTheme("osd-shutd-screen")));
430​
431​ addRule(new RuleItem(QLatin1String("fullscreen"),
432​ RulePolicy::SetRule, RuleItem::Boolean,
433​ i18n("Fullscreen"), i18n("Size & Position"),
434​ QIcon::fromTheme("view-fullscreen")));
435​
436​ addRule(new RuleItem(QLatin1String("minimize"),
437​ RulePolicy::SetRule, RuleItem::Boolean,
438​ i18n("Minimized"), i18n("Size & Position"),
439​ QIcon::fromTheme("window-minimize")));
440​
441​ addRule(new RuleItem(QLatin1String("shade"),
442​ RulePolicy::SetRule, RuleItem::Boolean,
443​ i18n("Shaded"), i18n("Size & Position"),
444​ QIcon::fromTheme("window-shade")));
445​
446​ auto placement = addRule(new RuleItem(QLatin1String("placement"),
447​ RulePolicy::ForceRule, RuleItem::Option,
448​ i18n("Initial placement"), i18n("Size & Position"),
449​ QIcon::fromTheme("region")));
450​ placement->setOptionsData(placementModelData());
451​
452​ addRule(new RuleItem(QLatin1String("ignoregeometry"),
453​ RulePolicy::SetRule, RuleItem::Boolean,
454​ i18n("Ignore requested geometry"), i18n("Size & Position"),
455​ QIcon::fromTheme("view-time-schedule-baselined-remove"),
456​ i18n("Windows can ask to appear in a certain position.\n"
457​ "By default this overrides the placement strategy\n"
458​ "what might be nasty if the client abuses the feature\n"
459​ "to unconditionally popup in the middle of your screen.")));
460​
461​ addRule(new RuleItem(QLatin1String("minsize"),
462​ RulePolicy::ForceRule, RuleItem::Coordinate,
463​ i18n("Minimum Size"), i18n("Size & Position"),
464​ QIcon::fromTheme("image-resize-symbolic")));
465​
466​ addRule(new RuleItem(QLatin1String("maxsize"),
467​ RulePolicy::ForceRule, RuleItem::Coordinate,
468​ i18n("Maximum Size"), i18n("Size & Position"),
469​ QIcon::fromTheme("image-resize-symbolic")));
470​
471​ addRule(new RuleItem(QLatin1String("strictgeometry"),
472​ RulePolicy::ForceRule, RuleItem::Boolean,
473​ i18n("Obey geometry restrictions"), i18n("Size & Position"),
474​ QIcon::fromTheme("transform-crop-and-resize"),
475​ i18n("Eg. terminals or video players can ask to keep a certain aspect ratio\n"
476​ "or only grow by values larger than one\n"
477​ "(eg. by the dimensions of one character).\n"
478​ "This may be pointless and the restriction prevents arbitrary dimensions\n"
479​ "like your complete screen area.")));
480​
481​ // Arrangement & Access
482​ addRule(new RuleItem(QLatin1String("above"),
483​ RulePolicy::SetRule, RuleItem::Boolean,
484​ i18n("Keep above"), i18n("Arrangement & Access"),
485​ QIcon::fromTheme("window-keep-above")));
486​
487​ addRule(new RuleItem(QLatin1String("below"),
488​ RulePolicy::SetRule, RuleItem::Boolean,
489​ i18n("Keep below"), i18n("Arrangement & Access"),
490​ QIcon::fromTheme("window-keep-below")));
491​
492​ addRule(new RuleItem(QLatin1String("skiptaskbar"),
493​ RulePolicy::SetRule, RuleItem::Boolean,
494​ i18n("Skip taskbar"), i18n("Arrangement & Access"),
495​ QIcon::fromTheme("kt-show-statusbar"),
496​ i18n("Window shall (not) appear in the taskbar.")));
497​
498​ addRule(new RuleItem(QLatin1String("skippager"),
499​ RulePolicy::SetRule, RuleItem::Boolean,
500​ i18n("Skip pager"), i18n("Arrangement & Access"),
501​ QIcon::fromTheme("org.kde.plasma.pager"),
502​ i18n("Window shall (not) appear in the manager for virtual desktops")));
503​
504​ addRule(new RuleItem(QLatin1String("skipswitcher"),
505​ RulePolicy::SetRule, RuleItem::Boolean,
506​ i18n("Skip switcher"), i18n("Arrangement & Access"),
507​ QIcon::fromTheme("preferences-system-windows-effect-flipswitch"),
508​ i18n("Window shall (not) appear in the Alt+Tab list")));
509​
510​ addRule(new RuleItem(QLatin1String("shortcut"),
511​ RulePolicy::SetRule, RuleItem::Shortcut,
512​ i18n("Shortcut"), i18n("Arrangement & Access"),
513​ QIcon::fromTheme("configure-shortcuts")));
514​
515​ // Appearance & Fixes
516​ addRule(new RuleItem(QLatin1String("noborder"),
517​ RulePolicy::SetRule, RuleItem::Boolean,
518​ i18n("No titlebar and frame"), i18n("Appearance & Fixes"),
519​ QIcon::fromTheme("dialog-cancel")));
520​
521​ auto decocolor = addRule(new RuleItem(QLatin1String("decocolor"),
522​ RulePolicy::ForceRule, RuleItem::Option,
523​ i18n("Titlebar color scheme"), i18n("Appearance & Fixes"),
524​ QIcon::fromTheme("preferences-desktop-theme")));
525​ decocolor->setOptionsData(colorSchemesModelData());
526​
527​ addRule(new RuleItem(QLatin1String("opacityactive"),
528​ RulePolicy::ForceRule, RuleItem::Percentage,
529​ i18n("Active opacity"), i18n("Appearance & Fixes"),
530​ QIcon::fromTheme("edit-opacity")));
531​
532​ addRule(new RuleItem(QLatin1String("opacityinactive"),
533​ RulePolicy::ForceRule, RuleItem::Percentage,
534​ i18n("Inactive opacity"), i18n("Appearance & Fixes"),
535​ QIcon::fromTheme("edit-opacity")));
536​
537​ auto fsplevel = addRule(new RuleItem(QLatin1String("fsplevel"),
538​ RulePolicy::ForceRule, RuleItem::Option,
539​ i18n("Focus stealing prevention"), i18n("Appearance & Fixes"),
540​ QIcon::fromTheme("preferences-system-windows-effect-glide"),
541​ i18n("KWin tries to prevent windows from taking the focus\n"
542​ "(\"activate\") while you're working in another window,\n"
543​ "but this may sometimes fail or superact.\n"
544​ "\"None\" will unconditionally allow this window to get the focus while\n"
545​ "\"Extreme\" will completely prevent it from taking the focus.")));
546​ fsplevel->setOptionsData(focusModelData());
547​
548​ auto fpplevel = addRule(new RuleItem(QLatin1String("fpplevel"),
549​ RulePolicy::ForceRule, RuleItem::Option,
550​ i18n("Focus protection"), i18n("Appearance & Fixes"),
551​ QIcon::fromTheme("preferences-system-windows-effect-minimize"),
552​ i18n("This controls the focus protection of the currently active window.\n"
553​ "None will always give the focus away,\n"
554​ "Extreme will keep it.\n"
555​ "Otherwise it's interleaved with the stealing prevention\n"
556​ "assigned to the window that wants the focus.")));
557​ fpplevel->setOptionsData(focusModelData());
558​
559​ addRule(new RuleItem(QLatin1String("acceptfocus"),
560​ RulePolicy::ForceRule, RuleItem::Boolean,
561​ i18n("Accept focus"), i18n("Appearance & Fixes"),
562​ QIcon::fromTheme("preferences-desktop-cursors"),
563​ i18n("Windows may prevent to get the focus (activate) when being clicked.\n"
564​ "On the other hand you might wish to prevent a window\n"
565​ "from getting focused on a mouse click.")));
566​
567​ addRule(new RuleItem(QLatin1String("disableglobalshortcuts"),
568​ RulePolicy::ForceRule, RuleItem::Boolean,
569​ i18n("Ignore global shortcuts"), i18n("Appearance & Fixes"),
570​ QIcon::fromTheme("input-keyboard-virtual-off"),
571​ i18n("When used, a window will receive\n"
572​ "all keyboard inputs while it is active, including Alt+Tab etc.\n"
573​ "This is especially interesting for emulators or virtual machines.\n"
574​ "\n"
575​ "Be warned:\n"
576​ "you won't be able to Alt+Tab out of the window\n"
577​ "nor use any other global shortcut (such as Alt+F2 to show KRunner)\n"
578​ "while it's active!")));
579​
580​ addRule(new RuleItem(QLatin1String("closeable"),
581​ RulePolicy::ForceRule, RuleItem::Boolean,
582​ i18n("Closeable"), i18n("Appearance & Fixes"),
583​ QIcon::fromTheme("dialog-close")));
584​
585​ auto type = addRule(new RuleItem(QLatin1String("type"),
586​ RulePolicy::ForceRule, RuleItem::Option,
587​ i18n("Set window type"), i18n("Appearance & Fixes"),
588​ QIcon::fromTheme("window-duplicate")));
589​ type->setOptionsData(windowTypesModelData());
590​
591​ addRule(new RuleItem(QLatin1String("desktopfile"),
592​ RulePolicy::SetRule, RuleItem::String,
593​ i18n("Desktop file name"), i18n("Appearance & Fixes"),
594​ QIcon::fromTheme("application-x-desktop")));
595​
596​ addRule(new RuleItem(QLatin1String("blockcompositing"),
597​ RulePolicy::ForceRule, RuleItem::Boolean,
598​ i18n("Block compositing"), i18n("Appearance & Fixes"),
599​ QIcon::fromTheme("composite-track-on")));
600​}
601​
602​
603​const QHash<QString, QString> RulesModel::x11PropertyHash()
604​{
605​ static const auto propertyToRule = QHash<QString, QString> {
606​ /* The original detection dialog allows to choose depending on "Match complete window class":
607​ * if Match Complete == false: wmclass = "resourceClass"
608​ * if Match Complete == true: wmclass = "resourceName" + " " + "resourceClass"
609​ */
610​ { "resourceName", "wmclass" },
611​ { "caption", "title" },
612​ { "role", "windowrole" },
613​ { "clientMachine", "clientmachine" },
614​ { "x11DesktopNumber", "desktop" },
615​ { "maximizeHorizontal", "maximizehoriz" },
616​ { "maximizeVertical", "maximizevert" },
617​ { "minimized", "minimize" },
618​ { "shaded", "shade" },
619​ { "fullscreen", "fullscreen" },
620​ { "keepAbove", "above" },
621​ { "keepBelow", "below" },
622​ { "noBorder", "noborder" },
623​ { "skipTaskbar", "skiptaskbar" },
624​ { "skipPager", "skippager" },
625​ { "skipSwitcher", "skipswitcher" },
626​ { "type", "type" },
627​ { "desktopFile", "desktopfile" }
628​ };
629​ return propertyToRule;
630​};
631​
632​void RulesModel::prefillProperties(const QVariantMap &info)
633​{
634​ beginResetModel();
635​
636​ // Properties that cannot be directly applied via x11PropertyHash
637​ const QString position = QStringLiteral("%1,%2").arg(info.value("x").toInt())
638​ .arg(info.value("y").toInt());
639​ const QString size = QStringLiteral("%1,%2").arg(info.value("width").toInt())
640​ .arg(info.value("height").toInt());
641​
642​ if (!m_rules["position"]->isEnabled()) {
643​ m_rules["position"]->setValue(position);
644​ }
645​ if (!m_rules["size"]->isEnabled()) {
646​ m_rules["size"]->setValue(size);
647​ }
648​ if (!m_rules["minsize"]->isEnabled()) {
649​ m_rules["minsize"]->setValue(size);
650​ }
651​ if (!m_rules["maxsize"]->isEnabled()) {
652​ m_rules["maxsize"]->setValue(size);
653​ }
654​
655​ NET::WindowType window_type = static_cast<NET::WindowType>(info.value("type", 0).toInt());
656​ if (!m_rules["types"]->isEnabled() || m_rules["types"]->value() == 0) {
657​ if (window_type == NET::Unknown) {
658​ window_type = NET::Normal;
659​ }
660​ m_rules["types"]->setValue(1 << window_type);
661​ }
662​
663​ const auto ruleForProperty = x11PropertyHash();
664​ for (QString &property : info.keys()) {
665​ if (!ruleForProperty.contains(property)) {
666​ continue;
667​ }
668​ const QString ruleKey = ruleForProperty.value(property, QString());
669​ Q_ASSERT(hasRule(ruleKey));
670​
671​ // Only prefill disabled or empty properties
672​ if (!m_rules[ruleKey]->isEnabled() || m_rules[ruleKey]->value().toString().isEmpty()) {
673​ m_rules[ruleKey]->setValue(info.value(property));
674​ }
675​ }
676​
677​ endResetModel();
678​
679​ emit descriptionChanged();
680​ emit warningMessageChanged();
681​}
682​
683​
684​QList<OptionsModel::Data> RulesModel::windowTypesModelData() const
685​{
686​ static const auto modelData = QList<OptionsModel::Data> {
687​ //TODO: Find/create better icons
688​ { NET::Normal, i18n("Normal Window") , QIcon::fromTheme("window") },
689​ { NET::Dialog, i18n("Dialog Window") , QIcon::fromTheme("window-duplicate") },
690​ { NET::Utility, i18n("Utility Window") , QIcon::fromTheme("dialog-object-properties") },
691​ { NET::Dock, i18n("Dock (panel)") , QIcon::fromTheme("list-remove") },
692​ { NET::Toolbar, i18n("Toolbar") , QIcon::fromTheme("tools") },
693​ { NET::Menu, i18n("Torn-Off Menu") , QIcon::fromTheme("overflow-menu-left") },
694​ { NET::Splash, i18n("Splash Screen") , QIcon::fromTheme("embosstool") },
695​ { NET::Desktop, i18n("Desktop") , QIcon::fromTheme("desktop") },
696​ // { NET::Override, i18n("Unmanaged Window") }, deprecated
697​ { NET::TopMenu, i18n("Standalone Menubar"), QIcon::fromTheme("open-menu-symbolic") }
698​ };
699​ return modelData;
700​}
701​
702​QList<OptionsModel::Data> RulesModel::virtualDesktopsModelData() const
703​{
704​ QList<OptionsModel::Data> modelData;
705​ for (int desktopId = 1; desktopId <= KWindowSystem::numberOfDesktops(); ++desktopId) {
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​ desktopId,
708​ QString::number(desktopId).rightJustified(2) + QStringLiteral(": ") + KWindowSystem::desktopName(desktopId),
709​ QIcon::fromTheme("virtual-desktops")
710​ };
711​ }
712​ modelData << OptionsModel::Data{ NET::OnAllDesktops, i18n("All Desktops"), QIcon::fromTheme("window-pin") };
713​ return modelData;
714​}
715​
716​
717​QList<OptionsModel::Data> RulesModel::activitiesModelData() const
718​{
719​#ifdef KWIN_BUILD_ACTIVITIES
720​ QList<OptionsModel::Data> modelData;
721​
722​ // NULL_ID from kactivities/src/lib/core/consumer.cpp
723​ modelData << OptionsModel::Data{
724​ QString::fromLatin1("00000000-0000-0000-0000-000000000000"),
725​ i18n("All Activities"),
726​ QIcon::fromTheme("activities")
727​ };
728​
729​ const auto activities = m_activities->activities(KActivities::Info::Running);
730​ if (m_activities->serviceStatus() == KActivities::Consumer::Running) {
731​ for (const QString &activityId : activities) {
732​ const KActivities::Info info(activityId);
733​ modelData << OptionsModel::Data{ activityId, info.name(), QIcon::fromTheme(info.icon()) };
734​ }
735​ }
736​
737​ return modelData;
738​#else
739​ return {};
740​#endif
741​}
742​
743​QList<OptionsModel::Data> RulesModel::placementModelData() const
744​{
745​ // From "placement.h" : Placement rule is stored as a string, not the enum value
746​ static const auto modelData = QList<OptionsModel::Data> {
747​ { Placement::policyToString(Placement::Default), i18n("Default") },
748​ { Placement::policyToString(Placement::NoPlacement), i18n("No Placement") },
749​ { Placement::policyToString(Placement::Smart), i18n("Minimal Overlapping") },
750​ { Placement::policyToString(Placement::Maximizing), i18n("Maximized") },
751​ { Placement::policyToString(Placement::Cascade), i18n("Cascaded") },
752​ { Placement::policyToString(Placement::Centered), i18n("Centered") },
753​ { Placement::policyToString(Placement::Random), i18n("Random") },
754​ { Placement::policyToString(Placement::ZeroCornered), i18n("In Top-Left Corner") },
755​ { Placement::policyToString(Placement::UnderMouse), i18n("Under Mouse") },
756​ { Placement::policyToString(Placement::OnMainWindow), i18n("On Main Window") }
757​ };
758​ return modelData;
759​}
760​
761​QList<OptionsModel::Data> RulesModel::focusModelData() const
762​{
763​ static const auto modelData = QList<OptionsModel::Data> {
764​ { 0, i18n("None") },
765​ { 1, i18n("Low") },
766​ { 2, i18n("Normal") },
767​ { 3, i18n("High") },
768​ { 4, i18n("Extreme") }
769​ };
770​ return modelData;
771​}
772​
773​QList<OptionsModel::Data> RulesModel::colorSchemesModelData() const
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​ QList<OptionsModel::Data> modelData;
776​
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​ KColorSchemeManager schemes;
778​ QAbstractItemModel *schemesModel = schemes.model();
779​
780​ // Skip row 0, which is Default scheme
781​ for (int r = 1; r < schemesModel->rowCount(); r++) {
782​ const QModelIndex index = schemesModel->index(r, 0);
783​ modelData << OptionsModel::Data{
784​ QFileInfo(index.data(Qt::UserRole).toString()).baseName(),
broulikUnsubmitted
Done

You can also do QModelIndex::data()

broulik: You can also do `QModelIndex::data()`
785​ index.data(Qt::DisplayRole).toString(),
786​ index.data(Qt::DecorationRole).value<QIcon>()
787​ };
788​ }
789​
790​ return modelData;
791​}
792​
793​void RulesModel::detectWindowProperties(int secs)
794​{
795​ QTimer::singleShot(secs*1000, this, &RulesModel::selectX11Window);
796​}
797​
798​void RulesModel::selectX11Window()
799​{
800​ QDBusMessage message = QDBusMessage::createMethodCall(QStringLiteral("org.kde.KWin"),
801​ QStringLiteral("/KWin"),
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​ QStringLiteral("org.kde.KWin"),
803​ QStringLiteral("queryWindowInfo"));
804​
805​ QDBusPendingReply<QVariantMap> async = QDBusConnection::sessionBus().asyncCall(message);
806​
807​ QDBusPendingCallWatcher *callWatcher = new QDBusPendingCallWatcher(async, this);
808​ connect(callWatcher, &QDBusPendingCallWatcher::finished, this,
809​ [this](QDBusPendingCallWatcher *self) {
810​ QDBusPendingReply<QVariantMap> reply = *self;
811​ self->deleteLater();
812​ if (!reply.isValid()) {
813​ return;
814​ }
815​ const QVariantMap windowInfo = reply.value();
816​ //TODO: Improve UI to suggest/select the detected properties.
817​ // For now, just prefill unused rules
818​ prefillProperties(windowInfo);
819​ }
820​ );
821​}
822​
823​} //namespace