Differential D28922 Diff 82289 faces/SensorFaceController.cpp

Changeset View

Standalone View

View Options

faces/SensorFaceController.cpp

  • This file was added.
1​/*
2​ Copyright (C) 2020 Marco Martin <mart@kde.org>
3​
4​ This library is free software; you can redistribute it and/or
5​ modify it under the terms of the GNU Library General Public
6​ License as published by the Free Software Foundation; either
7​ version 2 of the License, or (at your option) any later version.
8​
9​ This library is distributed in the hope that it will be useful,
10​ but WITHOUT ANY WARRANTY; without even the implied warranty of
11​ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12​ Library General Public License for more details.
13​
14​ You should have received a copy of the GNU Library General Public License
15​ along with this library; see the file COPYING.LIB. If not, write to
16​ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17​ Boston, MA 02110-1301, USA.
18​*/
19​
20​#include "SensorFaceController.h"
21​#include "SensorFaceController_p.h"
22​#include "SensorFace_p.h"
23​#include <SensorQuery.h>
24​
25​#include <QtQml>
26​#include <QDebug>
27​
28​#include <KDesktopFile>
29​#include <KDeclarative/ConfigPropertyMap>
30​#include <KPackage/PackageLoader>
31​#include <KLocalizedString>
32​#include <KConfigLoader>
33​#include <KPluginMetaData>
34​
35​using namespace KSysGuard;
36​
37​FacesModel::FacesModel(QObject *parent)
38​ : QStandardItemModel(parent)
39​{
40​ reload();
41​}
42​
43​void FacesModel::reload()
44​{
ahiemstraUnsubmitted
Done

"Plasma/SensorApplet" should probably be changed to something non-plasma?

ahiemstra: "Plasma/SensorApplet" should probably be changed to something non-plasma?
45​ clear();
46​
47​ auto list = KPackage::PackageLoader::self()->listPackages(QStringLiteral("KSysguard/SensorFace"));
48​ // NOTE: This will disable completely the internal in-memory cache
49​ KPackage::Package p;
50​ p.install(QString(), QString());
51​
52​ for (auto plugin : list) {
53​ QStandardItem *item = new QStandardItem(plugin.name());
54​ item->setData(plugin.pluginId(), FacesModel::PluginIdRole);
55​ appendRow(item);
56​ }
57​}
58​
59​QString FacesModel::pluginId(int row)
60​{
61​ return data(index(row, 0), PluginIdRole).toString();
62​}
63​
64​QHash<int, QByteArray> FacesModel::roleNames() const
65​{
66​ QHash<int, QByteArray> roles = QAbstractItemModel::roleNames();
67​
68​ roles[PluginIdRole] = "pluginId";
69​ return roles;
70​}
71​
72​PresetsModel::PresetsModel(QObject *parent)
73​ : QStandardItemModel(parent)
74​{
75​ reload();
76​}
77​
78​void PresetsModel::reload()
ahiemstraUnsubmitted
Not Done

Similar to above, does it still make sense to use "Plasma/Applet" here?

ahiemstra: Similar to above, does it still make sense to use "Plasma/Applet" here?
martAuthorUnsubmitted
Not Done

it kinda has to, as the original idea is to be able to use any preset as it was a standalone applet, so creating a preset means you can find it directly in the widget explorer. If presets are moved somewhere else, it needs somthing that synchronizes them for the extra plasmoids to still work, which it addsa new brittle level of complexity.

it is a bit annoying that is depending indirectly from libplasma for the package plugin, perhaps it could have an internal, non-plugin replacement for this package structure to have it working also when plasma is not installed

