Differential D27862 Diff 79116 kcmkwin/kwinscreenedges/kwinscreenedge.cpp

Changeset View

Standalone View

View Options

kcmkwin/kwinscreenedges/kwinscreenedge.cpp

  • This file was added.
1​/********************************************************************
2​ KWin - the KDE window manager
3​ This file is part of the KDE project.
4​
5​Copyright (C) 2009 Lucas Murray <lmurray@undefinedfire.com>
6​Copyright (C) 2020 Cyril Rossi <cyril.rossi@enioka.com>
7​
8​This program is free software; you can redistribute it and/or modify
9​it under the terms of the GNU General Public License as published by
10​the Free Software Foundation; either version 2 of the License, or
11​(at your option) any later version.
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 "kwinscreenedge.h"
23​
24​#include "monitor.h"
25​
26​namespace KWin
27​{
28​
29​KWinScreenEdge::KWinScreenEdge(QWidget *parent)
30​ : QWidget(parent)
31​{
32​ QMetaObject::invokeMethod(this, "createConnection", Qt::QueuedConnection);
33​}
34​
35​KWin::KWinScreenEdge::~KWinScreenEdge()
ervinUnsubmitted
Done

That KWin namespace is redundant here.

ervin: That KWin namespace is redundant here.
36​{
37​}
38​
39​void KWinScreenEdge::monitorHideEdge(ElectricBorder border, bool hidden)
40​{
41​ const int edge = KWinScreenEdge::electricBorderToMonitorEdge(border);
42​ monitor()->setEdgeHidden(edge, hidden);
43​}
44​
45​void KWinScreenEdge::monitorAddItem(const QString &item)
46​{
47​ for (int i = 0; i < 8; i++) {
48​ monitor()->addEdgeItem(i, item);
49​ }
50​}
51​
52​void KWinScreenEdge::monitorItemSetEnabled(int index, bool enabled)
53​{
54​ for (int i = 0; i < 8; i++) {
55​ monitor()->setEdgeItemEnabled(i, index, enabled);
56​ }
57​}
58​
59​void KWinScreenEdge::monitorChangeEdge(const QList<int> &borderList, int index)
60​{
61​ for (int border : borderList) {
62​ monitorChangeEdge(static_cast<ElectricBorder>(border), index);
63​ }
64​}
65​
66​void KWinScreenEdge::monitorChangeEdge(ElectricBorder border, int index)
67​{
68​ if (ELECTRIC_COUNT == border || ElectricNone == border) {
69​ return;
70​ }
71​ m_reference[border] = index;
72​ monitor()->selectEdgeItem(KWinScreenEdge::electricBorderToMonitorEdge(border), index);
73​}
74​
75​QList<int> KWinScreenEdge::monitorCheckEffectHasEdge(int index) const
76​{
77​ QList<int> list = QList<int>();
ervinUnsubmitted
Done

Either:
auto list = QList<int>();
or
QList<int> list;

ervin: Either: `auto list = QList<int>();` or `QList<int> list;`
78​ if (monitor()->selectedEdgeItem(Monitor::Top) == index) {
79​ list.append(ElectricTop);
80​ }
81​ if (monitor()->selectedEdgeItem(Monitor::TopRight) == index) {
82​ list.append(ElectricTopRight);
83​ }
84​ if (monitor()->selectedEdgeItem(Monitor::Right) == index) {
85​ list.append(ElectricRight);
86​ }
87​ if (monitor()->selectedEdgeItem(Monitor::BottomRight) == index) {
88​ list.append(ElectricBottomRight);
89​ }
90​ if (monitor()->selectedEdgeItem(Monitor::Bottom) == index) {
91​ list.append(ElectricBottom);
92​ }
93​ if (monitor()->selectedEdgeItem(Monitor::BottomLeft) == index) {
94​ list.append(ElectricBottomLeft);
95​ }
96​ if (monitor()->selectedEdgeItem(Monitor::Left) == index) {
97​ list.append(ElectricLeft);
98​ }
99​ if (monitor()->selectedEdgeItem(Monitor::TopLeft) == index) {
100​ list.append(ElectricTopLeft);
101​ }
102​
103​ if (list.isEmpty()) {
104​ list.append(ElectricNone);
105​ }
106​ return list;
107​}
108​
109​int KWinScreenEdge::selectedEdgeItem(ElectricBorder border) const
110​{
111​ return monitor()->selectedEdgeItem(KWinScreenEdge::electricBorderToMonitorEdge(border));
112​}
113​
114​void KWinScreenEdge::monitorChangeDefaultEdge(ElectricBorder border, int index)
115​{
116​ if (ELECTRIC_COUNT == border || ElectricNone == border) {
117​ return;
118​ }
119​ m_default[border] = index;
120​}
121​
122​void KWinScreenEdge::monitorChangeDefaultEdge(const QList<int> &borderList, int index)
123​{
124​ for (int border : borderList) {
125​ monitorChangeDefaultEdge(static_cast<ElectricBorder>(border), index);
126​ }
127​}
128​
129​void KWinScreenEdge::reload()
130​{
131​ for (auto it = m_reference.begin(); it != m_reference.cend(); ++it) {
132​ monitor()->selectEdgeItem(KWinScreenEdge::electricBorderToMonitorEdge(it.key()), it.value());
133​ }
134​ onChanged();
135​}
136​
137​void KWinScreenEdge::setDefaults()
138​{
139​ for (auto it = m_default.begin(); it != m_default.cend(); ++it) {
140​ monitor()->selectEdgeItem(KWinScreenEdge::electricBorderToMonitorEdge(it.key()), it.value());
141​ }
142​ onChanged();
143​}
144​
145​int KWinScreenEdge::electricBorderToMonitorEdge(ElectricBorder border)
146​{
147​ switch(border) {
148​ case ElectricTop:
149​ return Monitor::Top;
150​ case ElectricTopRight:
151​ return Monitor::TopRight;
152​ case ElectricRight:
153​ return Monitor::Right;
154​ case ElectricBottomRight:
155​ return Monitor::BottomRight;
156​ case ElectricBottom:
157​ return Monitor::Bottom;
158​ case ElectricBottomLeft:
159​ return Monitor::BottomLeft;
160​ case ElectricLeft:
161​ return Monitor::Left;
162​ case ElectricTopLeft:
163​ return Monitor::TopLeft;
164​ default: // ELECTRIC_COUNT and ElectricNone
165​ Q_ASSERT(false);
166​ }
ervinUnsubmitted
Not Done

Ah indeed, in non-debug builds Q_ASSERT is a noop so you still need to return something after it. Also now I realize that using Q_UNREACHABLE would have probably been better too.

ervin: Ah indeed, in non-debug builds Q_ASSERT is a noop so you still need to return something after…
167​}
168​
169​ElectricBorder KWinScreenEdge::monitorEdgeToElectricBorder(int edge)
170​{
171​ const Monitor::Edges monitorEdge = static_cast<Monitor::Edges>(edge);
172​ switch (monitorEdge) {
173​ case Monitor::Left:
174​ return ElectricLeft;
175​ case Monitor::Right:
176​ return ElectricRight;
177​ case Monitor::Top:
178​ return ElectricTop;
179​ case Monitor::Bottom:
180​ return ElectricBottom;
181​ case Monitor::TopLeft:
182​ return ElectricTopLeft;
183​ case Monitor::TopRight:
184​ return ElectricTopRight;
185​ case Monitor::BottomLeft:
186​ return ElectricBottomLeft;
187​ case Monitor::BottomRight:
188​ return ElectricBottomRight;
189​ default:
190​ return ElectricNone;
191​ }
192​}
193​
194​void KWinScreenEdge::onChanged()
195​{
196​ bool needSave = false;
197​ for (auto it = m_reference.begin(); it != m_reference.cend(); ++it) {
198​ needSave |= it.value() != monitor()->selectedEdgeItem(KWinScreenEdge::electricBorderToMonitorEdge(it.key()));
199​ }
200​ emit saveNeededChanged(needSave);
201​
202​ bool isDefault = true;
203​ for (auto it = m_default.begin(); it != m_default.cend(); ++it) {
204​ isDefault &= it.value() == monitor()->selectedEdgeItem(KWinScreenEdge::electricBorderToMonitorEdge(it.key()));
205​ }
206​ emit defaultChanged(isDefault);
207​}
208​
209​void KWinScreenEdge::createConnection()
210​{
211​ connect(monitor(),
212​ &Monitor::changed,
213​ this,
214​ &KWinScreenEdge::onChanged);
215​}
216​
217​} // namespace