Differential D14542 Diff 39009 kcmkwin/kwindesktopng/desktopsmodel.cpp

Changeset View

Standalone View

View Options

kcmkwin/kwindesktopng/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 <QDebug>
26​#include <QDBusArgument>
27​#include <QDBusConnection>
28​#include <QDBusMessage>
29​#include <QDBusMetaType>
30​#include <QDBusPendingCall>
31​#include <QDBusVariant>
32​#include <QMetaEnum>
33​
34​namespace KWin {
35​
36​static const QString s_serviceName(QStringLiteral("org.kde.KWin"));
37​static const QString s_virtualDesktopsInterface(QStringLiteral("org.kde.KWin.VirtualDesktopManager"));
38​static const QString s_virtDesktopsPath(QStringLiteral("/VirtualDesktopManager"));
39​static const QString s_fdoPropertiesInterface(QStringLiteral("org.freedesktop.DBus.Properties"));
40​
41​DesktopsModel::DesktopsModel(QObject *parent)
42​ : QAbstractListModel(parent)
43​ , m_rows(-1)
44​{
45​ qDBusRegisterMetaType<KWin::DBusDesktopDataStruct>();
46​ qDBusRegisterMetaType<KWin::DBusDesktopDataVector>();
47​
48​ auto handleConnectionError = [this]() {
49​ m_error = i18n("There was an error connecting to the compositor.");
50​ emit errorChanged();
51​ };
52​
53​ bool connected = QDBusConnection::sessionBus().connect(
davidedmundsonUnsubmitted
Not Done

We can just generate the interface from the XML and use the generated class instead of using low level classes.

davidedmundson: We can just generate the interface from the XML and use the generated class instead of using…
heinAuthorUnsubmitted
Not Done

I have no preference here. Marco's patch currently doesn't provide an XML file, though.

hein: I have no preference here. Marco's patch currently doesn't provide an XML file, though.
54​ s_serviceName,
55​ s_virtDesktopsPath,
56​ s_virtualDesktopsInterface,
57​ QStringLiteral("desktopCreated"),
58​ this,
59​ SLOT(desktopCreated(QString,KWin::DBusDesktopDataStruct)));
60​
61​ if (!connected) {
62​ handleConnectionError();
63​
64​ return;
65​ }
66​
67​ connected = QDBusConnection::sessionBus().connect(
68​ s_serviceName,
69​ s_virtDesktopsPath,
70​ s_virtualDesktopsInterface,
71​ QStringLiteral("desktopRemoved"),
72​ this,
73​ SLOT(desktopRemoved(QString)));
74​
75​ if (!connected) {
76​ handleConnectionError();
77​
78​ return;
79​ }
martUnsubmitted
Not Done

all of this, static values

mart: all of this, static values
80​
81​ connected = QDBusConnection::sessionBus().connect(
82​ s_serviceName,
83​ s_virtDesktopsPath,
84​ s_virtualDesktopsInterface,
85​ QStringLiteral("desktopDataChanged"),
86​ this,
87​ SLOT(desktopDataChanged(QString,KWin::DBusDesktopDataStruct)));
88​
89​ if (!connected) {
90​ handleConnectionError();
91​
92​ return;
93​ }
broulikUnsubmitted
Not Done

Architectural question: why don't you go the standard org.freedesktop.DBus.Properties.PropertiesChanged way?

broulik: Architectural question: why don't you go the standard `org.freedesktop.DBus.Properties.
heinAuthorUnsubmitted
Not Done

No deeper reason. Marco added an additional rowsChanged I guess.

hein: No deeper reason. Marco added an additional rowsChanged I guess.
94​
95​ connected = QDBusConnection::sessionBus().connect(
96​ s_serviceName,
97​ s_virtDesktopsPath,
98​ s_virtualDesktopsInterface,
99​ QStringLiteral("rowsChanged"),
100​ this,
101​ SLOT(desktopRowsChanged(uint)));
102​
103​ if (!connected) {
104​ handleConnectionError();
105​
106​ return;
broulikUnsubmitted
Not Done

Can you put a couple of static QStrings somewhere to avoid copy-pasting this all over?

broulik: Can you put a couple of static `QString`s somewhere to avoid copy-pasting this all over?
107​ }
martUnsubmitted
Not Done

one way that I would love this thing to work (and how i designed it to be used as)
is with GetAll, which minimizes absolutely the roundtrips (the amount of data, even if useless passing is not an issue at all, the number of calls is)

It's very type unsafe, which sn't great, tough you are sure you get the whole initial state in one go.

Look at plasma-workspace/dataengines/statusnotifieritem/statusnotifieritemsource.cpp performrefresh() and refreshcallback()

In this case the whole getall would be needed only at start (and eventually when the service goes down/gets back up) as all the signals carry all the needed data to keep it in sync.

mart: one way that I would love this thing to work (and how i designed it to be used as) is with…
108​
109​ auto initializeCall = QDBusMessage::createMethodCall(
110​ s_serviceName,
111​ s_virtDesktopsPath,
112​ s_fdoPropertiesInterface,
113​ QStringLiteral("GetAll"));
114​
115​ initializeCall.setArguments({s_virtualDesktopsInterface});
116​
117​ QDBusConnection::sessionBus().callWithCallback(
118​ initializeCall,
119​ this,
120​ SLOT(initialize(QDBusMessage)),
121​ SLOT(handleCallError()));
122​}
123​
124​DesktopsModel::~DesktopsModel()
125​{
126​}
127​
128​QHash<int, QByteArray> DesktopsModel::roleNames() const
129​{
130​ QHash<int, QByteArray> roles = QAbstractItemModel::roleNames();
131​
132​ QMetaEnum e = metaObject()->enumerator(metaObject()->indexOfEnumerator("AdditionalRoles"));
133​
134​ for (int i = 0; i < e.keyCount(); ++i) {
135​ roles.insert(e.value(i), e.key(i));
136​ }
137​
138​ return roles;
139​}
140​
141​QVariant DesktopsModel::data(const QModelIndex &index, int role) const
142​{
143​ if (!index.isValid() || index.row() < 0 || index.row() > (m_desktops.count() - 1)) {
144​ return QVariant();
145​ }
146​
147​ if (role == Qt::DisplayRole) {
148​ return m_names.value(m_desktops.at(index.row()));
149​ } else if (role == Id) {
150​ return m_desktops.at(index.row());
151​ } else if (role == DesktopRow) {
152​ const int rows = std::max(m_rows, 1);
153​ const int perRow = std::ceil((qreal)m_desktops.count() / (qreal)rows);
154​
155​ return (index.row() / perRow) + 1;
156​
157​ }
158​
159​ return QVariant();
160​}
161​
162​int DesktopsModel::rowCount(const QModelIndex &parent) const
163​{
164​ if (parent.isValid()) {
165​ return 0;
166​ }
broulikUnsubmitted
Not Done

m_rows can potentially be 0 here

broulik: `m_rows` can potentially be `0` here
167​
168​ return m_desktops.count();
169​}
170​
171​bool DesktopsModel::ready() const
172​{
173​ return !m_desktops.isEmpty();
174​}
175​
176​QString DesktopsModel::error() const
177​{
178​ return m_error;
179​}
180​
181​int DesktopsModel::rows() const
182​{
183​ return m_rows;
184​}
185​
186​void DesktopsModel::setRows(int rows)
187​{
188​ if (!ready() || rows < 1) {
189​ return;
190​ }
191​
192​ auto call = QDBusMessage::createMethodCall(
193​ s_serviceName,
194​ s_virtDesktopsPath,
195​ s_fdoPropertiesInterface,
196​ QStringLiteral("Set"));
197​
198​ call.setArguments({s_virtualDesktopsInterface,
199​ QStringLiteral("rows"), QVariant::fromValue(QDBusVariant(QVariant((uint)rows)))});
200​
201​ QDBusConnection::sessionBus().asyncCall(call);
202​}
203​
204​void DesktopsModel::createDesktop(const QString &name)
205​{
206​ if (!ready()) {
207​ return;
208​ }
209​
210​ auto call = QDBusMessage::createMethodCall(
211​ s_serviceName,
212​ s_virtDesktopsPath,
213​ s_virtualDesktopsInterface,
214​ QStringLiteral("createDesktop"));
215​
216​ // FIXME TODO: Positions are currently not zero- but one-indexed in KWin it seems.
217​ call.setArguments({(uint)m_desktops.count() + 1, name});
218​
219​ QDBusConnection::sessionBus().asyncCall(call);
220​}
221​
222​void DesktopsModel::removeDesktop(const QString &id)
223​{
224​ if (!ready() || !m_desktops.contains(id)) {
225​ return;
226​ }
227​
228​ auto call = QDBusMessage::createMethodCall(
229​ s_serviceName,
230​ s_virtDesktopsPath,
231​ s_virtualDesktopsInterface,
232​ QStringLiteral("removeDesktop"));
233​
234​ call.setArguments({id});
235​
236​ QDBusConnection::sessionBus().asyncCall(call);
237​}
238​
239​void DesktopsModel::setDesktopName(const QString &id, const QString &name)
240​{
241​ if (!ready() || !m_desktops.contains(id)) {
242​ return;
243​ }
244​
245​ auto call = QDBusMessage::createMethodCall(
246​ s_serviceName,
247​ s_virtDesktopsPath,
248​ s_virtualDesktopsInterface,
249​ QStringLiteral("setDesktopName"));
250​
251​ call.setArguments({id, name});
252​
253​ QDBusConnection::sessionBus().asyncCall(call);
254​}
255​
256​void DesktopsModel::initialize(const QDBusMessage &msg)
257​{
258​ beginResetModel();
259​
260​ const QVariantMap &data = qdbus_cast<QVariantMap>(msg.arguments().at(0).value<QDBusArgument>());
261​
262​ const KWin::DBusDesktopDataVector &desktops = qdbus_cast<KWin::DBusDesktopDataVector>(
263​ data.value(QLatin1String("desktops")).value<QDBusArgument>()
264​ );
265​
266​ m_rows = data.value(QLatin1String("rows")).toUInt();
267​
268​ foreach(const KWin::DBusDesktopDataStruct &d, desktops) {
269​ m_desktops.append(d.id);
270​ m_names[d.id] = d.name;
271​ }
272​
273​ endResetModel();
274​
275​ emit readyChanged();
276​}
277​
278​void DesktopsModel::desktopCreated(const QString &id, const KWin::DBusDesktopDataStruct &data)
279​{
280​ // FIXME TODO: We don't get an insert index from the API, so for now
281​ // we always append.
282​
283​ beginInsertRows(QModelIndex(), m_desktops.count(), m_desktops.count());
284​
285​ m_desktops.append(id);
286​ m_names[data.id] = data.name;
287​
288​ endInsertRows();
289​}
290​
291​void DesktopsModel::desktopRemoved(const QString &id)
292​{
293​ const int desktopIndex = m_desktops.indexOf(id);
294​
295​ beginRemoveRows(QModelIndex(), desktopIndex, desktopIndex);
296​
martUnsubmitted
Not Done

this is for retrocompatibility with x11 desktops, where they are 1 indexed for some obscure reason.
1 has been kept elsewhere to not make kwin code even more confusing and error prone

mart: this is for retrocompatibility with x11 desktops, where they are 1 indexed for some obscure…
297​ m_desktops.removeAt(desktopIndex);
298​ m_names.remove(id);
299​
300​ endRemoveRows();
301​}
302​
303​void DesktopsModel::desktopDataChanged(const QString &id, const KWin::DBusDesktopDataStruct &data)
304​{
305​ const int desktopIndex = m_desktops.indexOf(id);
306​
307​ m_desktops[desktopIndex] = id;
308​ m_names[id] = data.name;
309​
310​ const QModelIndex &idx = index(desktopIndex, 0);
311​
312​ dataChanged(idx, idx, QVector<int>{Qt::DisplayRole});
313​}
314​
315​void DesktopsModel::desktopRowsChanged(uint rows)
316​{
317​ m_rows = rows;
318​
319​ emit rowsChanged();
320​ emit dataChanged(index(0, 0), index(m_desktops.count() - 1, 0), QVector<int>{DesktopRow});
321​}
322​
323​void DesktopsModel::handleCallError()
324​{
325​ m_error = i18n("There was an error requesting information from the compositor.");
326​ emit errorChanged();
327​}
328​
329​}
330​
331​const QDBusArgument &operator<<(QDBusArgument &argument, const KWin::DBusDesktopDataStruct &desk)
332​{
333​ argument.beginStructure();
334​ argument << desk.x11DesktopNumber;
335​ argument << desk.id;
336​ argument << desk.name;
337​ argument.endStructure();
338​ return argument;
339​}
340​
341​const QDBusArgument &operator>>(const QDBusArgument &argument, KWin::DBusDesktopDataStruct &desk)
342​{
343​ argument.beginStructure();
344​ argument >> desk.x11DesktopNumber;
345​ argument >> desk.id;
346​ argument >> desk.name;
347​ argument.endStructure();
348​ return argument;
349​}
350​
351​const QDBusArgument &operator<<(QDBusArgument &argument, const KWin::DBusDesktopDataVector &deskVector)
352​{
353​ argument.beginArray(qMetaTypeId<KWin::DBusDesktopDataStruct>());
354​ for (int i = 0; i < deskVector.size(); ++i) {
355​ argument << deskVector[i];
356​ }
357​ argument.endArray();
358​ return argument;
359​}
360​
361​const QDBusArgument &operator>>(const QDBusArgument &argument, KWin::DBusDesktopDataVector &deskVector)
davidedmundsonUnsubmitted
Not Done

All this is already in the kwin repo for Marco's export. We should share code here even if it means including a C++ file from outside the kcmkwin dir.

davidedmundson: All this is already in the kwin repo for Marco's export. We should share code here even if it…
heinAuthorUnsubmitted
Not Done

This was mentioned in the commit message, too. I want Marco to do this refactoring.

hein: This was mentioned in the commit message, too. I want Marco to do this refactoring.
362​{
363​ argument.beginArray();
364​ deskVector.clear();
365​
366​ while (!argument.atEnd()) {
367​ KWin::DBusDesktopDataStruct element;
368​ argument >> element;
369​ deskVector.append(element);
370​ }
371​
372​ argument.endArray();
373​
374​ return argument;
375​}