Differential D14542 Diff 39008 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 library is free software; you can redistribute it and/or
6​ * modify it under the terms of the GNU Library General Public
7​ * License as published by the Free Software Foundation; either
8​ * version 2 of the License, or (at your option) any later version.
9​ *
10​ * This library 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 GNU
13​ * Library General Public License for more details.
14​ *
15​ * You should have received a copy of the GNU Library General Public License
16​ * along with this library; see the file COPYING.LIB. If not, write to
17​ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18​ * Boston, MA 02110-1301, USA.
19​ */
20​
21​#include "desktopsmodel.h"
22​
23​#include <cmath>
24​
25​#include <KLocalizedString>
26​
27​#include <QDebug>
28​#include <QDBusArgument>
29​#include <QDBusConnection>
30​#include <QDBusMessage>
31​#include <QDBusMetaType>
32​#include <QDBusPendingCall>
33​#include <QDBusVariant>
34​#include <QMetaEnum>
35​
36​namespace KWin {
37​
38​static const QString s_serviceName(QStringLiteral("org.kde.KWin"));
39​static const QString s_virtualDesktopsInterface(QStringLiteral("org.kde.KWin.VirtualDesktopManager"));
40​static const QString s_virtDesktopsPath(QStringLiteral("/VirtualDesktopManager"));
41​static const QString s_fdoPropertiesInterface(QStringLiteral("org.freedesktop.DBus.Properties"));
42​
43​DesktopsModel::DesktopsModel(QObject *parent)
44​ : QAbstractListModel(parent)
45​ , m_rows(-1)
46​{
47​ qDBusRegisterMetaType<KWin::DBusDesktopDataStruct>();
48​ qDBusRegisterMetaType<KWin::DBusDesktopDataVector>();
49​
50​ auto handleConnectionError = [this]() {
51​ m_error = i18n("There was an error connecting to the compositor.");
52​ emit errorChanged();
53​ };
54​
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.
55​ bool connected = QDBusConnection::sessionBus().connect(
56​ s_serviceName,
57​ s_virtDesktopsPath,
58​ s_virtualDesktopsInterface,
59​ QStringLiteral("desktopCreated"),
60​ this,
61​ SLOT(desktopCreated(QString,KWin::DBusDesktopDataStruct)));
62​
63​ if (!connected) {
64​ handleConnectionError();
65​
66​ return;
67​ }
68​
69​ connected = QDBusConnection::sessionBus().connect(
70​ s_serviceName,
71​ s_virtDesktopsPath,
72​ s_virtualDesktopsInterface,
73​ QStringLiteral("desktopRemoved"),
74​ this,
75​ SLOT(desktopRemoved(QString)));
76​
77​ if (!connected) {
78​ handleConnectionError();
79​
martUnsubmitted
Not Done

all of this, static values

mart: all of this, static values
80​ return;
81​ }
82​
83​ connected = QDBusConnection::sessionBus().connect(
84​ s_serviceName,
85​ s_virtDesktopsPath,
86​ s_virtualDesktopsInterface,
87​ QStringLiteral("desktopDataChanged"),
88​ this,
89​ SLOT(desktopDataChanged(QString,KWin::DBusDesktopDataStruct)));
90​
91​ if (!connected) {
92​ handleConnectionError();
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​ return;
95​ }
96​
97​ connected = QDBusConnection::sessionBus().connect(
98​ s_serviceName,
99​ s_virtDesktopsPath,
100​ s_virtualDesktopsInterface,
101​ QStringLiteral("rowsChanged"),
102​ this,
103​ SLOT(desktopRowsChanged(uint)));
104​
105​ if (!connected) {
106​ handleConnectionError();
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​ return;
109​ }
110​
111​ auto initializeCall = QDBusMessage::createMethodCall(
112​ s_serviceName,
113​ s_virtDesktopsPath,
114​ s_fdoPropertiesInterface,
115​ QStringLiteral("GetAll"));
116​
117​ initializeCall.setArguments({s_virtualDesktopsInterface});
118​
119​ QDBusConnection::sessionBus().callWithCallback(
120​ initializeCall,
121​ this,
122​ SLOT(initialize(QDBusMessage)),
123​ SLOT(handleCallError()));
124​}
125​
126​DesktopsModel::~DesktopsModel()
127​{
128​}
129​
130​QHash<int, QByteArray> DesktopsModel::roleNames() const
131​{
132​ QHash<int, QByteArray> roles = QAbstractItemModel::roleNames();
133​
134​ QMetaEnum e = metaObject()->enumerator(metaObject()->indexOfEnumerator("AdditionalRoles"));
135​
136​ for (int i = 0; i < e.keyCount(); ++i) {
137​ roles.insert(e.value(i), e.key(i));
138​ }
139​
140​ return roles;
141​}
142​
143​QVariant DesktopsModel::data(const QModelIndex &index, int role) const
144​{
145​ if (!index.isValid() || index.row() < 0 || index.row() > (m_desktops.count() - 1)) {
146​ return QVariant();
147​ }
148​
149​ if (role == Qt::DisplayRole) {
150​ return m_names.value(m_desktops.at(index.row()));
151​ } else if (role == Id) {
152​ return m_desktops.at(index.row());
153​ } else if (role == DesktopRow) {
154​ const int rows = std::max(m_rows, 1);
155​ const int perRow = std::ceil((qreal)m_desktops.count() / (qreal)rows);
156​
157​ return (index.row() / perRow) + 1;
158​
159​ }
160​
161​ return QVariant();
162​}
163​
164​int DesktopsModel::rowCount(const QModelIndex &parent) const
165​{
166​ if (parent.isValid()) {
broulikUnsubmitted
Not Done

m_rows can potentially be 0 here

broulik: `m_rows` can potentially be `0` here
167​ return 0;
168​ }
169​
170​ return m_desktops.count();
171​}
172​
173​bool DesktopsModel::ready() const
174​{
175​ return !m_desktops.isEmpty();
176​}
177​
178​QString DesktopsModel::error() const
179​{
180​ return m_error;
181​}
182​
183​int DesktopsModel::rows() const
184​{
185​ return m_rows;
186​}
187​
188​void DesktopsModel::setRows(int rows)
189​{
190​ if (!ready() || rows < 1) {
191​ return;
192​ }
193​
194​ auto call = QDBusMessage::createMethodCall(
195​ s_serviceName,
196​ s_virtDesktopsPath,
197​ s_fdoPropertiesInterface,
198​ QStringLiteral("Set"));
199​
200​ call.setArguments({s_virtualDesktopsInterface,
201​ QStringLiteral("rows"), QVariant::fromValue(QDBusVariant(QVariant((uint)rows)))});
202​
203​ QDBusConnection::sessionBus().asyncCall(call);
204​}
205​
206​void DesktopsModel::createDesktop(const QString &name)
207​{
208​ if (!ready()) {
209​ return;
210​ }
211​
212​ auto call = QDBusMessage::createMethodCall(
213​ s_serviceName,
214​ s_virtDesktopsPath,
215​ s_virtualDesktopsInterface,
216​ QStringLiteral("createDesktop"));
217​
218​ // FIXME TODO: Positions are currently not zero- but one-indexed in KWin it seems.
219​ call.setArguments({(uint)m_desktops.count() + 1, name});
220​
221​ QDBusConnection::sessionBus().asyncCall(call);
222​}
223​
224​void DesktopsModel::removeDesktop(const QString &id)
225​{
226​ if (!ready() || !m_desktops.contains(id)) {
227​ return;
228​ }
229​
230​ auto call = QDBusMessage::createMethodCall(
231​ s_serviceName,
232​ s_virtDesktopsPath,
233​ s_virtualDesktopsInterface,
234​ QStringLiteral("removeDesktop"));
235​
236​ call.setArguments({id});
237​
238​ QDBusConnection::sessionBus().asyncCall(call);
239​}
240​
241​void DesktopsModel::setDesktopName(const QString &id, const QString &name)
242​{
243​ if (!ready() || !m_desktops.contains(id)) {
244​ return;
245​ }
246​
247​ auto call = QDBusMessage::createMethodCall(
248​ s_serviceName,
249​ s_virtDesktopsPath,
250​ s_virtualDesktopsInterface,
251​ QStringLiteral("setDesktopName"));
252​
253​ call.setArguments({id, name});
254​
255​ QDBusConnection::sessionBus().asyncCall(call);
256​}
257​
258​void DesktopsModel::initialize(const QDBusMessage &msg)
259​{
260​ beginResetModel();
261​
262​ const QVariantMap &data = qdbus_cast<QVariantMap>(msg.arguments().at(0).value<QDBusArgument>());
263​
264​ const KWin::DBusDesktopDataVector &desktops = qdbus_cast<KWin::DBusDesktopDataVector>(
265​ data.value(QLatin1String("desktops")).value<QDBusArgument>()
266​ );
267​
268​ m_rows = data.value(QLatin1String("rows")).toUInt();
269​
270​ foreach(const KWin::DBusDesktopDataStruct &d, desktops) {
271​ m_desktops.append(d.id);
272​ m_names[d.id] = d.name;
273​ }
274​
275​ endResetModel();
276​
277​ emit readyChanged();
278​}
279​
280​void DesktopsModel::desktopCreated(const QString &id, const KWin::DBusDesktopDataStruct &data)
281​{
282​ // FIXME TODO: We don't get an insert index from the API, so for now
283​ // we always append.
284​
285​ beginInsertRows(QModelIndex(), m_desktops.count(), m_desktops.count());
286​
287​ m_desktops.append(id);
288​ m_names[data.id] = data.name;
289​
290​ endInsertRows();
291​}
292​
293​void DesktopsModel::desktopRemoved(const QString &id)
294​{
295​ const int desktopIndex = m_desktops.indexOf(id);
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​ beginRemoveRows(QModelIndex(), desktopIndex, desktopIndex);
298​
299​ m_desktops.removeAt(desktopIndex);
300​ m_names.remove(id);
301​
302​ endRemoveRows();
303​}
304​
305​void DesktopsModel::desktopDataChanged(const QString &id, const KWin::DBusDesktopDataStruct &data)
306​{
307​ const int desktopIndex = m_desktops.indexOf(id);
308​
309​ m_desktops[desktopIndex] = id;
310​ m_names[id] = data.name;
311​
312​ const QModelIndex &idx = index(desktopIndex, 0);
313​
314​ dataChanged(idx, idx, QVector<int>{Qt::DisplayRole});
315​}
316​
317​void DesktopsModel::desktopRowsChanged(uint rows)
318​{
319​ m_rows = rows;
320​
321​ emit rowsChanged();
322​ emit dataChanged(index(0, 0), index(m_desktops.count() - 1, 0), QVector<int>{DesktopRow});
323​}
324​
325​void DesktopsModel::handleCallError()
326​{
327​ m_error = i18n("There was an error requesting information from the compositor.");
328​ emit errorChanged();
329​}
330​
331​}
332​
333​const QDBusArgument &operator<<(QDBusArgument &argument, const KWin::DBusDesktopDataStruct &desk)
334​{
335​ argument.beginStructure();
336​ argument << desk.x11DesktopNumber;
337​ argument << desk.id;
338​ argument << desk.name;
339​ argument.endStructure();
340​ return argument;
341​}
342​
343​const QDBusArgument &operator>>(const QDBusArgument &argument, KWin::DBusDesktopDataStruct &desk)
344​{
345​ argument.beginStructure();
346​ argument >> desk.x11DesktopNumber;
347​ argument >> desk.id;
348​ argument >> desk.name;
349​ argument.endStructure();
350​ return argument;
351​}
352​
353​const QDBusArgument &operator<<(QDBusArgument &argument, const KWin::DBusDesktopDataVector &deskVector)
354​{
355​ argument.beginArray(qMetaTypeId<KWin::DBusDesktopDataStruct>());
356​ for (int i = 0; i < deskVector.size(); ++i) {
357​ argument << deskVector[i];
358​ }
359​ argument.endArray();
360​ return argument;
361​}
362​
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.
363​const QDBusArgument &operator>>(const QDBusArgument &argument, KWin::DBusDesktopDataVector &deskVector)
364​{
365​ argument.beginArray();
366​ deskVector.clear();
367​
368​ while (!argument.atEnd()) {
369​ KWin::DBusDesktopDataStruct element;
370​ argument >> element;
371​ deskVector.append(element);
372​ }
373​
374​ argument.endArray();
375​
376​ return argument;
377​}