mart: it kinda has to, as the original idea is to be able to use any preset as it was a standalone…
79​{
80​ clear();
81​ QList<KPluginMetaData> plugins = KPackage::PackageLoader::self()->findPackages(QStringLiteral("Plasma/Applet"), QString(), [](const KPluginMetaData &plugin) {
82​ return plugin.value(QStringLiteral("X-Plasma-RootPath")) == QStringLiteral("org.kde.plasma.systemmonitor");
83​ });
84​
85​ QSet<QString> usedNames;
86​
87​ // We iterate backwards because packages under ~/.local are listed first, while we want them last
88​ auto it = plugins.rbegin();
89​ for (; it != plugins.rend(); ++it) {
90​ const auto &plugin = *it;
91​ KPackage::Package p = KPackage::PackageLoader::self()->loadPackage(QStringLiteral("Plasma/Applet"), plugin.pluginId());
92​ KDesktopFile df(p.path() + QStringLiteral("metadata.desktop"));
93​
94​ QString baseName = df.readName();
95​ QString name = baseName;
96​ int id = 0;
97​
98​ while (usedNames.contains(name)) {
99​ name = baseName + QStringLiteral(" (") + QString::number(++id) + QStringLiteral(")");
100​ }
101​ usedNames << name;
102​
103​ QStandardItem *item = new QStandardItem(baseName);
104​
105​ // TODO config
106​ QVariantMap config;
107​
108​ KConfigGroup configGroup(df.group("Config"));
109​
110​ const QStringList keys = configGroup.keyList();
111​ for (const QString &key : keys) {
112​ // all strings for now, type conversion happens in QML side when we have the config property map
113​ config.insert(key, configGroup.readEntry(key));
114​ }
115​
116​ item->setData(plugin.pluginId(), PresetsModel::PluginIdRole);
117​ item->setData(config, PresetsModel::ConfigRole);
118​
119​ item->setData(QFileInfo(p.path() + QStringLiteral("metadata.desktop")).isWritable(), PresetsModel::WritableRole);
120​
121​ appendRow(item);
122​ }
123​}
124​
125​QHash<int, QByteArray> PresetsModel::roleNames() const
126​{
127​ QHash<int, QByteArray> roles = QAbstractItemModel::roleNames();
128​
129​ roles[PluginIdRole] = "pluginId";
130​ roles[ConfigRole] = "config";
131​ roles[WritableRole] = "writable";
132​ return roles;
133​}
134​
135​
136​
137​class SensorFaceController::Private
138​{
139​public:
140​ Private();
141​ SensorFace *createGui(const QString &qmlPath);
142​ QQuickItem *createConfigUi(const QString &file, const QVariantMap &initialProperties);
143​
144​ SensorFaceController *q;
145​ QString title;
146​ QQmlEngine *engine;
147​
148​ KConfigGroup faceProperties;
149​ KDeclarative::ConfigPropertyMap *faceConfiguration = nullptr;
150​ KConfigLoader *faceConfigLoader = nullptr;
151​
152​ bool configNeedsSave = false;
153​ KPackage::Package facePackage;
154​ QString faceId;
155​ KConfigGroup configGroup;
156​ KConfigGroup appearanceGroup;
157​ KConfigGroup sensorsGroup;
158​ KConfigGroup colorsGroup;
159​ QPointer <SensorFace> fullRepresentation;
160​ QPointer <SensorFace> compactRepresentation;
161​ QPointer <QQuickItem> faceConfigUi;
162​ QPointer <QQuickItem> appearanceConfigUi;
163​ QPointer <QQuickItem> sensorsConfigUi;
164​
165​ QTimer *syncTimer;
166​ FacesModel *availableFacesModel = nullptr;
167​ PresetsModel *availablePresetsModel = nullptr;
168​};
169​
170​SensorFaceController::Private::Private()
171​{}
172​
173​SensorFace *SensorFaceController::Private::createGui(const QString &qmlPath)
174​{
175​ QQmlComponent *component = new QQmlComponent(engine, qmlPath, nullptr);
176​ // TODO: eventually support async components? (only useful for qml files from http, we probably don't want that)
177​ if (component->status() != QQmlComponent::Ready) {
178​ qCritical() << "Error creating component:";
zzagUnsubmitted
Not Done

One could argue that "Error creating component" is a pretty common error message. Categorized logging can be useful for resolving such ambiguities.

zzag: One could argue that "Error creating component" is a pretty common error message. Categorized…
179​ for (auto err : component->errors()) {
180​ qWarning() << err.toString();
181​ }
182​ component->deleteLater();
183​ return nullptr;
ahiemstraUnsubmitted
Not Done

This seems to be unused?

ahiemstra: This seems to be unused?
martAuthorUnsubmitted
Not Done

it's used in the component->beginCreate(context); next line

mart: it's used in the component->beginCreate(context); next line
184​ }
185​
186​ //TODO: add i18n context object
187​ QQmlContext *context = new QQmlContext(engine);
188​ QObject *guiObject = component->beginCreate(context);
189​ SensorFace *gui = qobject_cast<SensorFace *>(guiObject);
190​ if (!gui) {
191​ qWarning()<<"ERROR: QML gui" << guiObject << "not a SensorFace instance";
192​ guiObject->deleteLater();
193​ context->deleteLater();
194​ return nullptr;
195​ }
196​ // context->setParent(gui);
197​
198​ gui->setController(q);
199​
200​ component->completeCreate();
201​
202​ component->deleteLater();
203​ return gui;
204​}
205​
206​QQuickItem *SensorFaceController::Private::createConfigUi(const QString &file, const QVariantMap &initialProperties)
207​{
208​ QQmlComponent *component = new QQmlComponent(engine, file, nullptr);
209​ // TODO: eventually support async components? (only useful for qml files from http, we probably don't want that)
210​ if (component->status() != QQmlComponent::Ready) {
211​ qCritical() << "Error creating component:";
212​ for (auto err : component->errors()) {
213​ qWarning() << err.toString();
214​ }
215​ component->deleteLater();
216​ return nullptr;
217​ }
218​
219​ //TODO: add i18n context object
220​ QQmlContext *context = new QQmlContext(engine);
221​ QObject *guiObject = component->createWithInitialProperties(
222​ initialProperties, context);
223​ QQuickItem *gui = qobject_cast<QQuickItem *>(guiObject);
224​ Q_ASSERT(gui);
225​
226​ component->deleteLater();
227​
228​ return gui;
229​}
230​
231​
232​
233​
234​
235​SensorFaceController::SensorFaceController(KConfigGroup &config, QQmlEngine *engine)
236​ : QObject(engine),
237​ d(std::make_unique<Private>())
238​{
239​ d->q = this;
240​ d->configGroup = config;
241​ d->appearanceGroup = KConfigGroup(&config, "Appearance");
242​ d->sensorsGroup = KConfigGroup(&config, "Sensors");
243​ d->colorsGroup = KConfigGroup(&config, "SensorColors");
244​ d->engine = engine;
245​ d->syncTimer = new QTimer(this);
246​ d->syncTimer->setSingleShot(true);
247​ d->syncTimer->setInterval(5000);
248​ connect(d->syncTimer, &QTimer::timeout, this, [this]() {
ahiemstraUnsubmitted
Not Done

I think we should have a "default face" for when no specfic face has been set yet, that isn't a pie chart. At least for ksysguard the default pie chart feels weird.

ahiemstra: I think we should have a "default face" for when no specfic face has been set yet, that isn't a…
martAuthorUnsubmitted
Not Done

perhaps line chart?

mart: perhaps line chart?
ahiemstraUnsubmitted
Not Done

I was more thinking something along the lines of a new face that's either completely empty or displays a "not configured" message.

ahiemstra: I was more thinking something along the lines of a new face that's either completely empty or…
249​ d->appearanceGroup.sync();
250​ d->sensorsGroup.sync();
251​ });
252​
253​ setFaceId(d->appearanceGroup.readEntry("chartFace", QStringLiteral("org.kde.ksysguard.piechart")));
254​}
255​
256​SensorFaceController::~SensorFaceController()
257​{
258​}
259​
260​QString SensorFaceController::title() const
261​{
262​ return d->appearanceGroup.readEntry("title", name());
263​}
264​
265​void SensorFaceController::setTitle(const QString &title)
266​{
267​ if (title == SensorFaceController::title()) {
268​ return;
269​ }
270​
271​ d->appearanceGroup.writeEntry("title", title);
272​ d->syncTimer->start();
273​
274​ emit titleChanged();
275​}
276​
277​QJsonArray SensorFaceController::totalSensors() const
278​{
279​ QJsonDocument doc = QJsonDocument::fromJson(d->sensorsGroup.readEntry("totalSensors", QString()).toUtf8());
280​ return doc.array();
281​}
282​
283​void SensorFaceController::setTotalSensors(const QJsonArray &totalSensors)
284​{
285​ if (totalSensors == SensorFaceController::totalSensors()) {
286​ return;
287​ }
288​
289​ d->sensorsGroup.writeEntry("totalSensors", QJsonDocument(totalSensors).toJson(QJsonDocument::Compact));
290​ d->syncTimer->start();
291​ emit totalSensorsChanged();
292​}
293​
294​QJsonArray SensorFaceController::highPrioritySensorIds() const
295​{
296​ QJsonDocument doc = QJsonDocument::fromJson(d->sensorsGroup.readEntry("highPrioritySensorIds", QString()).toUtf8());
297​ return doc.array();
298​}
299​
300​
301​void SensorFaceController::setHighPrioritySensorIds(const QJsonArray &highPrioritySensorIds)
302​{
303​ if (highPrioritySensorIds == SensorFaceController::highPrioritySensorIds()) {
304​ return;
305​ }
306​
307​ d->sensorsGroup.writeEntry("highPrioritySensorIds", QJsonDocument(highPrioritySensorIds).toJson(QJsonDocument::Compact));
308​ d->syncTimer->start();
309​ emit highPrioritySensorIdsChanged();
310​}
311​
312​QVariantMap SensorFaceController::sensorColors() const
313​{
314​ QVariantMap colors;
315​ for (const auto &key : d->colorsGroup.keyList()) {
316​ QColor color = d->colorsGroup.readEntry(key, QColor());
317​
318​ if (color.isValid()) {
319​ colors[key] = color;
320​ }
321​ }
322​ return colors;
323​}
324​
325​void SensorFaceController::setSensorColors(const QVariantMap &colors)
326​{
327​ d->colorsGroup.deleteGroup();
328​ d->colorsGroup = KConfigGroup(&d->configGroup, "SensorColors");
329​
330​ auto it = colors.constBegin();
331​ for (; it != colors.constEnd(); ++it) {
332​ d->colorsGroup.writeEntry(it.key(), it.value());
333​ }
334​
335​ d->syncTimer->start();
336​ emit sensorColorsChanged();
337​}
338​
339​QJsonArray SensorFaceController::lowPrioritySensorIds() const
340​{
341​ QJsonDocument doc = QJsonDocument::fromJson(d->sensorsGroup.readEntry("lowPrioritySensorIds", QString()).toUtf8());
342​ return doc.array();
343​}
344​
345​void SensorFaceController::setLowPrioritySensorIds(const QJsonArray &lowPrioritySensorIds)
346​{
347​ if (lowPrioritySensorIds == SensorFaceController::lowPrioritySensorIds()) {
348​ return;
349​ }
350​
351​ d->sensorsGroup.writeEntry("lowPrioritySensorIds", QJsonDocument(lowPrioritySensorIds).toJson(QJsonDocument::Compact));
352​ d->syncTimer->start();
353​ emit lowPrioritySensorIdsChanged();
354​}
355​
356​// from face config, immutable by the user
357​QString SensorFaceController::name() const
358​{
359​ return d->facePackage.metadata().name();
360​}
361​
362​const QString SensorFaceController::icon() const
363​{
364​ return d->facePackage.metadata().iconName();
365​}
366​
367​bool SensorFaceController::supportsSensorsColors() const
368​{
369​ return d->faceProperties.readEntry("SupportsSensorsColors", false);
370​}
371​
372​bool SensorFaceController::supportsTotalSensors() const
373​{
374​ return d->faceProperties.readEntry("SupportsTotalSensors", false);
375​}
376​
377​bool SensorFaceController::supportsLowPrioritySensors() const
378​{
379​ return d->faceProperties.readEntry("SupportsLowPrioritySensors", false);
380​}
381​
382​void SensorFaceController::setFaceId(const QString &face)
383​{
384​ if (d->faceId == face) {
385​ return;
386​ }
387​
388​ if (d->fullRepresentation) {
389​ d->fullRepresentation->deleteLater();
390​ d->fullRepresentation.clear();
391​ }
392​ if (d->compactRepresentation) {
393​ d->compactRepresentation->deleteLater();
394​ d->fullRepresentation.clear();
395​ }
396​
397​ d->faceId = face;
398​
399​ d->facePackage = KPackage::PackageLoader::self()->loadPackage(QStringLiteral("KSysguard/SensorFace"), face);
400​
401​ if (d->faceConfiguration) {
402​ d->faceConfiguration->deleteLater();
403​ d->faceConfiguration = nullptr;
404​ }
405​ if (d->faceConfigLoader) {
406​ d->faceConfigLoader ->deleteLater();
407​ d->faceConfigLoader = nullptr;
408​ }
409​
410​ if (!d->facePackage.isValid()) {
411​ emit faceIdChanged();
412​ return;
413​ }
414​
415​ //TODO: should be in a different config file rather than metadata
416​ d->faceProperties = KConfigGroup(KSharedConfig::openConfig(d->facePackage.filePath("FaceProperties")), QStringLiteral("Config"));
ahiemstraUnsubmitted
Done

Can we define this in the package and then use filePath("metadata") or so?

ahiemstra: Can we define this in the package and then use filePath("metadata") or so?
417​
418​ const QString xmlPath = d->facePackage.filePath("mainconfigxml");
419​
420​ if (!xmlPath.isEmpty()) {
421​ QFile file(xmlPath);
422​ KConfigGroup cg(&d->configGroup, d->faceId);
423​
424​ d->faceConfigLoader = new KConfigLoader(cg, &file, this);
425​ d->faceConfiguration = new KDeclarative::ConfigPropertyMap(d->faceConfigLoader, this);
426​ }
427​
428​ d->appearanceGroup.writeEntry("chartFace", face);
429​ d->syncTimer->start();
430​ emit faceIdChanged();
431​ return;
432​}
433​
434​QString SensorFaceController::faceId() const
435​{
436​ return d->faceId;
437​}
438​
439​KDeclarative::ConfigPropertyMap *SensorFaceController::faceConfiguration() const
440​{
441​ return d->faceConfiguration;
442​}
443​
444​QQuickItem *SensorFaceController::compactRepresentation()
445​{
446​ if (!d->facePackage.isValid()) {
447​ return nullptr;
448​ } else if (d->compactRepresentation) {
449​ return d->compactRepresentation;
450​ }
451​
452​ d->fullRepresentation = d->createGui(d->facePackage.filePath("ui", QStringLiteral("CompactRepresentation.qml")));
453​ return d->compactRepresentation;
454​}
455​
456​QQuickItem *SensorFaceController::fullRepresentation()
457​{
458​ if (!d->facePackage.isValid()) {
459​ return nullptr;
460​ } else if (d->fullRepresentation) {
461​ return d->fullRepresentation;
462​ }
463​
464​ d->fullRepresentation = d->createGui(d->facePackage.filePath("ui", QStringLiteral("FullRepresentation.qml")));
465​
466​ return d->fullRepresentation;
467​}
468​
469​QQuickItem *SensorFaceController::faceConfigUi()
470​{
471​ if (!d->facePackage.isValid()) {
472​ return nullptr;
473​ } else if (d->faceConfigUi) {
474​ return d->faceConfigUi;
475​ }
476​
477​ d->faceConfigUi = d->createConfigUi(QStringLiteral(":/FaceDetailsConfig.qml"),
ahiemstraUnsubmitted
Not Done

Code style is a bit messed up here. Maybe run clang-format over the entire thing?

ahiemstra: Code style is a bit messed up here. Maybe run clang-format over the entire thing?
478​ {{QStringLiteral("controller"), QVariant::fromValue(this)},
479​ {QStringLiteral("source"), d->facePackage.filePath("ui", QStringLiteral("Config.qml"))}});
480​
481​ return d->faceConfigUi;
482​}
483​
484​QQuickItem *SensorFaceController::appearanceConfigUi()
485​{
486​ if (d->appearanceConfigUi) {
487​ return d->appearanceConfigUi;
488​ }
489​
490​ d->appearanceConfigUi = d->createConfigUi(QStringLiteral(":/ConfigAppearance.qml"), {{QStringLiteral("controller"), QVariant::fromValue(this)}});
491​
492​ return d->appearanceConfigUi;
493​}
494​
495​QQuickItem *SensorFaceController::sensorsConfigUi()
496​{
497​ if (d->sensorsConfigUi) {
498​ return d->sensorsConfigUi;
499​ }
500​
501​ d->sensorsConfigUi = d->createConfigUi(QStringLiteral(":/ConfigSensors.qml"), {{QStringLiteral("controller"), QVariant::fromValue(this)}});
502​
503​ return d->sensorsConfigUi;
504​}
505​
506​QAbstractItemModel *SensorFaceController::availableFacesModel()
507​{
508​ if (d->availableFacesModel) {
509​ return d->availableFacesModel;
510​ }
511​
512​ d->availableFacesModel = new FacesModel(this);
513​ return d->availableFacesModel;
514​}
515​
516​QAbstractItemModel *SensorFaceController::availablePresetsModel()
517​{
518​ if (d->availablePresetsModel) {
519​ return d->availablePresetsModel;
520​ }
521​
522​ d->availablePresetsModel = new PresetsModel(this);
523​
524​ return d->availablePresetsModel;
525​}
526​
527​void SensorFaceController::reloadConfig()
528​{
529​ if (d->faceConfigLoader) {
530​ d->faceConfigLoader->load();
531​ }
532​
533​ //Force to re-read all the values
534​ setFaceId(d->appearanceGroup.readEntry("chartFace", QStringLiteral("org.kde.ksysguard.textonly")));
535​ titleChanged();
536​ totalSensorsChanged();
537​ highPrioritySensorIdsChanged();
538​ sensorColorsChanged();
539​ lowPrioritySensorIdsChanged();
540​}
541​
542​void SensorFaceController::loadPreset(const QString &preset)
543​{
544​ if (preset.isEmpty()) {
545​ return;
546​ }
547​
548​ auto presetPackage = KPackage::PackageLoader::self()->loadPackage(QStringLiteral("Plasma/Applet"));
549​
550​ presetPackage.setPath(preset);
551​
552​ if (!presetPackage.isValid()) {
553​ return;
554​ }
555​
556​ if (presetPackage.metadata().value(QStringLiteral("X-Plasma-RootPath")) != QStringLiteral("org.kde.plasma.systemmonitor")) {
557​ return;
558​ }
559​
560​ KDesktopFile df(presetPackage.path() + QStringLiteral("metadata.desktop"));
561​
562​ auto c = KSharedConfig::openConfig(presetPackage.filePath("config", QStringLiteral("faceproperties")));
563​ KConfigGroup presetGroup(c, QStringLiteral("Config"));
564​ KConfigGroup colorsGroup(c, QStringLiteral("SensorColors"));
565​
566​ // Load the title
567​ setTitle(df.readName());
568​
569​ //Remove the "custon" value from presets models
570​ if (d->availablePresetsModel &&
571​ d->availablePresetsModel->data(d->availablePresetsModel->index(0, 0), PresetsModel::PluginIdRole).toString().isEmpty()) {
572​ d->availablePresetsModel->removeRow(0);
573​ }
574​
575​ auto loadSensors = [this](const QJsonArray &partialEntries) {
576​ QJsonArray sensors;
577​
578​ for (const auto &id : partialEntries) {
579​ KSysGuard::SensorQuery query{id.toString()};
580​ query.execute();
581​ query.waitForFinished();
582​ for (const auto &fitleredId : query.sensorIds()) {
583​ sensors.append(QJsonValue(fitleredId));
584​ }
585​ }
586​ return sensors;
587​ };
588​
589​ QJsonDocument doc = QJsonDocument::fromJson(presetGroup.readEntry("totalSensors", QString()).toUtf8());
590​ setTotalSensors(loadSensors(doc.array()));
591​
592​ doc = QJsonDocument::fromJson(presetGroup.readEntry("highPrioritySensorIds", QString()).toUtf8());
593​ setHighPrioritySensorIds(loadSensors(doc.array()));
594​
595​ doc = QJsonDocument::fromJson(presetGroup.readEntry("lowPrioritySensorIds", QString()).toUtf8());
596​ setLowPrioritySensorIds(loadSensors(doc.array()));
597​
598​ setFaceId(presetGroup.readEntry(QStringLiteral("chartFace"), QStringLiteral("org.kde.ksysguard.piechart")));
599​
600​ colorsGroup.copyTo(&d->colorsGroup);
601​ emit sensorColorsChanged();
602​
603​ if (d->faceConfigLoader) {
604​ KConfigGroup presetGroup(KSharedConfig::openConfig(presetPackage.filePath("FaceProperties")), QStringLiteral("FaceConfig"));
605​
606​ for (const QString &key : presetGroup.keyList()) {
607​ KConfigSkeletonItem *item = d->faceConfigLoader->findItemByName(key);
608​ if (item) {
609​ if (item->property().type() == QVariant::StringList) {
610​ item->setProperty(presetGroup.readEntry(key, QStringList()));
611​ } else {
612​ item->setProperty(presetGroup.readEntry(key));
613​ }
614​ d->faceConfigLoader->save();
615​ d->faceConfigLoader->read();
616​ }
617​ }
618​ }
619​}
620​
621​void SensorFaceController::savePreset()
622​{
623​ QString pluginName = QStringLiteral("org.kde.plasma.systemmonitor.") + title().simplified().replace(QLatin1Char(' '), QChar()).toLower();
624​ int suffix = 0;
625​
626​ auto presetPackage = KPackage::PackageLoader::self()->loadPackage(QStringLiteral("Plasma/Applet"));
627​
628​ presetPackage.setPath(pluginName);
629​ if (presetPackage.isValid()) {
630​ do {
631​ presetPackage.setPath(QString());
632​ presetPackage.setPath(pluginName + QString::number(++suffix));
633​ } while (presetPackage.isValid());
634​
635​ pluginName += QString::number(suffix);
636​ }
637​
638​ QTemporaryDir dir;
639​ if (!dir.isValid()) {
640​ return;
641​ }
642​
643​ KConfig c(dir.path() % QLatin1Literal("/metadata.desktop"));
644​
645​ KConfigGroup cg(&c, "Desktop Entry");
646​ cg.writeEntry("Name", title());
647​ cg.writeEntry("Icon", "ksysguardd");
648​ cg.writeEntry("X-Plasma-API", "declarativeappletscript");
649​ cg.writeEntry("X-Plasma-MainScript", "ui/main.qml");
650​ cg.writeEntry("X-Plasma-Provides", "org.kde.plasma.systemmonitor");
651​ cg.writeEntry("X-Plasma-RootPath", "org.kde.plasma.systemmonitor");
652​ cg.writeEntry("X-KDE-PluginInfo-Name", pluginName);
653​ cg.writeEntry("X-KDE-ServiceTypes", "Plasma/Applet");
654​ cg.writeEntry("X-KDE-PluginInfo-Category", "System Information");
655​ cg.writeEntry("X-KDE-PluginInfo-License", "LGPL 2.1+");
656​ cg.writeEntry("X-KDE-PluginInfo-EnabledByDefault", "true");
657​ cg.writeEntry("X-KDE-PluginInfo-Version", "0.1");
658​ cg.sync();
659​
660​ QDir subDir(dir.path());
661​ subDir.mkdir(QStringLiteral("contents"));
662​ KConfig faceConfig(subDir.path() % QLatin1Literal("/contents/faceproperties"));
663​
664​ KConfigGroup configGroup(&faceConfig, "Config");
665​ configGroup.writeEntry(QStringLiteral("totalSensors"), QJsonDocument(totalSensors()).toJson(QJsonDocument::Compact));
666​ configGroup.writeEntry(QStringLiteral("highPrioritySensorIds"), QJsonDocument(highPrioritySensorIds()).toJson(QJsonDocument::Compact));
667​ configGroup.writeEntry(QStringLiteral("lowPrioritySensorIds"), QJsonDocument(lowPrioritySensorIds()).toJson(QJsonDocument::Compact));
668​
669​ KConfigGroup colorsGroup(&faceConfig, "SensorColors");
670​ d->colorsGroup.copyTo(&colorsGroup);
671​ colorsGroup.sync();
672​
673​ configGroup = KConfigGroup(&faceConfig, "FaceConfig");
674​ if (d->faceConfigLoader) {
675​ const auto &items = d->faceConfigLoader->items();
676​ for (KConfigSkeletonItem *item : items) {
677​ configGroup.writeEntry(item->key(), item->property());
678​ }
679​ }
680​ configGroup.sync();
681​
682​ auto *job = presetPackage.install(dir.path());
683​
684​ connect(job, &KJob::finished, this, [this, pluginName] () {
685​ d->availablePresetsModel->reload();
686​ });
687​}
688​
689​void SensorFaceController::uninstallPreset(const QString &pluginId)
690​{
691​ auto presetPackage = KPackage::PackageLoader::self()->loadPackage(QStringLiteral("Plasma/Applet"), pluginId);
692​
693​ if (presetPackage.metadata().value(QStringLiteral("X-Plasma-RootPath")) != QStringLiteral("org.kde.plasma.systemmonitor")) {
694​ return;
695​ }
696​
697​ QDir root(presetPackage.path());
698​ root.cdUp();
699​ auto *job = presetPackage.uninstall(pluginId, root.path());
700​
701​ connect(job, &KJob::finished, this, [this] () {
702​ d->availablePresetsModel->reload();
703​ });
704​}
705​
706​#include "moc_SensorFaceController.cpp"