Differential D27862 Diff 78009 kcmkwin/kwinscreenedges/kwnscreenedgeconfigform.cpp

Changeset View

Standalone View

View Options

kcmkwin/kwinscreenedges/kwnscreenedgeconfigform.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 "kwnscreenedgeconfigform.h"
23​
24​#include <QDebug>
zzagUnsubmitted
Not Done

I don't see where it's used. Remove?

zzag: I don't see where it's used. Remove?
25​
26​#include "monitor.h"
27​#include "ui_touch.h"
28​
29​namespace KWin
30​{
31​
32​KWinScreenEdgeConfigForm::KWinScreenEdgeConfigForm(QWidget *parent)
33​ : QWidget(parent)
34​ , ui(new Ui::KWinTouchScreenConfigUi)
35​{
ervinUnsubmitted
Done

This is leaked

ervin: This is leaked
36​ ui->setupUi(this);
37​
38​ connect(ui->monitor,
39​ &Monitor::changed,
40​ this,
41​ &KWinScreenEdgeConfigForm::onChanged);
42​}
43​
44​KWin::KWinScreenEdgeConfigForm::~KWinScreenEdgeConfigForm()
45​{
46​ delete ui;
47​}
48​
49​void KWinScreenEdgeConfigForm::monitorHideEdge(ElectricBorder border, bool hidden)
50​{
51​ const int edge = KWinScreenEdgeConfigForm::electricBorderToMonitorEdge(border);
52​ ui->monitor->setEdgeHidden(edge, hidden);
53​}
54​
55​void KWinScreenEdgeConfigForm::monitorAddItem(const QString &item)
56​{
57​ for (int i = 0; i < 8; i++) {
58​ ui->monitor->addEdgeItem(i, item);
59​ }
60​}
61​
62​void KWinScreenEdgeConfigForm::monitorItemSetEnabled(int index, bool enabled)
63​{
64​ for (int i = 0; i < 8; i++) {
65​ ui->monitor->setEdgeItemEnabled(i, index, enabled);
66​ }
67​}
68​
69​void KWinScreenEdgeConfigForm::monitorChangeEdge(const QList<int> &borderList, int index)
70​{
71​ for (int border : borderList) {
72​ monitorChangeEdge(static_cast<ElectricBorder>(border), index);
73​ }
74​}
75​
76​void KWinScreenEdgeConfigForm::monitorChangeEdge(ElectricBorder border, int index)
77​{
78​ if (ELECTRIC_COUNT == border || ElectricNone == border) {
79​ return;
80​ }
81​ m_reference[border] = index;
82​ ui->monitor->selectEdgeItem(KWinScreenEdgeConfigForm::electricBorderToMonitorEdge(border), index);
83​}
84​
85​QList<int> KWinScreenEdgeConfigForm::monitorCheckEffectHasEdge(int index) const
ervinUnsubmitted
Done

those static casts are not strictly required, enums convert implicitly to int

ervin: those static casts are not strictly required, enums convert implicitly to int
86​{
87​ QList<int> list = QList<int>();
88​ if (ui->monitor->selectedEdgeItem(Monitor::Top) == index) {
89​ list.append(ElectricTop);
90​ }
91​ if (ui->monitor->selectedEdgeItem(Monitor::TopRight) == index) {
92​ list.append(ElectricTopRight);
93​ }
94​ if (ui->monitor->selectedEdgeItem(Monitor::Right) == index) {
95​ list.append(ElectricRight);
96​ }
97​ if (ui->monitor->selectedEdgeItem(Monitor::BottomRight) == index) {
98​ list.append(ElectricBottomRight);
99​ }
100​ if (ui->monitor->selectedEdgeItem(Monitor::Bottom) == index) {
101​ list.append(ElectricBottom);
102​ }
103​ if (ui->monitor->selectedEdgeItem(Monitor::BottomLeft) == index) {
104​ list.append(ElectricBottomLeft);
105​ }
106​ if (ui->monitor->selectedEdgeItem(Monitor::Left) == index) {
107​ list.append(ElectricLeft);
108​ }
109​ if (ui->monitor->selectedEdgeItem(Monitor::TopLeft) == index) {
110​ list.append(ElectricTopLeft);
111​ }
112​
113​ if (list.isEmpty()) {
114​ list.append(ElectricNone);
115​ }
116​ return list;
117​}
118​
119​int KWinScreenEdgeConfigForm::selectedEdgeItem(ElectricBorder border) const
120​{
121​ return ui->monitor->selectedEdgeItem(KWinScreenEdgeConfigForm::electricBorderToMonitorEdge(border));
122​}
123​
124​void KWinScreenEdgeConfigForm::monitorChangeDefaultEdge(ElectricBorder border, int index)
125​{
126​ if (ELECTRIC_COUNT == border || ElectricNone == border) {
127​ return;
128​ }
129​ m_default[border] = index;
130​}
131​
132​void KWinScreenEdgeConfigForm::monitorChangeDefaultEdge(const QList<int> &borderList, int index)
133​{
134​ for (int border : borderList) {
135​ monitorChangeDefaultEdge(static_cast<ElectricBorder>(border), index);
136​ }
137​}
138​
139​void KWinScreenEdgeConfigForm::reload()
140​{
141​ for (auto it = m_reference.begin(); it != m_reference.cend(); ++it) {
142​ ui->monitor->selectEdgeItem(KWinScreenEdgeConfigForm::electricBorderToMonitorEdge(it.key()), it.value());
143​ }
144​ onChanged();
145​}
146​
147​void KWinScreenEdgeConfigForm::setDefaults()
148​{
149​ for (auto it = m_default.begin(); it != m_default.cend(); ++it) {
150​ ui->monitor->selectEdgeItem(KWinScreenEdgeConfigForm::electricBorderToMonitorEdge(it.key()), it.value());
151​ }
152​ onChanged();
153​}
154​
155​int KWinScreenEdgeConfigForm::electricBorderToMonitorEdge(ElectricBorder border)
ervinUnsubmitted
Done

ditto

ervin: ditto
156​{
157​ switch(border) {
158​ case ElectricTop:
159​ return Monitor::Top;
160​ case ElectricTopRight:
161​ return Monitor::TopRight;
162​ case ElectricRight:
163​ return Monitor::Right;
164​ case ElectricBottomRight:
165​ return Monitor::BottomRight;
166​ case ElectricBottom:
167​ return Monitor::Bottom;
168​ case ElectricBottomLeft:
169​ return Monitor::BottomLeft;
170​ case ElectricLeft:
171​ return Monitor::Left;
172​ case ElectricTopLeft:
173​ return Monitor::TopLeft;
174​ default: // ELECTRIC_COUNT and ElectricNone
175​ Q_ASSERT(false);
176​ }
177​}
178​
179​ElectricBorder KWinScreenEdgeConfigForm::monitorEdgeToElectricBorder(int edge)
180​{
181​ const Monitor::Edges monitorEdge = static_cast<Monitor::Edges>(edge);
182​ switch (monitorEdge) {
183​ case Monitor::Left:
184​ return ElectricLeft;
185​ case Monitor::Right:
186​ return ElectricRight;
187​ case Monitor::Top:
188​ return ElectricTop;
189​ case Monitor::Bottom:
190​ return ElectricBottom;
191​ case Monitor::TopLeft:
192​ return ElectricTopLeft;
193​ case Monitor::TopRight:
194​ return ElectricTopRight;
195​ case Monitor::BottomLeft:
196​ return ElectricBottomLeft;
197​ case Monitor::BottomRight:
198​ return ElectricBottomRight;
199​ default:
200​ return ElectricNone;
201​ }
202​}
203​
204​void KWinScreenEdgeConfigForm::onChanged()
205​{
206​ bool needSave = false;
207​ for (auto it = m_reference.begin(); it != m_reference.cend(); ++it) {
208​ needSave |= it.value() != ui->monitor->selectedEdgeItem(KWinScreenEdgeConfigForm::electricBorderToMonitorEdge(it.key()));
209​ }
210​ emit saveNeededChanged(needSave);
211​
212​ bool isDefault = true;
213​ for (auto it = m_default.begin(); it != m_default.cend(); ++it) {
214​ isDefault &= it.value() == ui->monitor->selectedEdgeItem(KWinScreenEdgeConfigForm::electricBorderToMonitorEdge(it.key()));
215​ }
216​ emit defaultChanged(isDefault);
217​}
218​
219​} // namespace