Differential D28152 Diff 78318 kcmkwin/kwinrules/optionsmodel.cpp

Changeset View

Standalone View

View Options

kcmkwin/kwinrules/optionsmodel.cpp

  • This file was added.
1​/*
2​ * Copyright (c) 2020 Ismael Asensio <isma.af@gmail.com>
3​ *
4​ * This program is free software; you can redistribute it and/or
5​ * modify it under the terms of the GNU General Public License as
6​ * published by the Free Software Foundation; either version 2 of
7​ * the License or (at your option) version 3 or any later version
8​ * accepted by the membership of KDE e.V. (or its successor approved
9​ * by the membership of KDE e.V.), which shall act as a proxy
10​ * defined in Section 14 of version 3 of the license.
11​ *
12​ * This program is distributed in the hope that it will be useful,
13​ * but WITHOUT ANY WARRANTY; without even the implied warranty of
14​ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15​ * GNU General Public License for more details.
16​ *
17​ * You should have received a copy of the GNU General Public License
18​ * along with this program. If not, see <http://www.gnu.org/licenses/>.
19​ */
20​
21​#include "optionsmodel.h"
22​
23​#include <KLocalizedString>
24​
25​
26​namespace KWin
27​{
28​
29​QHash<int, QByteArray> OptionsModel::roleNames() const
30​{
31​ return {
32​ {Qt::DisplayRole, QByteArrayLiteral("text")},
33​ {Qt::UserRole, QByteArrayLiteral("value")},
34​ {Qt::DecorationRole, QByteArrayLiteral("icon")},
35​ {Qt::ToolTipRole, QByteArrayLiteral("description")},
36​ {Qt::UserRole + 1, QByteArrayLiteral("iconName")},
37​ };
38​}
39​
40​int OptionsModel::rowCount(const QModelIndex &parent) const
41​{
42​ if (parent.isValid()) {
43​ return 0;
44​ }
45​ return m_data.size();
46​}
47​
48​QVariant OptionsModel::data(const QModelIndex &index, int role) const
49​{
50​ if (!checkIndex(index, CheckIndexOption::IndexIsValid | CheckIndexOption::ParentIsInvalid)) {
51​ return QVariant();
broulikUnsubmitted
Done

There's checkIndex() :)

broulik: There's `checkIndex()` :)
52​ }
53​
54​ const Data data = m_data.at(index.row());
55​
56​ switch (role) {
57​ case Qt::DisplayRole:
58​ return data.text;
59​ case Qt::UserRole:
60​ return data.value;
61​ case Qt::DecorationRole:
62​ return data.icon;
63​ case Qt::UserRole + 1:
64​ return data.icon.name();
65​ case Qt::ToolTipRole:
66​ return data.description;
67​ }
68​ return QVariant();
69​}
70​
71​int OptionsModel::selectedIndex() const
72​{
73​ return m_index;
74​}
75​
76​QVariant OptionsModel::value() const
77​{
78​ if (m_data.isEmpty()) {
79​ return QVariant();
80​ }
81​ return m_data.at(m_index).value;
82​}
83​
84​void OptionsModel::setValue(QVariant value)
85​{
86​ if (this->value() == value) {
87​ return;
88​ }
89​ for (int index = 0; index < m_data.count(); index++) {
90​ if (m_data.at(index).value != value) {
91​ continue;
92​ }
93​ if (m_index != index) {
94​ m_index = index;
95​ emit selectedIndexChanged(index);
96​ }
97​ }
98​}
99​
100​void OptionsModel::resetValue()
101​{
102​ m_index = 0;
103​ emit selectedIndexChanged(m_index);
104​}
105​
106​void OptionsModel::updateModelData(const QList<Data> &data) {
107​ beginResetModel();
108​ m_data = data;
109​ endResetModel();
110​}
111​
112​
113​RulePolicy::Type RulePolicy::type() const
114​{
115​ return m_type;
116​}
117​
118​int RulePolicy::value() const
119​{
120​ if (m_type == RulePolicy::NoPolicy) {
121​ return Rules::Apply; // To simplify external checks when rule has no policy
122​ }
123​ return OptionsModel::value().toInt();
124​}
125​
126​QString RulePolicy::policyKey(const QString &key) const
127​{
128​ switch (m_type) {
129​ case NoPolicy:
130​ return QString();
131​ case StringMatch:
132​ return QStringLiteral("%1match").arg(key);
133​ case SetRule:
134​ case ForceRule:
135​ return QStringLiteral("%1rule").arg(key);
136​ }
137​
138​ return QString();
139​}
140​
141​QList<RulePolicy::Data> RulePolicy::policyOptions(RulePolicy::Type type)
142​{
143​ static const auto stringMatchOptions = QList<RulePolicy::Data> {
144​ {Rules::UnimportantMatch, i18n("Unimportant")},
145​ {Rules::ExactMatch, i18n("Exact Match")},
146​ {Rules::SubstringMatch, i18n("Substring Match")},
147​ {Rules::RegExpMatch, i18n("Regular Expression")}
148​ };
149​
150​ static const auto setRuleOptions = QList<RulePolicy::Data> {
151​ {Rules::DontAffect,
152​ i18n("Do Not Affect"),
153​ i18n("The window property will not be affected and therefore the default handling for it will be used."
154​ "\nSpecifying this will block more generic window settings from taking effect.")},
155​ {Rules::Apply,
156​ i18n("Apply Initially"),
157​ i18n("The window property will be only set to the given value after the window is created."
158​ "\nNo further changes will be affected.")},
159​ {Rules::Remember,
160​ i18n("Remember"),
161​ i18n("The value of the window property will be remembered and, every time the window"
162​ " is created, the last remembered value will be applied.")},
163​ {Rules::Force,
164​ i18n("Force"),
165​ i18n("The window property will be always forced to the given value.")},
166​ {Rules::ApplyNow,
167​ i18n("Apply Now"),
168​ i18n("The window property will be set to the given value immediately and will not be affected later"
169​ "\n(this action will be deleted afterwards).")},
170​ {Rules::ForceTemporarily,
171​ i18n("Force Temporarily"),
172​ i18n("The window property will be forced to the given value until it is hidden"
173​ "\n(this action will be deleted after the window is hidden).")}
174​ };
175​
176​ static auto forceRuleOptions = QList<RulePolicy::Data> {
177​ setRuleOptions.at(0), // Rules::DontAffect
178​ setRuleOptions.at(3), // Rules::Force
179​ setRuleOptions.at(5), // Rules::ForceTemporarily
180​ };
181​
182​ switch (type) {
183​ case NoPolicy:
184​ return {};
185​ case StringMatch:
186​ return stringMatchOptions;
187​ case SetRule:
188​ return setRuleOptions;
189​ case ForceRule:
190​ return forceRuleOptions;
191​ }
192​ return {};
193​}
194​
195​} //namespace