Differential D14542 Diff 46551 kcmkwin/kwindesktop/desktopsmodel.cpp

Changeset View

Standalone View

kcmkwin/kwindesktop/desktopsmodel.cpp

This file was added.

1		/*
2		* Copyright (C) 2018 Eike Hein <hein@kde.org>
3		* Copyright (C) 2018 Marco Martin <mart@kde.org>
4		*
5		* This program is free software; you can redistribute it and/or modify
6		* it under the terms of the GNU General Public License as published by
7		* the Free Software Foundation; either version 2 of the License, or
8		* (at your option) any later version.
9		*
10		* This program is distributed in the hope that it will be useful,
11		* but WITHOUT ANY WARRANTY; without even the implied warranty of
12		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13		* GNU General Public License for more details.
14		*
15		* You should have received a copy of the GNU General Public License
16		* along with this program. If not, see <http://www.gnu.org/licenses/>.
17		*/
18
19		#include "desktopsmodel.h"
20
21		#include <cmath>
22
23		#include <KLocalizedString>
24
25		#include <QDBusArgument>
26		#include <QDBusConnection>
27		#include <QDBusMessage>
28		#include <QDBusMetaType>
29		#include <QDBusPendingCall>
30		#include <QDBusPendingCallWatcher>
31		#include <QDBusPendingReply>
32		#include <QDBusVariant>
33		#include <QMetaEnum>
34		#include <QUuid>
35
36		namespace KWin
37		{
38
	zzagUnsubmitted Not Done namespace KWin { zzag: ```lang=cpp namespace KWin { ```
39		static const QString s_serviceName(QStringLiteral("org.kde.KWin"));
40		static const QString s_virtualDesktopsInterface(QStringLiteral("org.kde.KWin.VirtualDesktopManager"));
41		static const QString s_virtDesktopsPath(QStringLiteral("/VirtualDesktopManager"));
42		static const QString s_fdoPropertiesInterface(QStringLiteral("org.freedesktop.DBus.Properties"));
43
44		DesktopsModel::DesktopsModel(QObject *parent)
45		: QAbstractListModel(parent)
46		, m_userModified(false)
47		, m_serverModified(false)
48		, m_serverSideRows(-1)
49		, m_synchronizing(false)
50		{
51		qDBusRegisterMetaType<KWin::DBusDesktopDataStruct>();
52		qDBusRegisterMetaType<KWin::DBusDesktopDataVector>();
53
54		auto initializeCall = QDBusMessage::createMethodCall(
55		s_serviceName,
56		s_virtDesktopsPath,
57		s_fdoPropertiesInterface,
58		QStringLiteral("GetAll"));
59
60		initializeCall.setArguments({s_virtualDesktopsInterface});
61
62		QDBusConnection::sessionBus().callWithCallback(
63		initializeCall,
64		this,
65		SLOT(initialize(QDBusMessage)),
66		SLOT(handleCallError()));
67		}
68
69		DesktopsModel::~DesktopsModel()
70		{
71		}
72
73		QHash<int, QByteArray> DesktopsModel::roleNames() const
74		{
75		QHash<int, QByteArray> roles = QAbstractItemModel::roleNames();
76
77		QMetaEnum e = metaObject()->enumerator(metaObject()->indexOfEnumerator("AdditionalRoles"));
78
79		for (int i = 0; i < e.keyCount(); ++i) {
80		roles.insert(e.value(i), e.key(i));
81		}
82
83		return roles;
84		}
85
86		QVariant DesktopsModel::data(const QModelIndex &index, int role) const
87		{
88		if (!index.isValid() \|\| index.row() < 0 \|\| index.row() > (m_desktops.count() - 1)) {
89		return QVariant();
90		}
91
92		if (role == Qt::DisplayRole) {
93		return m_names.value(m_desktops.at(index.row()));
94		} else if (role == Id) {
95		return m_desktops.at(index.row());
96		} else if (role == DesktopRow) {
97		const int rows = std::max(m_rows, 1);
98		const int perRow = std::ceil((qreal)m_desktops.count() / (qreal)rows);
99
100		return (index.row() / perRow) + 1;
101
102		}
103
104		return QVariant();
105		}
106
107		int DesktopsModel::rowCount(const QModelIndex &parent) const
108		{
109		if (parent.isValid()) {
110		return 0;
111		}
112
113		return m_desktops.count();
114		}
115
116		bool DesktopsModel::ready() const
117		{
118		return !m_serverSideDesktops.isEmpty();
119		}
120
121		QString DesktopsModel::error() const
122		{
123		return m_error;
124		}
125
126		bool DesktopsModel::userModified() const
127		{
128		return m_userModified;
129		}
130
131		bool DesktopsModel::serverModified() const
132		{
133		return m_serverModified;
134		}
135
136		int DesktopsModel::rows() const
137		{
138		return m_rows;
139		}
140
141		void DesktopsModel::setRows(int rows)
142		{
143		if (!ready()) {
144		return;
145		}
146
147		if (m_rows != rows) {
148		m_rows = rows;
149
150		emit rowsChanged();
151		emit dataChanged(index(0, 0), index(m_desktops.count() - 1, 0), QVector<int>{DesktopRow});
152
153		checkModifiedState();
154		}
155		}
156
157		void DesktopsModel::createDesktop(const QString &name)
158		{
159		if (!ready()) {
160		return;
161		}
162
163		beginInsertRows(QModelIndex(), m_serverSideDesktops.count(), m_serverSideDesktops.count());
164
165		const QString &dummyId = QUuid::createUuid().toString(QUuid::WithoutBraces);
166
167		m_desktops.append(dummyId);
168		m_names[dummyId] = name;
169
170		endInsertRows();
171
172		checkModifiedState();
173		}
174
175		void DesktopsModel::removeDesktop(const QString &id)
176		{
177		if (!ready() \|\| !m_desktops.contains(id)) {
178		return;
179		}
180
181		const int desktopIndex = m_desktops.indexOf(id);
182
183		beginRemoveRows(QModelIndex(), desktopIndex, desktopIndex);
184
185		m_desktops.removeAt(desktopIndex);
186		m_names.remove(id);
187
188		endRemoveRows();
189
190		checkModifiedState();
191		}
192
193		void DesktopsModel::setDesktopName(const QString &id, const QString &name)
194		{
195		if (!ready() \|\| !m_desktops.contains(id)) {
196		return;
197		}
198
199		m_names[id] = name;
200
201		const QModelIndex &idx = index(m_desktops.indexOf(id), 0);
202
203		dataChanged(idx, idx, QVector<int>{Qt::DisplayRole});
	davidedmundsonUnsubmitted Not Done this is setting it to the value it already is davidedmundson: this is setting it to the value it already is
204
205		checkModifiedState();
206		}
207
208		void DesktopsModel::syncWithServer()
209		{
210		m_synchronizing = true;
211
212		auto callFinished = [this](QDBusPendingCallWatcher *call) {
213		QDBusPendingReply<void> reply = *call;
214
215		if (reply.isError()) {
216		handleCallError();
217		}
218
219		call->deleteLater();
220		};
221
222		if (m_desktops.count() > m_serverSideDesktops.count()) {
223		auto call = QDBusMessage::createMethodCall(
224		s_serviceName,
225		s_virtDesktopsPath,
226		s_virtualDesktopsInterface,
227		QStringLiteral("createDesktop"));
228
229		const int newIndex = m_serverSideDesktops.count();
230
231		call.setArguments({(uint)newIndex, m_names.value(m_desktops.at(newIndex))});
232
233		QDBusPendingCall pending = QDBusConnection::sessionBus().asyncCall(call);
234
235		const auto *watcher = new QDBusPendingCallWatcher(pending, this);
236		QObject::connect(watcher, &QDBusPendingCallWatcher::finished, this, callFinished);
237
238		return; // The change-handling slot will call syncWithServer() again,
239		// until everything is in sync.
240		}
241
242		if (m_desktops.count() < m_serverSideDesktops.count()) {
243		QStringListIterator i(m_serverSideDesktops);
244
245		i.toBack();
246
247		while (i.hasPrevious()) {
248		const QString &previous = i.previous();
249
250		if (!m_desktops.contains(previous)) {
251		auto call = QDBusMessage::createMethodCall(
252		s_serviceName,
	davidedmundsonUnsubmitted Not Done If I have 3 desktops with 3 IDs id1 -> desktop1 id2 -> desktop2 id3 -> desktop3 and I delete desktop2 Here I delete 3 and then sync the names, leaving me with: id1 -> desktop1 id2 -> desktop3 it looks fine within the confines of this KCM, but as soon as we rely on those IDs for external use (even just the fact that a user might have his windows on id3 and none on id2) it'll fall apart. When you make the change sending insert/remove instead of renaming we'll need to make sure we do removal before insertion. desktopCreated relies on the index of the newly created desktop to be in the same place as m_desktops has it. If we insert first, the position will be off as the server will still have the about-to-be-deleted entries davidedmundson: If I have 3 desktops with 3 IDs id1 -> desktop1 id2 -> desktop2 id3 -> desktop3 and I delete…
253		s_virtDesktopsPath,
254		s_virtualDesktopsInterface,
	zzagUnsubmitted Not Done Is m_desktops.last() the right one? It can be already deleted. For example, If user has two virtual desktops: Desktop 1 Pizza and he or she wants to delete virtual desktop called "Pizza", then Desktop 1 will be removed instead. zzag: Is m_desktops.last() the right one? It can be already deleted. For example, If user has two…
255		QStringLiteral("removeDesktop"));
256
257		call.setArguments({previous});
258
259		QDBusPendingCall pending = QDBusConnection::sessionBus().asyncCall(call);
260
261		const QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pending, this);
262		QObject::connect(watcher, &QDBusPendingCallWatcher::finished, this, callFinished);
263
264		return; // The change-handling slot will call syncWithServer() again,
265		// until everything is in sync.
266		}
267		}
268		}
269
270		// Sync ids.
271		m_desktops = m_serverSideDesktops;
272		emit dataChanged(index(0, 0), index(rowCount() - 1, 0), QVector<int>{Qt::DisplayRole});
273
274		// Sync names.
275		if (m_names != m_serverSideNames) {
276		QHashIterator<QString, QString> i(m_names);
277
278		while (i.hasNext()) {
279		i.next();
280
281		if (i.value() != m_serverSideNames.value(i.key())) {
282		auto call = QDBusMessage::createMethodCall(
283		s_serviceName,
284		s_virtDesktopsPath,
285		s_virtualDesktopsInterface,
286		QStringLiteral("setDesktopName"));
287
288		call.setArguments({i.key(), i.value()});
289
290		QDBusPendingCall pending = QDBusConnection::sessionBus().asyncCall(call);
291
292		const QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pending, this);
	zzagUnsubmitted Not Done Please indent it. zzag: Please indent it.
293		QObject::connect(watcher, &QDBusPendingCallWatcher::finished, this, callFinished);
294
295		break;
296		}
297		}
298
299		return; // The change-handling slot will call syncWithServer() again,
300		// until everything is in sync..
301		}
302
303		// Sync rows.
304		if (m_rows != m_serverSideRows) {
305		auto call = QDBusMessage::createMethodCall(
306		s_serviceName,
307		s_virtDesktopsPath,
308		s_fdoPropertiesInterface,
309		QStringLiteral("Set"));
310
311		call.setArguments({s_virtualDesktopsInterface,
312		QStringLiteral("rows"), QVariant::fromValue(QDBusVariant(QVariant((uint)m_rows)))});
313
314		QDBusPendingCall pending = QDBusConnection::sessionBus().asyncCall(call);
315
316		const QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pending, this);
317		QObject::connect(watcher, &QDBusPendingCallWatcher::finished, this, callFinished);
318		}
	zzagUnsubmitted Not Done You could also use `auto` here. ;-) zzag: You could also use `auto` here. ;-)
