Differential D28141 Diff 78017 sensors/SensorTreeModel.cpp

Changeset View

Standalone View

View Options

sensors/SensorTreeModel.cpp

  • This file was added.
1​/*
2​ Copyright (c) 2019 Eike Hein <hein@kde.org>
3​ Copyright (C) 2020 Arjen Hiemstra <ahiemstra@heimr.nl>
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 "SensorTreeModel.h"
22​
23​#include <QDebug>
24​#include <QMimeData>
25​#include <QMetaEnum>
26​#include <KLocalizedString>
27​
28​#include "formatter/Formatter.h"
29​
30​#include "Sensor.h"
31​#include "SensorQuery.h"
32​#include "SensorInfo_p.h"
33​#include "SensorDaemonInterface_p.h"
34​
35​using namespace KSysGuard;
36​
37​struct Q_DECL_HIDDEN SensorTreeItem
38​{
39​ SensorTreeItem *parent = nullptr;
40​ QString name;
41​ QVector<SensorTreeItem *> children;
42​
43​ inline int indexOf(const QString &name)
44​ {
45​ int index = -1;
46​
47​ for (int i = 0; i < children.count(); ++i) {
48​ if (children.at(i)->name == name) {
49​ return i;
50​ }
51​ }
52​
53​ return index;
54​ }
55​
56​ ~SensorTreeItem() {
57​ qDeleteAll(children);
58​ }
59​};
60​
61​class Q_DECL_HIDDEN SensorTreeModel::Private
62​{
63​public:
64​ Private(SensorTreeModel *qq) : rootItem(new SensorTreeItem), q(qq) { }
65​ ~Private() { delete rootItem; }
66​
67​ SensorTreeItem *rootItem;
68​ QHash<SensorTreeItem *, SensorInfo> sensorInfos;
69​
70​ void addSensor(const QString &sensorId, const SensorInfo &info);
71​ void removeSensor(const QString &sensorId);
72​
73​ QString sensorId(const QModelIndex &index);
74​
75​ SensorTreeItem *find(const QString &sensorId);
76​
77​private:
78​ SensorTreeModel *q;
79​};
80​
81​void SensorTreeModel::Private::addSensor(const QString &sensorId, const SensorInfo &info)
82​{
83​ const QStringList &segments = sensorId.split(QLatin1Char('/'));
84​
85​ if (!segments.count()|| segments.at(0).isEmpty()) {
86​ qDebug() << "Rejecting sensor" << sensorId << "- sensor id is not well-formed.";
87​ return;
88​ }
89​
90​ SensorTreeItem *item = rootItem;
91​
92​ for (auto segment : segments) {
93​ int index = item->indexOf(segment);
94​
95​ if (index != -1) {
96​ item = item->children.at(index);
97​ } else {
98​ SensorTreeItem *newItem = new SensorTreeItem();
99​ newItem->parent = item;
100​ newItem->name = segment;
101​
102​ const QModelIndex &parentIndex = (item == rootItem) ? QModelIndex()
103​ : q->createIndex(item->parent->children.indexOf(item), 0, item);
104​ q->beginInsertRows(parentIndex, item->children.count(), item->children.count());
105​ item->children.append(newItem);
106​ q->endInsertRows();
107​
108​ item = newItem;
109​ }
110​ }
111​
112​ sensorInfos[item] = info;
113​}
114​
115​void SensorTreeModel::Private::removeSensor(const QString &sensorId)
116​{
117​ SensorTreeItem *item = rootItem;
118​
119​ const auto segments = sensorId.split(QLatin1Char('/'));
120​ for (const QString &segment : segments) {
121​ int index = item->indexOf(segment);
122​ Q_ASSERT(index != -1);
123​ item = item->children.at(index);
124​ }
125​
126​ SensorTreeItem *parent = item->parent;
127​
128​ if (!parent) {
129​ return;
130​ }
131​
132​ auto remove = [this](SensorTreeItem *item, SensorTreeItem *parent) {
133​ const int index = item->parent->children.indexOf(item);
134​
135​ const QModelIndex &parentIndex = (parent == rootItem) ? QModelIndex()
136​ : q->createIndex(parent->parent->children.indexOf(parent), 0, parent);
137​ q->beginRemoveRows(parentIndex, index, index);
138​ delete item->parent->children.takeAt(index);
139​ q->endRemoveRows();
140​
141​ sensorInfos.remove(item);
142​ };
143​
144​ remove(item, parent);
145​
146​ while (!parent->children.count()) {
147​ item = parent;
148​ parent = parent->parent;
149​
150​ if (!parent) {
151​ break;
152​ }
153​
154​ remove(item, parent);
155​ }
156​}
157​
158​QString SensorTreeModel::Private::sensorId(const QModelIndex &index)
159​{
160​ QStringList segments;
161​
162​ SensorTreeItem *item = static_cast<SensorTreeItem *>(index.internalPointer());
163​
164​ segments << item->name;
165​
166​ while (item->parent && item->parent != rootItem) {
167​ item = item->parent;
168​ segments.prepend(item->name);
169​ }
170​
171​ return segments.join(QLatin1Char('/'));
172​}
173​
174​SensorTreeItem *KSysGuard::SensorTreeModel::Private::find(const QString &sensorId)
175​{
176​ auto item = rootItem;
177​ const auto segments = sensorId.split(QLatin1Char('/'));
178​ for (const QString &segment : segments) {
179​ int index = item->indexOf(segment);
180​ if (index != -1) {
181​ item = item->children.at(index);
182​ } else {
183​ return nullptr;
184​ }
185​ }
186​ return item;
187​}
188​
189​SensorTreeModel::SensorTreeModel(QObject *parent)
190​ : QAbstractItemModel(parent)
191​ , d(new Private(this))
192​{
193​ connect(SensorDaemonInterface::instance(), &SensorDaemonInterface::sensorAdded, this, &SensorTreeModel::onSensorAdded);
194​ connect(SensorDaemonInterface::instance(), &SensorDaemonInterface::sensorRemoved, this, &SensorTreeModel::onSensorRemoved);
195​ connect(SensorDaemonInterface::instance(), &SensorDaemonInterface::metaDataChanged, this, &SensorTreeModel::onMetaDataChanged);
196​ init();
197​}
198​
199​SensorTreeModel::~SensorTreeModel()
200​{
201​}
202​
203​QHash<int, QByteArray> SensorTreeModel::roleNames() const
204​{
205​ QHash<int, QByteArray> roles = QAbstractItemModel::roleNames();
206​
207​ QMetaEnum e = metaObject()->enumerator(metaObject()->indexOfEnumerator("AdditionalRoles"));
208​
209​ for (int i = 0; i < e.keyCount(); ++i) {
210​ roles.insert(e.value(i), e.key(i));
211​ }
212​
213​ return roles;
214​}
215​
216​QVariant SensorTreeModel::headerData(int section, Qt::Orientation, int role) const
217​{
218​ if (role != Qt::DisplayRole) {
219​ return QVariant();
220​ }
221​
222​ if (section == 0) {
223​ return i18n("Sensor Browser");
224​ }
225​
226​ return QVariant();
227​}
228​
229​QStringList SensorTreeModel::mimeTypes() const
230​{
231​ return QStringList() << QStringLiteral("application/x-ksysguard");
232​}
233​
234​QVariant SensorTreeModel::data(const QModelIndex &index, int role) const
235​{
236​ const bool check = checkIndex(index, CheckIndexOption::IndexIsValid);
237​
238​ Q_ASSERT(check);
239​
240​ if (!check) {
241​ return QVariant();
242​ }
243​
244​ if (role == Qt::DisplayRole) {
245​ SensorTreeItem *item = static_cast<SensorTreeItem *>(index.internalPointer());
246​
247​ if (d->sensorInfos.contains(item)) {
248​ auto info = d->sensorInfos.value(item);
249​ const QString &unit = Formatter::symbol(info.unit);
250​
251​ if (!unit.isEmpty()) {
252​ return i18nc("Name (unit)", "%1 (%2)", info.name, unit);
253​ }
254​
255​ return info.name;
256​ }
257​
258​ const QString &name = item->name;
259​ if (name.isEmpty()) {
260​ return i18n("EMPTY");
261​ } else {
262​ return name;
263​ }
264​ // Only leaf nodes are valid sensors
265​ } else if (role == SensorId) {
266​ if (rowCount(index)) {
267​ return QString();
268​ } else {
269​ return d->sensorId(index);
270​ }
271​ }
272​
273​ return QVariant();
274​}
275​
276​QMimeData *SensorTreeModel::mimeData(const QModelIndexList &indexes) const
277​{
278​ QMimeData *mimeData = new QMimeData();
279​
280​ if (indexes.count() != 1) {
281​ return mimeData;
282​ }
283​
284​ const QModelIndex &index = indexes.at(0);
285​
286​ const bool check = checkIndex(index, CheckIndexOption::IndexIsValid);
287​
288​ Q_ASSERT(check);
289​
290​ if (!check) {
291​ return mimeData;
292​ }
293​
294​ if (rowCount(index)) {
295​ return mimeData;
296​ }
297​
298​ mimeData->setData(QStringLiteral("application/x-ksysguard"), d->sensorId(index).toUtf8());
299​
300​ return mimeData;
301​}
302​
303​Qt::ItemFlags SensorTreeModel::flags(const QModelIndex &index) const
304​{
305​ const bool check = checkIndex(index, CheckIndexOption::IndexIsValid | CheckIndexOption::DoNotUseParent);
306​
307​ Q_ASSERT(check);
308​
309​ if (!check) {
310​ return Qt::NoItemFlags;
311​ }
312​
313​ if (!rowCount(index)) {
314​ return Qt::ItemIsDragEnabled | Qt::ItemIsSelectable | Qt::ItemIsEnabled;
315​ }
316​
317​ return Qt::ItemIsEnabled;
318​}
319​
320​int SensorTreeModel::rowCount(const QModelIndex &parent) const
321​{
322​ if (parent.isValid()) {
323​ const bool check = checkIndex(parent, CheckIndexOption::IndexIsValid | CheckIndexOption::DoNotUseParent);
324​
325​ Q_ASSERT(check);
326​
327​ if (!check) {
328​ return 0;
329​ }
330​
331​ const SensorTreeItem *item = static_cast<SensorTreeItem *>(parent.internalPointer());
332​ return item->children.count();
333​ }
334​
335​ return d->rootItem->children.count();
336​}
337​
338​int SensorTreeModel::columnCount(const QModelIndex &parent) const
339​{
340​ Q_UNUSED(parent)
341​
342​ return 1;
343​}
344​
345​QModelIndex SensorTreeModel::index(int row, int column, const QModelIndex &parent) const
346​{
347​ SensorTreeItem *parentItem = d->rootItem;
348​
349​ if (parent.isValid()) {
350​ Q_ASSERT(parent.model() == this);
351​
352​ if (parent.model() != this) {
353​ return QModelIndex();
354​ }
355​
356​ parentItem = static_cast<SensorTreeItem *>(parent.internalPointer());
357​ }
358​
359​ if (row < 0 || row >= parentItem->children.count()) {
360​ return QModelIndex();
361​ }
362​
363​ if (column < 0) {
364​ return QModelIndex();
365​ }
366​
367​ return createIndex(row, column, parentItem->children.at(row));
368​}
369​
370​QModelIndex SensorTreeModel::parent(const QModelIndex &index) const
371​{
372​ const bool check = checkIndex(index, CheckIndexOption::IndexIsValid | CheckIndexOption::DoNotUseParent);
373​
374​ Q_ASSERT(check);
375​
376​ if (!check) {
377​ return QModelIndex();
378​ }
379​
380​ if (index.column() > 0) {
381​ return QModelIndex();
382​ }
383​
384​ const SensorTreeItem *item = static_cast<SensorTreeItem *>(index.internalPointer());
385​ SensorTreeItem *parentItem = item->parent;
386​
387​ if (parentItem == d->rootItem) {
388​ return QModelIndex();
389​ }
390​
391​ return createIndex(parentItem->parent->children.indexOf(parentItem), 0, parentItem);
392​}
393​
394​void SensorTreeModel::init()
395​{
396​ auto query = new SensorQuery{QString(), this};
397​ connect(query, &SensorQuery::finished, [query, this]() {
398​ query->deleteLater();
399​ const auto result = query->result();
400​ for (auto pair : result) {
401​ d->addSensor(pair.first, pair.second);
402​ }
403​ });
404​ query->execute();
405​}
406​
407​void KSysGuard::SensorTreeModel::onSensorAdded(const QString &sensor)
408​{
409​ SensorDaemonInterface::instance()->requestMetaData(sensor);
410​}
411​
412​void KSysGuard::SensorTreeModel::onSensorRemoved(const QString &sensor)
413​{
414​ d->removeSensor(sensor);
415​}
416​
417​void KSysGuard::SensorTreeModel::onMetaDataChanged(const QString &sensorId, const SensorInfo &info)
418​{
419​ auto item = d->find(sensorId);
420​ if (!item) {
421​ d->addSensor(sensorId, info);
422​ } else {
423​ item->name = info.name;
424​ d->sensorInfos[item] = info;
425​
426​ auto parentItem = item->parent;
427​ if (!parentItem) {
428​ return;
429​ }
430​
431​ auto parentIndex = QModelIndex{};
432​ if (parentItem != d->rootItem) {
433​ parentIndex = createIndex(parentItem->parent->children.indexOf(parentItem), 0, parentItem);
434​ }
435​
436​ auto itemIndex = index(parentItem->children.indexOf(item), 0, parentIndex);
437​ Q_EMIT dataChanged(itemIndex, itemIndex);
438​ }
439​}