Differential D28152 Diff 78313 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​class RuleItemPrivate
28​{
29​public:
30​ RuleItemPrivate(const QString &key, const QString &name, const QString &section, const QString &iconName)
31​ : m_key(key)
32​ , m_name(name)
33​ , m_section(section)
34​ , m_icon(QIcon::fromTheme(iconName))
35​ , m_enabled(false)
36​ , m_flags(0)
37​ {};
broulikUnsubmitted
Done

We usually prefer initialization in the class definition

broulik: We usually prefer initialization in the class definition
38​
39​public:
40​ QString m_key;
41​ QString m_name;
42​ QString m_section;
43​ QIcon m_icon;
44​
45​ bool m_enabled;
46​
47​ QString m_description;
48​ uint m_flags;
49​
broulikUnsubmitted
Done

There's QFlag you could use

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