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