319		}
320
321		void DesktopsModel::initialize(const QDBusMessage &msg)
322		{
323		beginResetModel();
324
325		const QVariantMap &data = qdbus_cast<QVariantMap>(msg.arguments().at(0).value<QDBusArgument>());
326
327		const KWin::DBusDesktopDataVector &desktops = qdbus_cast<KWin::DBusDesktopDataVector>(
328		data.value(QStringLiteral("desktops")).value<QDBusArgument>()
329		);
330
331		m_serverSideRows = data.value(QStringLiteral("rows")).toUInt();
332		m_rows = m_serverSideRows;
333
334		for (const KWin::DBusDesktopDataStruct &d : desktops) {
335		m_serverSideDesktops.append(d.id);
336		m_desktops = m_serverSideDesktops;
337		m_serverSideNames[d.id] = d.name;
338		m_names = m_serverSideNames;
339		}
340
341		endResetModel();
342
343		emit readyChanged();
344
345		auto handleConnectionError = [this]() {
346		m_error = i18n("There was an error connecting to the compositor.");
347		emit errorChanged();
348		};
349
350		bool connected = QDBusConnection::sessionBus().connect(
351		s_serviceName,
352		s_virtDesktopsPath,
353		s_virtualDesktopsInterface,
354		QStringLiteral("desktopCreated"),
355		this,
356		SLOT(desktopCreated(QString,KWin::DBusDesktopDataStruct)));
357
358		if (!connected) {
359		handleConnectionError();
360
361		return;
362		}
363
364		connected = QDBusConnection::sessionBus().connect(
365		s_serviceName,
366		s_virtDesktopsPath,
367		s_virtualDesktopsInterface,
368		QStringLiteral("desktopRemoved"),
369		this,
370		SLOT(desktopRemoved(QString)));
371
372		if (!connected) {
373		handleConnectionError();
374
375		return;
376		}
377
378		connected = QDBusConnection::sessionBus().connect(
379		s_serviceName,
	zzagUnsubmitted Not Done Minor nitpick: In order to construct QString, we'll copy the QLatin1String (source). Maybe, use QStringLiteral instead? (Same with the QLatin1String down below) zzag: Minor nitpick: In order to construct QString, we'll copy the QLatin1String ([source](https…
380		s_virtDesktopsPath,
381		s_virtualDesktopsInterface,
382		QStringLiteral("desktopDataChanged"),
383		this,
384		SLOT(desktopDataChanged(QString,KWin::DBusDesktopDataStruct)));
385
	zzagUnsubmitted Not Done Minor nitpick: because that's a new code, maybe use range based for loop instead? zzag: Minor nitpick: because that's a new code, maybe use range based for loop instead?
386		if (!connected) {
387		handleConnectionError();
388
389		return;
390		}
391
392		connected = QDBusConnection::sessionBus().connect(
393		s_serviceName,
394		s_virtDesktopsPath,
395		s_virtualDesktopsInterface,
396		QStringLiteral("rowsChanged"),
397		this,
398		SLOT(desktopRowsChanged(uint)));
399
400		if (!connected) {
401		handleConnectionError();
402
403		return;
	davidedmundsonUnsubmitted Not Done but if it is userModified don't we need to update the ID to be the non-dummy value in case that entry is then later removed? davidedmundson: but if it is userModified don't we need to update the ID to be the non-dummy value in case that…
404		}
405		}
406
407		void DesktopsModel::desktopCreated(const QString &id, const KWin::DBusDesktopDataStruct &data)
408		{
409		m_serverSideDesktops.insert(data.position, id);
410		m_serverSideNames[data.id] = data.name;
411
412		// If the user didn't make any changes, we can just stay in sync.
413		if (!m_userModified) {
414		beginInsertRows(QModelIndex(), data.position, data.position);
	zzagUnsubmitted Not Done Is this right? If I remove a desktop in the KCM(without applying settings) and create a new one using the d-bus interface, the KCM will crash. zzag: Is this right? If I remove a desktop in the KCM(without applying settings) and create a new…
415
416		m_desktops = m_serverSideDesktops;
417		m_names = m_serverSideNames;
	davidedmundsonUnsubmitted Not Done needs a guard. could be emitted before the first load finishes davidedmundson: needs a guard. could be emitted before the first load finishes
	heinAuthorUnsubmitted Not Done I'll move the other connnects to the initialize slot. hein: I'll move the other connnects to the initialize slot.
	heinAuthorUnsubmitted Not Done Sorry for the above, I wrote it before updating the review but forgot to submit. hein: Sorry for the above, I wrote it before updating the review but forgot to submit.
418
419		endInsertRows();
420		} else {
421		// Remove dummy data.
422		const QString dummyId = m_desktops.at(data.position);
423		m_desktops[data.position] = id;
424		m_names.remove(dummyId);
425		m_names[id] = data.name;
426		const QModelIndex &idx = index(data.position, 0);
427		emit dataChanged(idx, idx, QVector<int>{Id});
428
429		checkModifiedState(/* server */ true);
430		}
431		}
432
433		void DesktopsModel::desktopRemoved(const QString &id)
434		{
435		const int desktopIndex = m_serverSideDesktops.indexOf(id);
436
437		m_serverSideDesktops.removeAt(desktopIndex);
438		m_serverSideNames.remove(id);
439
440		// If the user didn't make any changes, we can just stay in sync.
441		if (!m_userModified) {
442		beginRemoveRows(QModelIndex(), desktopIndex, desktopIndex);
443
444		m_desktops = m_serverSideDesktops;
445		m_names = m_serverSideNames;
446
447		endRemoveRows();
448		} else {
449		checkModifiedState(/* server */ true);
450		}
451		}
452
453		void DesktopsModel::desktopDataChanged(const QString &id, const KWin::DBusDesktopDataStruct &data)
454		{
455		const int desktopIndex = m_serverSideDesktops.indexOf(id);
456
457		m_serverSideDesktops[desktopIndex] = id;
458		m_serverSideNames[id] = data.name;
459
460		// If the user didn't make any changes, we can just stay in sync.
461		if (!m_userModified) {
462		m_desktops = m_serverSideDesktops;
463		m_names = m_serverSideNames;
464
465		const QModelIndex &idx = index(desktopIndex, 0);
466
467		dataChanged(idx, idx, QVector<int>{Qt::DisplayRole});
468		} else {
469		checkModifiedState(/* server */ true);
470		}
471		}
472
473		void DesktopsModel::desktopRowsChanged(uint rows)
474		{
475		// Unfortunately we sometimes get this signal from the server with an unchanged value.
476		if ((int)rows == m_serverSideRows) {
477		return;
478		}
479
480		m_serverSideRows = rows;
481
482		// If the user didn't make any changes, we can just stay in sync.
483		if (!m_userModified) {
484		m_rows = m_serverSideRows;
485
486		emit rowsChanged();
487		emit dataChanged(index(0, 0), index(m_desktops.count() - 1, 0), QVector<int>{DesktopRow});
488		} else {
489		checkModifiedState(/* server */ true);
490		}
491		}
492
493		void DesktopsModel::checkModifiedState(bool server)
494		{
495		if (m_desktops == m_serverSideDesktops
496		&& m_names == m_serverSideNames
497		&& m_rows == m_serverSideRows) {
498
499		m_userModified = false;
500		emit userModifiedChanged();
501
502		m_serverModified = false;
503		emit serverModifiedChanged();
504
505		emit needsSaving(false);
506
507		m_synchronizing = false;
508		} else {
509		if (m_synchronizing) {
510		m_serverModified = false;
511		emit serverModifiedChanged();
512
513		syncWithServer();
514		} else if (server) {
515		m_serverModified = true;
516		emit serverModifiedChanged();
517		} else {
518		m_userModified = true;
519		emit userModifiedChanged();
520
521		emit needsSaving(true);
522		}
523		}
524		}
525
526		void DesktopsModel::handleCallError()
527		{
528		if (m_synchronizing) {
529		m_synchronizing = false;
530
531		m_serverModified = false;
532		emit serverModifiedChanged();
533
534		m_error = i18n("There was an error saving the settings to the compositor.");
535		emit errorChanged();
536		} else {
537		m_error = i18n("There was an error requesting information from the compositor.");
538		emit errorChanged();
539		}
540		}
541
542		}