Differential D28152 Diff 80472 kcmkwin/kwinrules/ruleitem.cpp

Changeset View

Standalone View

View Options

kcmkwin/kwinrules/ruleitem.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 "ruleitem.h"
22​
23​
24​namespace KWin
25​{
26​
27​RuleItem::RuleItem(const QString &key,
28​ const RulePolicy::Type policyType,
29​ const RuleItem::Type type,
30​ const QString &name,
31​ const QString &section,
32​ const QIcon &icon,
33​ const QString &description)
34​ : m_key(key)
35​ , m_type(type)
36​ , m_name(name)
37​ , m_section(section)
broulikUnsubmitted
Done

We usually prefer initialization in the class definition

broulik: We usually prefer initialization in the class definition
38​ , m_icon(icon)
39​ , m_description(description)
40​ , m_flags(NoFlags)
41​ , m_enabled(false)
42​ , m_policy(new RulePolicy(policyType))
43​ , m_options(nullptr)
44​{
45​ reset();
46​}
47​
48​RuleItem::~RuleItem()
49​{
broulikUnsubmitted
Done

There's QFlag you could use

broulik: There's `QFlag` you could use
50​ delete m_policy;
51​ delete m_options;
52​}
53​
54​void RuleItem::reset()
55​{
56​ m_enabled = hasFlag(AlwaysEnabled) | hasFlag(StartEnabled);
57​ m_value = typedValue(QVariant(), m_type);
58​ m_suggestedValue = QVariant();
59​ m_policy->resetValue();
60​ if (m_options) {
61​ m_options->resetValue();
62​ }
63​}
64​
65​QString RuleItem::key() const
66​{
67​ return m_key;
68​}
69​
70​QString RuleItem::name() const
71​{
72​ return m_name;
73​}
74​
75​QString RuleItem::section() const
76​{
77​ return m_section;
78​}
79​
80​QString RuleItem::iconName() const
81​{
82​ return m_icon.name();
83​}
84​
85​QIcon RuleItem::icon() const
86​{
87​ return m_icon;
88​}
89​
90​QString RuleItem::description() const
91​{
92​ return m_description;
93​}
94​
95​bool RuleItem::isEnabled() const
96​{
97​ return m_enabled;
98​}
99​
100​void RuleItem::setEnabled(bool enabled)
101​{
102​ m_enabled = enabled | hasFlag(AlwaysEnabled);
103​}
104​
105​bool RuleItem::hasFlag(RuleItem::Flags flag) const
106​{
107​ return m_flags.testFlag(flag);
108​}
109​
110​void RuleItem::setFlag(RuleItem::Flags flag, bool active)
111​{
112​ m_flags.setFlag(flag, active);
113​}
114​
115​RuleItem::Type RuleItem::type() const
116​{
117​ return m_type;
118​}
119​
120​QVariant RuleItem::value() const
121​{
122​ if (m_type == Option) {
123​ return m_options->value();
124​ }
125​ return m_value;
126​}
127​
128​void RuleItem::setValue(QVariant value)
129​{
130​ if (m_type == Option) {
131​ m_options->setValue(value);
132​ }
133​ m_value = typedValue(value, m_type);
134​}
135​
136​QVariant RuleItem::suggestedValue() const
137​{
138​ return m_suggestedValue;
139​}
140​
141​void RuleItem::setSuggestedValue(QVariant value, bool forceValue)
142​{
143​ if (forceValue) {
144​ setValue(value);
145​ }
146​ m_suggestedValue = typedValue(value, m_type);
147​}
148​
149​QVariant RuleItem::options() const
150​{
151​ if (!m_options) {
152​ return QVariant();
153​ }
154​ return QVariant::fromValue(m_options);
155​}
156​
157​void RuleItem::setOptionsData(const QList<OptionsModel::Data> &data)
158​{
159​ if (!m_options) {
160​ if (m_type != Option && m_type != FlagsOption) {
161​ return;
162​ }
163​ m_options = new OptionsModel();
164​ }
165​ m_options->updateModelData(data);
166​ m_options->setValue(m_value);
167​}
168​
169​int RuleItem::policy() const
170​{
171​ return m_policy->value();
172​}
173​
174​void RuleItem::setPolicy(int policy)
175​{
176​ m_policy->setValue(policy);
177​}
178​
179​RulePolicy::Type RuleItem::policyType() const
180​{
181​ return m_policy->type();
182​}
183​
184​QVariant RuleItem::policyModel() const
185​{
186​ return QVariant::fromValue(m_policy);
187​}
188​
189​QString RuleItem::policyKey() const
190​{
191​ return m_policy->policyKey(m_key);
192​}
193​
194​QVariant RuleItem::typedValue(const QVariant &value, const RuleItem::Type type)
195​{
196​ if (value.isNull()) {
197​ return QVariant();
198​ }
199​ switch (type) {
200​ case Undefined:
201​ case Option:
202​ return value;
203​ case Boolean:
204​ return value.toBool();
205​ case Integer:
206​ case Percentage:
207​ return value.toInt();
208​ case FlagsOption:
209​ // HACK: Currently, the only user of this is "types" property
210​ if (value.toInt() == -1) { //NET:AllTypesMask
211​ return 0x3FF - 0x040; //All possible flags minus NET::Override (deprecated)
212​ }
213​ return value.toInt();
214​ case Coordinate:
215​ if (value.toString().isEmpty()) {
216​ return QStringLiteral("0,0");
217​ }
218​ return value.toString();
219​ case String:
220​ case Shortcut:
221​ return value.toString();
222​ }
223​ return value;
224​}
225​
226​} //namespace
227​