small fixes and cleanups. used auto keyword to make code easier.

fancontrol-gui/package/contents/ui/Application.qml

@@ -30,6 +30,7 @@ ApplicationWindow {
     title: i18n("Fancontrol-GUI")
     width: 1024
     height: 768
+    color: palette.window
     visible: true
 
     onClosing: {
@@ -161,4 +162,8 @@ ApplicationWindow {
 
         onAccepted: Fancontrol.base.save(true, fileUrl);
     }
+
+    SystemPalette {
+        id: palette
+    }
 }

fancontrol-gui/src/main.cpp

@@ -40,26 +40,27 @@ int main(int argc, char *argv[])
 
     KLocalizedString::setApplicationDomain("kcm_fancontrol");
 
-    KAboutData about(QStringLiteral("fancontrol_gui"),
-                     i18n("Fancontrol-GUI"),
-                     QStringLiteral("0.4"),
-                     i18n("Graphical user interface for fancontrol"),
-                     KAboutLicense::KAboutLicense::GPL_V2,
-                     QStringLiteral("Copyright (C) 2015 Malte Veerman"),
-                     QString(),
-                     QStringLiteral("http://github.com/maldela/fancontrol-gui"),
-                     QStringLiteral("http://github.com/maldela/fancontrol-gui/issues"));
+    auto about = KAboutData(QStringLiteral("fancontrol_gui"),
+                            i18n("Fancontrol-GUI"),
+                            QStringLiteral("0.4"),
+                            i18n("Graphical user interface for fancontrol"),
+                            KAboutLicense::KAboutLicense::GPL_V2,
+                            QStringLiteral("Copyright (C) 2015 Malte Veerman"),
+                            QString(),
+                            QStringLiteral("http://github.com/maldela/fancontrol-gui"),
+                            QStringLiteral("http://github.com/maldela/fancontrol-gui/issues"));
     about.addAuthor(i18n("Malte Veerman"), i18n("Main Developer"), QStringLiteral("maldela@halloarsch.de"));
     KAboutData::setApplicationData(about);
-    QCommandLineParser parser;
-    about.setupCommandLine(&parser);
-    parser.process(app);
-    about.processCommandLine(&parser);
+
+    const auto parser = new QCommandLineParser;
+    about.setupCommandLine(parser);
+    parser->process(app);
+    about.processCommandLine(parser);
+    delete parser;
 
     KDeclarative::QmlObject qmlObject;
     qmlObject.rootContext()->setContextProperty(QStringLiteral("windowConfig"), WindowConfig::instance());
-
     qmlObject.loadPackage("fancontrol-gui");
-    
+
     return app.exec();
 }

helper/src/helper.cpp

@@ -38,16 +38,16 @@ ActionReply Helper::action(const QVariantMap &arguments)
 #ifndef NO_SYSTEMD
     if (arguments[QStringLiteral("action")] == "dbusaction")
     {
-        QString method = arguments[QStringLiteral("method")].toString();
-        QVariantList argsForCall = arguments[QStringLiteral("arguments")].toList();
+        const auto method = arguments[QStringLiteral("method")].toString();
+        const auto argsForCall = arguments[QStringLiteral("arguments")].toList();
 
-        QDBusConnection systembus = QDBusConnection::systemBus();
+        const auto systembus = QDBusConnection::systemBus();
 
-        QDBusInterface *iface = new QDBusInterface (QStringLiteral("org.freedesktop.systemd1"),
-                                                    QStringLiteral("/org/freedesktop/systemd1"),
-                                                    QStringLiteral("org.freedesktop.systemd1.Manager"),
-                                                    systembus,
-                                                    this);
+        const auto iface = new QDBusInterface (QStringLiteral("org.freedesktop.systemd1"),
+                                               QStringLiteral("/org/freedesktop/systemd1"),
+                                               QStringLiteral("org.freedesktop.systemd1.Manager"),
+                                               systembus,
+                                               this);
 
         QDBusMessage dbusreply;
 
@@ -68,7 +68,7 @@ ActionReply Helper::action(const QVariantMap &arguments)
 #endif
         if (arguments[QStringLiteral("action")] == "read")
     {
-        QString filename = arguments[QStringLiteral("filename")].toString();
+        const auto filename = arguments[QStringLiteral("filename")].toString();
         QFile file(filename);
 
         if (!file.open(QIODevice::ReadOnly))
@@ -80,7 +80,7 @@ ActionReply Helper::action(const QVariantMap &arguments)
         }
 
         QTextStream stream(&file);
-        QString content = stream.readAll();
+        const auto content = stream.readAll();
 
         QVariantMap returnData;
         returnData[QStringLiteral("content")] = content;
@@ -90,7 +90,7 @@ ActionReply Helper::action(const QVariantMap &arguments)
 
     else if (arguments[QStringLiteral("action")] == "write")
     {
-        QString filename = arguments[QStringLiteral("filename")].toString();
+        const auto filename = arguments[QStringLiteral("filename")].toString();
         QFile file(filename);
 
         if (!file.open(QIODevice::WriteOnly))
@@ -107,8 +107,8 @@ ActionReply Helper::action(const QVariantMap &arguments)
 
     else if (arguments[QStringLiteral("action")] == "detectSensors")
     {
-        QString program = QStringLiteral("sensors-detect");
-        QStringList arguments = QStringList() << QStringLiteral("--auto");
+        const auto program = QStringLiteral("sensors-detect");
+        const auto arguments = QStringList() << QStringLiteral("--auto");
 
         QProcess process;
         process.start(program, arguments);

import/src/fan.cpp

@@ -40,7 +40,7 @@ Fan::Fan(Hwmon *parent, uint index) :
 {
     if (QDir(parent->path()).isReadable())
     {
-        QFile *rpmFile = new QFile(parent->path() + "/fan" + QString::number(index) + "_input", this);
+        const auto rpmFile = new QFile(parent->path() + "/fan" + QString::number(index) + "_input", this);
 
         if (rpmFile->open(QFile::ReadOnly))
         {
@@ -48,20 +48,24 @@ Fan::Fan(Hwmon *parent, uint index) :
             *m_rpmStream >> m_rpm;
         }
         else
+        {
+            delete rpmFile;
             qWarning() << "Can't open rpmFile " << parent->path() + "/fan" + QString::number(index) + "_input";
+        }
     }
 }
 
 Fan::~Fan()
 {
+    delete m_rpmStream->device();
     delete m_rpmStream;
 }
 
 QString Fan::name() const
 {
-    KConfigGroup names = KSharedConfig::openConfig(QStringLiteral("fancontrol-gui"))->group("names");
-    KConfigGroup localNames = names.group(m_parent->name());
-    QString name = localNames.readEntry("fan" + QString::number(m_index), QString());
+    const auto names = KSharedConfig::openConfig(QStringLiteral("fancontrol-gui"))->group("names");
+    const auto localNames = names.group(m_parent->name());
+    const auto name = localNames.readEntry("fan" + QString::number(m_index), QString());
     
     if (name.isEmpty())
         return "fan" + QString::number(m_index);
@@ -71,8 +75,8 @@ QString Fan::name() const
 
 void Fan::setName(const QString &name)
 {
-    KConfigGroup names = KSharedConfig::openConfig(QStringLiteral("fancontrol-gui"))->group("names");
-    KConfigGroup localNames = names.group(m_parent->name());
+    const auto names = KSharedConfig::openConfig(QStringLiteral("fancontrol-gui"))->group("names");
+    auto localNames = names.group(m_parent->name());
     
     if (name != localNames.readEntry("fan" + QString::number(m_index), QString())
         && !name.isEmpty())
@@ -84,13 +88,12 @@ void Fan::setName(const QString &name)
 
 void Fan::reset()
 {
-    QIODevice *oldFile = m_rpmStream->device();
+    delete m_rpmStream->device();
     delete m_rpmStream;
-    delete oldFile;
 
     if (QDir(m_parent->path()).isReadable())
     {
-        QFile *rpmFile = new QFile(m_parent->path() + "/fan" + QString::number(m_index) + "_input", this);
+        const auto rpmFile = new QFile(m_parent->path() + "/fan" + QString::number(m_index) + "_input", this);
 
         if (rpmFile->open(QFile::ReadOnly))
         {
@@ -98,7 +101,10 @@ void Fan::reset()
             *m_rpmStream >> m_rpm;
         }
         else
+        {
+            delete rpmFile;
             qWarning() << "Can't open rpmFile " << m_parent->path() + "/fan" + QString::number(m_index) + "_input";
+        }
     }
 }
 

import/src/guibase.cpp

@@ -51,12 +51,12 @@ GUIBase::GUIBase(QObject *parent) : QObject(parent),
     connect(m_loader, &Loader::requestSetServiceActive, m_com, &SystemdCommunicator::setServiceActive);
 #endif
 
-    QLocale locale = QLocale::system();
-    QLocale::MeasurementSystem system = locale.measurementSystem();
+    const auto locale = QLocale::system();
+    const auto system = locale.measurementSystem();
     m_unit = (system == QLocale::ImperialUSSystem) ? QStringLiteral("°F") : QStringLiteral("°C");
     emit unitChanged(m_unit);
 
-    foreach (Hwmon *hwmon, m_loader->hwmons())
+    foreach (const auto &hwmon, m_loader->hwmons())
     {
         m_pwmFanModel->addPwmFans(hwmon->pwmFans());
         m_tempModel->addTemps(hwmon->temps());

import/src/hwmon.cpp

@@ -24,6 +24,7 @@
 
 #include <QtCore/QDir>
 #include <QtCore/QTextStream>
+#include <QtCore/QDebug>
 
 
 namespace Fancontrol
@@ -41,20 +42,24 @@ Hwmon::Hwmon(const QString &path, Loader *parent) : QObject(parent),
         m_valid = false;
     }
 
-    bool success;
+    auto success = false;
     m_index = path.split('/').last().remove(QStringLiteral("hwmon")).toInt(&success);
+
     if (!success)
     {
         emit errorChanged(path + "is invalid!");
         m_valid = false;
     }
 
-    QFile nameFile(path + "/name");
-    if (nameFile.open(QFile::ReadOnly))
-        m_name = QTextStream(&nameFile).readLine();
+    const auto nameFile = new QFile(path + "/name");
+
+    if (nameFile->open(QFile::ReadOnly))
+        m_name = QTextStream(nameFile).readLine();
     else
         m_name = path.split('/').last();
 
+    delete nameFile;
+
     connect(this, &Hwmon::configUpdateNeeded, parent, &Loader::createConfigFile);
     connect(this, &Hwmon::pwmFansChanged, parent, &Loader::emitAllPwmFansChanged);
     connect(this, &Hwmon::tempsChanged, parent, &Loader::emitAllTempsChanged);
@@ -67,18 +72,29 @@ Hwmon::Hwmon(const QString &path, Loader *parent) : QObject(parent),
 void Hwmon::initialize()
 {
     QDir dir(m_path);
-    QStringList entrys = dir.entryList(QDir::Files | QDir::NoDotAndDotDot);
-    foreach (const QString &entry, entrys)
+    const auto entries = dir.entryList(QDir::Files | QDir::NoDotAndDotDot);
+    foreach (auto entry, entries)
     {
-        QString str = entry;
-        uint index = str.remove(QRegExp("\\D+")).toUInt();
-        if (entry.contains(QStringLiteral("fan")) && entry.contains(QStringLiteral("input")))
+        if (!entry.contains(QStringLiteral("input")))
+            continue;
+
+        auto str = entry;
+        auto success = false;
+        const auto index = str.remove(QRegExp("\\D+")).toUInt(&success);
+
+        if (!success)
+        {
+            qWarning() << "Not a valid Sensor:" << entry;
+            continue;
+        }
+
+        if (entry.contains(QStringLiteral("fan")))
         {
             if (QFile::exists(m_path + "/pwm" + QString::number(index)))
             {
                 PwmFan *newPwmFan = Q_NULLPTR;
 
-                foreach (PwmFan *pwmFan, m_pwmFans)
+                foreach (const auto &pwmFan, m_pwmFans)
                 {
                     if (pwmFan->index() == index)
                     {
@@ -96,7 +112,7 @@ void Hwmon::initialize()
                     emit pwmFansChanged();
                 }
 
-                Fan *newFan = qobject_cast<Fan *>(newPwmFan);
+                const auto newFan = qobject_cast<Fan *>(newPwmFan);
                 if (!m_fans.contains(newFan))
                 {
                     m_fans << newFan;
@@ -107,7 +123,7 @@ void Hwmon::initialize()
             {
                 Fan *newFan = Q_NULLPTR;
 
-                foreach (Fan *fan, m_fans)
+                foreach (const auto &fan, m_fans)
                 {
                     if (fan->index() == index)
                     {
@@ -127,11 +143,11 @@ void Hwmon::initialize()
             }
         }
 
-        if (entry.contains(QStringLiteral("temp")) && entry.contains(QStringLiteral("input")))
+        if (entry.contains(QStringLiteral("temp")))
         {
             Temp *newTemp = Q_NULLPTR;
 
-            foreach (Temp *temp, m_temps)
+            foreach (const auto &temp, m_temps)
             {
                 if (temp->index() == index)
                 {
@@ -155,7 +171,7 @@ void Hwmon::initialize()
 QList<QObject *> Hwmon::fansAsObjects() const
 {
     QList<QObject *> list;
-    foreach (Fan *fan, m_fans)
+    foreach (const auto &fan, m_fans)
     {
         list << qobject_cast<QObject *>(fan);
     }
@@ -165,7 +181,7 @@ QList<QObject *> Hwmon::fansAsObjects() const
 QList<QObject *> Hwmon::pwmFansAsObjects() const
 {
     QList<QObject *> list;
-    foreach (PwmFan *pwmFan, m_pwmFans)
+    foreach (const auto &pwmFan, m_pwmFans)
     {
         list << qobject_cast<QObject *>(pwmFan);
     }
@@ -175,7 +191,7 @@ QList<QObject *> Hwmon::pwmFansAsObjects() const
 QList<QObject *> Hwmon::tempsAsObjects() const
 {
     QList<QObject *> list;
-    foreach (Temp *temp, m_temps)
+    foreach (const auto &temp, m_temps)
     {
         list << qobject_cast<QObject *>(temp);
     }
@@ -184,7 +200,7 @@ QList<QObject *> Hwmon::tempsAsObjects() const
 
 void Hwmon::testFans()
 {
-    foreach (PwmFan *const fan, m_pwmFans)
+    foreach (const auto &fan, m_pwmFans)
     {
         fan->test();
     }
@@ -192,7 +208,7 @@ void Hwmon::testFans()
 
 void Hwmon::abortTestingFans()
 {
-    foreach (PwmFan *const fan, m_pwmFans)
+    foreach (const auto &fan, m_pwmFans)
     {
         fan->abortTest();
     }
@@ -220,9 +236,9 @@ void Hwmon::setError(const QString &error)
 
 bool Hwmon::testing() const
 {
-    bool testing = false;
+    auto testing = false;
 
-    foreach(const PwmFan *fan, m_pwmFans)
+    foreach(const auto &fan, m_pwmFans)
     {
         if (fan->testing())
         {

import/src/loader.cpp

@@ -61,7 +61,7 @@ Loader::Loader(QObject *parent) : QObject(parent),
 
 void Loader::parseHwmons()
 {
-    QDir hwmonDir(QStringLiteral(HWMON_PATH));
+    const auto hwmonDir = QDir(QStringLiteral(HWMON_PATH));
     QStringList list;
     if (hwmonDir.isReadable())
         list = hwmonDir.entryList(QDir::AllEntries | QDir::NoDotAndDotDot);
@@ -81,23 +81,23 @@ void Loader::parseHwmons()
     while (!list.isEmpty())
         dereferencedList << QFile::symLinkTarget(hwmonDir.absoluteFilePath(list.takeFirst()));
 
-    foreach (Hwmon *hwmon, m_hwmons)
+    foreach (const auto &hwmon, m_hwmons)
     {
         if (!dereferencedList.contains(hwmon->path()))
         {
+            hwmon->deleteLater();
             m_hwmons.removeOne(hwmon);
             emit hwmonsChanged();
-            hwmon->deleteLater();
         }
         else
             hwmon->initialize();
     }
 
-    foreach (const QString &hwmonPath, dereferencedList)
+    foreach (const auto &hwmonPath, dereferencedList)
     {
-        bool hwmonExists = false;
+        auto hwmonExists = false;
 
-        foreach (const Hwmon *hwmon, m_hwmons)
+        foreach (const auto &hwmon, m_hwmons)
         {
             if (hwmon->path() == hwmonPath)
             {
@@ -108,7 +108,7 @@ void Loader::parseHwmons()
 
         if (!hwmonExists)
         {
-            Hwmon *newHwmon = new Hwmon(hwmonPath, this);
+            auto newHwmon = new Hwmon(hwmonPath, this);
             if (newHwmon->isValid())
             {
                 connect(this, &Loader::sensorsUpdateNeeded, newHwmon, &Hwmon::updateSensors);
@@ -123,7 +123,7 @@ void Loader::parseHwmons()
 
 PwmFan * Loader::getPwmFan(const QPair<int, int> &indexPair) const
 {
-    Hwmon *hwmon = m_hwmons.value(indexPair.first, Q_NULLPTR);
+    const auto hwmon = m_hwmons.value(indexPair.first, Q_NULLPTR);
 
     if (!hwmon)
         return Q_NULLPTR;
@@ -133,7 +133,7 @@ PwmFan * Loader::getPwmFan(const QPair<int, int> &indexPair) const
 
 Temp * Loader::getTemp(const QPair<int, int> &indexPair) const
 {
-    Hwmon *hwmon = m_hwmons.value(indexPair.first, Q_NULLPTR);
+    const auto hwmon = m_hwmons.value(indexPair.first, Q_NULLPTR);
 
     if (!hwmon)
         return Q_NULLPTR;
@@ -149,14 +149,14 @@ QPair<int, int> Loader::getEntryNumbers(const QString &entry)
         return QPair<int, int>(-1, -1);
     }
 
-    QStringList list = entry.split('/', QString::SkipEmptyParts);
+    auto list = entry.split('/', QString::SkipEmptyParts);
     if (list.size() != 2)
     {
         qWarning() << "Invalid entry to parse:" << entry << "Should contain exactly one \'/\'";
         return QPair<int, int>(-1, -1);
     }
-    QString hwmon = list.at(0);
-    QString sensor = list.at(1);
+    auto &hwmon = list[0];
+    auto &sensor = list[1];
 
     if (!hwmon.startsWith(QStringLiteral("hwmon")))
     {
@@ -169,19 +169,19 @@ QPair<int, int> Loader::getEntryNumbers(const QString &entry)
         return QPair<int, int>(-1, -1);
     }
 
-    bool success;
+    auto success = false;
 
     hwmon.remove(QStringLiteral("hwmon"));
     sensor.remove(QRegExp("^(pwm|fan|temp)"));
     sensor.remove(QStringLiteral("_input"));
 
-    int hwmonResult = hwmon.toInt(&success);
+    const auto hwmonResult = hwmon.toInt(&success);
     if (!success)
     {
         qWarning() << "Invalid entry to parse:" << entry << "Could not convert" << hwmon << "to int";
         return QPair<int, int>(-1, -1);
     }
-    int sensorResult = sensor.toInt(&success);
+    const auto sensorResult = sensor.toInt(&success);
     if (!success)
     {
         qWarning() << "Invalid entry to parse:" << entry << "Could not convert" << sensor << "to int";
@@ -199,21 +199,21 @@ void Loader::parseConfigLine(const QString &line, void (PwmFan::*memberSetFuncti
         return;
     }
 
-    QStringList entries = line.split(' ');
+    const auto entries = line.split(' ');
 
-    foreach (const QString &entry, entries)
+    foreach (const auto &entry, entries)
     {
-        QStringList fanValuePair = entry.split('=');
+        const auto fanValuePair = entry.split('=');
         if (fanValuePair.size() == 2)
         {
-            QString fanString = fanValuePair.at(0);
-            QString valueString = fanValuePair.at(1);
-            bool success;
-            int value = valueString.toInt(&success);
+            const auto fanString = fanValuePair.at(0);
+            const auto valueString = fanValuePair.at(1);
+            auto success = false;
+            const auto value = valueString.toInt(&success);
 
             if (success)
             {
-                PwmFan *fan = getPwmFan(getEntryNumbers(fanString));
+                auto fan = getPwmFan(getEntryNumbers(fanString));
                 if (fan)
                     (fan->*memberSetFunction)(value);
             }
@@ -267,15 +267,15 @@ bool Loader::load(const QUrl &url)
     }
     else if (file.exists())
     {
-        KAuth::Action action = newFancontrolAction();
+        auto action = newFancontrolAction();
 
         if (action.isValid())
         {
-            QVariantMap map;
+            auto map = QVariantMap();
             map[QStringLiteral("action")] = QVariant("read");
             map[QStringLiteral("filename")] = fileName;
             action.setArguments(map);
-            KAuth::ExecuteJob *reply = action.execute();
+            auto reply = action.execute();
             if (!reply->exec())
             {
                 if (reply->error() == 4)
@@ -315,45 +315,48 @@ bool Loader::load(const QUrl &url)
 
     //Disconnect hwmons for performance reasons
     //They get reconnected later
-    foreach (Hwmon *hwmon, m_hwmons)
+    foreach (const auto &hwmon, m_hwmons)
     {
         disconnect(hwmon, &Hwmon::configUpdateNeeded, this, &Loader::createConfigFile);
-        foreach (QObject *pwmFan, hwmon->pwmFans())
+        foreach (const auto &pwmFan, hwmon->pwmFans())
         {
             qobject_cast<PwmFan *>(pwmFan)->reset();
         }
     }
 
     stream.setString(&fileContent);
-    QStringList lines;
+    auto lines = QStringList();
     do
     {
-        QString line(stream.readLine());
+        auto line(stream.readLine());
+
         if (line.startsWith('#') || line.trimmed().isEmpty())
             continue;
-        int offset = line.indexOf('#');
+
+        const auto offset = line.indexOf('#');
+
         if (offset != -1)
             line.truncate(offset-1);
+
         line = line.simplified();
         lines << line;
     }
     while(!stream.atEnd());
 
-    foreach (QString line, lines)
+    foreach (auto line, lines)
     {
         if (line.startsWith(QStringLiteral("INTERVAL=")))
         {
             line.remove(QStringLiteral("INTERVAL="));
-            bool success;
-            int interval = line.toInt(&success);
+            auto success = false;
+            const auto interval = line.toInt(&success);
+
             if (success)
-            {
                 setInterval(interval, false);
-            }
             else
             {
                 //Connect hwmons again
-                foreach (Hwmon *hwmon, m_hwmons)
+                foreach (const auto &hwmon, m_hwmons)
                     connect(hwmon, &Hwmon::configUpdateNeeded, this, &Loader::createConfigFile);
 
                 setError(i18n("Unable to parse interval line: \n %1", line), true);
@@ -363,16 +366,16 @@ bool Loader::load(const QUrl &url)
         else if (line.startsWith(QStringLiteral("FCTEMPS=")))
         {
             line.remove(QStringLiteral("FCTEMPS="));
-            QStringList fctemps = line.split(' ');
-            foreach (const QString &fctemp, fctemps)
+            const auto fctemps = line.split(' ');
+            foreach (const auto &fctemp, fctemps)
             {
-                QStringList nameValuePair = fctemp.split('=');
+                const auto nameValuePair = fctemp.split('=');
                 if (nameValuePair.size() == 2)
                 {
-                    QString pwm = nameValuePair.at(0);
-                    QString temp = nameValuePair.at(1);
-                    PwmFan *pwmPointer = getPwmFan(getEntryNumbers(pwm));
-                    Temp *tempPointer = getTemp(getEntryNumbers(temp));
+                    const auto pwm = nameValuePair.at(0);
+                    const auto temp = nameValuePair.at(1);
+                    const auto pwmPointer = getPwmFan(getEntryNumbers(pwm));
+                    const auto tempPointer = getTemp(getEntryNumbers(temp));
 
                     if (pwmPointer && tempPointer)
                     {
@@ -388,20 +391,22 @@ bool Loader::load(const QUrl &url)
         else if (line.startsWith(QStringLiteral("DEVNAME=")))
         {
             line.remove(QStringLiteral("DEVNAME="));
-            QStringList devnames = line.split(' ');
-            foreach (const QString &devname, devnames)
+            const auto devnames = line.split(' ');
+            foreach (const auto &devname, devnames)
             {
-                QStringList indexNamePair = devname.split('=');
+                const auto indexNamePair = devname.split('=');
                 if (indexNamePair.size() == 2)
                 {
-                    QString hwmon = indexNamePair.at(0);
-                    QString name = indexNamePair.at(1);
-                    bool success;
-                    Hwmon *hwmonPointer = m_hwmons.value(hwmon.remove(QStringLiteral("hwmon")).toInt(&success), Q_NULLPTR);
+                    auto index = indexNamePair.at(0);
+                    const auto &name = indexNamePair[1];
+                    auto success = false;
+                    index.remove(QStringLiteral("hwmon"));
+                    const auto hwmonPointer = m_hwmons.value(index.toInt(&success), Q_NULLPTR);
+
                     if (!success)
                     {
                         //Connect hwmons again
-                        foreach (Hwmon *hwmon, m_hwmons)
+                        foreach (const auto &hwmon, m_hwmons)
                             connect(hwmon, &Hwmon::configUpdateNeeded, this, &Loader::createConfigFile);
 
                         setError(i18n("Can not parse %1", devname), true);
@@ -411,7 +416,7 @@ bool Loader::load(const QUrl &url)
                     if (!hwmonPointer || hwmonPointer->name().split('.').first() != name)
                     {
                         //Connect hwmons again
-                        foreach (Hwmon *hwmon, m_hwmons)
+                        foreach (const auto &hwmon, m_hwmons)
                             connect(hwmon, &Hwmon::configUpdateNeeded, this, &Loader::createConfigFile);
 
                         setError(i18n("Invalid config file!"), true);
@@ -454,7 +459,7 @@ bool Loader::load(const QUrl &url)
             !line.startsWith(QStringLiteral("FCFANS=")))
         {
             //Connect hwmons again
-            foreach (Hwmon *hwmon, m_hwmons)
+            foreach (const auto &hwmon, m_hwmons)
                 connect(hwmon, &Hwmon::configUpdateNeeded, this, &Loader::createConfigFile);
 
             setError(i18n("Unrecognized line in config:\n%1", line), true);
@@ -465,7 +470,7 @@ bool Loader::load(const QUrl &url)
     createConfigFile();
 
     //Connect hwmons again
-    foreach (Hwmon *hwmon, m_hwmons)
+    foreach (const auto &hwmon, m_hwmons)
         connect(hwmon, &Hwmon::configUpdateNeeded, this, &Loader::createConfigFile);
 
     emit configUrlChanged();
@@ -499,7 +504,7 @@ bool Loader::save(const QUrl &url)
     }
     else
     {
-        KAuth::Action action = newFancontrolAction();
+        auto action = newFancontrolAction();
 
         if (action.isValid())
         {
@@ -509,7 +514,7 @@ bool Loader::save(const QUrl &url)
             map[QStringLiteral("content")] = m_configFile;
 
             action.setArguments(map);
-            KAuth::ExecuteJob *reply = action.execute();
+            auto *reply = action.execute();
 
             if (!reply->exec())
             {
@@ -535,13 +540,15 @@ void Loader::createConfigFile()
 {
     QList<Hwmon *> usedHwmons;
     QList<PwmFan *> usedFans;
-    foreach (Hwmon *hwmon, m_hwmons)
+
+    foreach (const auto &hwmon, m_hwmons)
     {
         if (hwmon->pwmFans().size() > 0)
             usedHwmons << hwmon;
-        foreach (QObject *fan, hwmon->pwmFans())
+
+        foreach (const auto &fan, hwmon->pwmFans())
         {
-            PwmFan *pwmFan = qobject_cast<PwmFan *>(fan);
+            auto pwmFan = qobject_cast<PwmFan *>(fan);
             if (pwmFan->hasTemp() && pwmFan->temp() && !pwmFan->testing())
             {
                 usedFans << pwmFan;
@@ -551,7 +558,7 @@ void Loader::createConfigFile()
         }
     }
 
-    QString configFile = QStringLiteral("# This file was created by Fancontrol-GUI") + QChar(QChar::LineFeed);
+    auto configFile = QStringLiteral("# This file was created by Fancontrol-GUI") + QChar(QChar::LineFeed);
 
     if (m_interval != 0)
         configFile += QStringLiteral("INTERVAL=") + QString::number(m_interval) + QChar(QChar::LineFeed);
@@ -559,9 +566,10 @@ void Loader::createConfigFile()
     if (!usedHwmons.isEmpty())
     {
         configFile += QStringLiteral("DEVPATH=");
-        foreach (Hwmon *hwmon, usedHwmons)
+
+        foreach (const auto &hwmon, usedHwmons)
         {
-            QString sanitizedPath = hwmon->path();
+            auto sanitizedPath = hwmon->path();
             sanitizedPath.remove(QRegExp("^/sys/"));
             sanitizedPath.remove(QRegExp("/hwmon/hwmon\\d\\s*$"));
             configFile += QStringLiteral("hwmon") + QString::number(hwmon->index()) + "=" + sanitizedPath + QChar(QChar::Space);
@@ -569,16 +577,17 @@ void Loader::createConfigFile()
         configFile += QChar(QChar::LineFeed);
 
         configFile += QStringLiteral("DEVNAME=");
-        foreach (Hwmon *hwmon, usedHwmons)
-        {
+
+        foreach (const auto &hwmon, usedHwmons)
             configFile += QStringLiteral("hwmon") + QString::number(hwmon->index()) + "=" + hwmon->name().split('.').first() + QChar(QChar::Space);
-        }
+
         configFile += QChar(QChar::LineFeed);
 
         if (!usedFans.isEmpty())
         {
             configFile += QStringLiteral("FCTEMPS=");
-            foreach (PwmFan *pwmFan, usedFans)
+
+            foreach (const auto &pwmFan, usedFans)
             {
                 configFile += QStringLiteral("hwmon") + QString::number(pwmFan->parent()->index()) + "/";
                 configFile += QStringLiteral("pwm") + QString::number(pwmFan->index()) + "=";
@@ -588,7 +597,8 @@ void Loader::createConfigFile()
             configFile += QChar(QChar::LineFeed);
 
             configFile += QStringLiteral("FCFANS=");
-            foreach (PwmFan *pwmFan, usedFans)
+
+            foreach (const auto &pwmFan, usedFans)
             {
                 configFile += QStringLiteral("hwmon") + QString::number(pwmFan->parent()->index()) + "/";
                 configFile += QStringLiteral("pwm") + QString::number(pwmFan->index()) + "=";
@@ -598,7 +608,8 @@ void Loader::createConfigFile()
             configFile += QChar(QChar::LineFeed);
 
             configFile += QStringLiteral("MINTEMP=");
-            foreach (PwmFan *pwmFan, usedFans)
+
+            foreach (const auto &pwmFan, usedFans)
             {
                 configFile += QStringLiteral("hwmon") + QString::number(pwmFan->parent()->index()) + "/";
                 configFile += QStringLiteral("pwm") + QString::number(pwmFan->index()) + "=";
@@ -607,7 +618,8 @@ void Loader::createConfigFile()
             configFile += QChar(QChar::LineFeed);
 
             configFile += QStringLiteral("MAXTEMP=");
-            foreach (PwmFan *pwmFan, usedFans)
+
+            foreach (const auto &pwmFan, usedFans)
             {
                 configFile += QStringLiteral("hwmon") + QString::number(pwmFan->parent()->index()) + "/";
                 configFile += QStringLiteral("pwm") + QString::number(pwmFan->index()) + "=";
@@ -616,7 +628,8 @@ void Loader::createConfigFile()
             configFile += QChar(QChar::LineFeed);
 
             configFile += QStringLiteral("MINSTART=");
-            foreach (PwmFan *pwmFan, usedFans)
+
+            foreach (const auto &pwmFan, usedFans)
             {
                 configFile += QStringLiteral("hwmon") + QString::number(pwmFan->parent()->index()) + "/";
                 configFile += QStringLiteral("pwm") + QString::number(pwmFan->index()) + "=";
@@ -625,7 +638,8 @@ void Loader::createConfigFile()
             configFile += QChar(QChar::LineFeed);
 
             configFile += QStringLiteral("MINSTOP=");
-            foreach (PwmFan *pwmFan, usedFans)
+
+            foreach (const auto &pwmFan, usedFans)
             {
                 configFile += QStringLiteral("hwmon") + QString::number(pwmFan->parent()->index()) + "/";
                 configFile += QStringLiteral("pwm") + QString::number(pwmFan->index()) + "=";
@@ -634,7 +648,8 @@ void Loader::createConfigFile()
             configFile += QChar(QChar::LineFeed);
 
             configFile += QStringLiteral("MINPWM=");
-            foreach (PwmFan *pwmFan, usedFans)
+
+            foreach (const auto &pwmFan, usedFans)
             {
                 configFile += QStringLiteral("hwmon") + QString::number(pwmFan->parent()->index()) + "/";
                 configFile += QStringLiteral("pwm") + QString::number(pwmFan->index()) + "=";
@@ -643,7 +658,8 @@ void Loader::createConfigFile()
             configFile += QChar(QChar::LineFeed);
 
             configFile += QStringLiteral("MAXPWM=");
-            foreach (PwmFan *pwmFan, usedFans)
+
+            foreach (const auto &pwmFan, usedFans)
             {
                 configFile += QStringLiteral("hwmon") + QString::number(pwmFan->parent()->index()) + "/";
                 configFile += QStringLiteral("pwm") + QString::number(pwmFan->index()) + "=";
@@ -674,26 +690,22 @@ void Loader::setInterval(int interval, bool writeNewConfig)
 
 void Loader::testFans()
 {
-    for (int i=0; i<m_hwmons.size(); i++)
-    {
-        m_hwmons.at(i)->testFans();
-    }
+    foreach (const auto &hwmon, m_hwmons)
+        hwmon->testFans();
 }
 
 void Loader::abortTestingFans()
 {
-    for (int i=0; i<m_hwmons.size(); i++)
-    {
-        m_hwmons.at(i)->abortTestingFans();
-    }
+    foreach (const auto &hwmon, m_hwmons)
+        hwmon->abortTestingFans();
 }
 
 void Loader::detectSensors()
 {
-    QString program = QStringLiteral("sensors-detect");
-    QStringList arguments = QStringList() << QStringLiteral("--auto");
+    auto program = QStringLiteral("sensors-detect");
+    auto arguments = QStringList() << QStringLiteral("--auto");
 
-    QProcess *process = new QProcess(this);
+    auto process = new QProcess(this);
     process->start(program, arguments);
 
     connect(process, static_cast<void(QProcess::*)(int)>(&QProcess::finished),
@@ -702,14 +714,14 @@ void Loader::detectSensors()
 
 void Loader::handleDetectSensorsResult(int exitCode)
 {
-    QProcess *process = qobject_cast<QProcess *>(sender());
+    auto process = qobject_cast<QProcess *>(sender());
 
     if (exitCode)
     {
         if (process)
             setError(process->readAllStandardOutput());
 
-        KAuth::Action action = newFancontrolAction();
+        auto action = newFancontrolAction();
 
         if (action.isValid())
         {
@@ -717,7 +729,7 @@ void Loader::handleDetectSensorsResult(int exitCode)
             map[QStringLiteral("action")] = QVariant("detectSensors");
 
             action.setArguments(map);
-            KAuth::ExecuteJob *job = action.execute();
+            auto job = action.execute();
 
             connect(job, &KAuth::ExecuteJob::result, this, static_cast<void(Loader::*)(KJob *)>(&Loader::handleDetectSensorsResult));
             job->start();
@@ -767,11 +779,10 @@ void Loader::handleDetectSensorsResult(KJob *job)
 
 QList<QObject *> Loader::hwmonsAsObjects() const
 {
-    QList<QObject *> list;
-    foreach (Hwmon *hwmon, m_hwmons)
-    {
+    auto list = QList<QObject *>();
+    foreach (const auto &hwmon, m_hwmons)
         list << qobject_cast<QObject *>(hwmon);
-    }
+
     return list;
 }
 
@@ -791,9 +802,9 @@ void Loader::setError (const QString &error, bool critical)
 
 void Loader::handleTestStatusChanged()
 {
-    bool testing = false;
+    auto testing = false;
 
-    foreach (const Hwmon *hwmon, m_hwmons)
+    foreach (const auto &hwmon, m_hwmons)
     {
         if (hwmon->testing() == true)
         {

import/src/pwmfan.cpp

@@ -70,7 +70,8 @@ PwmFan::PwmFan(Hwmon *parent, uint index) : Fan(parent, index),
 
     if (QDir(parent->path()).isReadable())
     {
-        QFile *pwmFile = new QFile(parent->path() + "/pwm" + QString::number(index), this);
+        const auto pwmFile = new QFile(parent->path() + "/pwm" + QString::number(index), this);
+
         if (pwmFile->open(QFile::ReadWrite))
         {
             m_pwmStream->setDevice(pwmFile);
@@ -82,9 +83,13 @@ PwmFan::PwmFan(Hwmon *parent, uint index) : Fan(parent, index),
             *m_pwmStream >> m_pwm;
         }
         else
+        {
+            delete pwmFile;
             qWarning() << "Can't open pwmFile " << pwmFile->fileName();
+        }
+
+        const auto pwmModeFile = new QFile(parent->path() + "/pwm" + QString::number(index) + "_mode", this);
 
-        QFile *pwmModeFile = new QFile(parent->path() + "/pwm" + QString::number(index) + "_mode", this);
         if (pwmModeFile->open(QFile::ReadWrite))
         {
             m_modeStream->setDevice(pwmModeFile);
@@ -96,7 +101,10 @@ PwmFan::PwmFan(Hwmon *parent, uint index) : Fan(parent, index),
             *m_modeStream >> m_pwmMode;
         }
         else
+        {
+            delete pwmModeFile;
             qWarning() << "Can't open pwmModeFile " << pwmModeFile->fileName();
+        }
     }
 }
 
@@ -124,41 +132,47 @@ void PwmFan::reset()
     setHasTemp(false);
     setTemp(Q_NULLPTR);
 
-    QIODevice *oldFile = m_pwmStream->device();
+    delete m_pwmStream->device();
     delete m_pwmStream;
-    delete oldFile;
 
-    oldFile = m_modeStream->device();
+    delete m_modeStream->device();
     delete m_modeStream;
-    delete oldFile;
 
-    QFile *pwmFile = new QFile(m_parent->path() + "/pwm" + QString::number(m_index), this);
-        if (pwmFile->open(QFile::ReadWrite))
-        {
-            m_pwmStream = new QTextStream(pwmFile);
-            *m_pwmStream >> m_pwm;
-        }
-        else if (pwmFile->open(QFile::ReadOnly))
-        {
-            m_pwmStream = new QTextStream(pwmFile);
-            *m_pwmStream >> m_pwm;
-        }
-        else
-            qWarning() << "Can't open pwmFile " << pwmFile->fileName();
+    const auto pwmFile = new QFile(m_parent->path() + "/pwm" + QString::number(m_index), this);
 
-        QFile *pwmModeFile = new QFile(m_parent->path() + "/pwm" + QString::number(m_index) + "_mode", this);
-        if (pwmModeFile->open(QFile::ReadWrite))
-        {
-            m_modeStream = new QTextStream(pwmModeFile);
-            *m_modeStream >> m_pwmMode;
-        }
-        else if (pwmModeFile->open(QFile::ReadOnly))
-        {
-            m_modeStream = new QTextStream(pwmModeFile);
-            *m_modeStream >> m_pwmMode;
-        }
-        else
-            qWarning() << "Can't open pwmModeFile " << pwmModeFile->fileName();
+    if (pwmFile->open(QFile::ReadWrite))
+    {
+        m_pwmStream = new QTextStream(pwmFile);
+        *m_pwmStream >> m_pwm;
+    }
+    else if (pwmFile->open(QFile::ReadOnly))
+    {
+        m_pwmStream = new QTextStream(pwmFile);
+        *m_pwmStream >> m_pwm;
+    }
+    else
+    {
+        delete pwmFile;
+        qWarning() << "Can't open pwmFile " << pwmFile->fileName();
+    }
+
+    const auto pwmModeFile = new QFile(m_parent->path() + "/pwm" + QString::number(m_index) + "_mode", this);
+
+    if (pwmModeFile->open(QFile::ReadWrite))
+    {
+        m_modeStream = new QTextStream(pwmModeFile);
+        *m_modeStream >> m_pwmMode;
+    }
+    else if (pwmModeFile->open(QFile::ReadOnly))
+    {
+        m_modeStream = new QTextStream(pwmModeFile);
+        *m_modeStream >> m_pwmMode;
+    }
+    else
+    {
+        delete pwmModeFile;
+        qWarning() << "Can't open pwmModeFile " << pwmModeFile->fileName();
+    }
 }
 
 bool PwmFan::setPwm(int pwm, bool write)
@@ -176,7 +190,7 @@ bool PwmFan::setPwm(int pwm, bool write)
                 *m_pwmStream << pwm;
             else
             {
-                KAuth::Action action = newFancontrolAction();
+                auto action = newFancontrolAction();
 
                 if (action.isValid())
                 {
@@ -186,7 +200,7 @@ bool PwmFan::setPwm(int pwm, bool write)
                     map[QStringLiteral("content")] = QString::number(pwm);
                     action.setArguments(map);
 
-                    KAuth::ExecuteJob *job = action.execute();
+                    const auto job = action.execute();
                     if (!job->exec())
                     {
                         if (job->error() == KAuth::ActionReply::HelperBusyError)
@@ -222,7 +236,7 @@ bool PwmFan::setPwmMode(int pwmMode, bool write)
 
             else
             {
-                KAuth::Action action = newFancontrolAction();
+                auto action = newFancontrolAction();
 
                 if (action.isValid())
                 {
@@ -232,7 +246,7 @@ bool PwmFan::setPwmMode(int pwmMode, bool write)
                     map[QStringLiteral("content")] = QString::number(pwmMode);
                     action.setArguments(map);
 
-                    KAuth::ExecuteJob *job = action.execute();
+                    const auto job = action.execute();
                     if (!job->exec())
                     {
                         if (job->error() == KAuth::ActionReply::HelperBusyError)
@@ -258,11 +272,11 @@ void PwmFan::test()
 {
     if (!m_modeStream->device()->isWritable() || !m_pwmStream->device()->isWritable())
     {
-        KAuth::Action action = newFancontrolAction();
+        auto action = newFancontrolAction();
 
         if (action.isValid())
         {
-            KAuth::ExecuteJob *job = action.execute(KAuth::Action::AuthorizeOnlyMode);
+            const auto job = action.execute(KAuth::Action::AuthorizeOnlyMode);
 
             if (!job->exec())
             {
@@ -305,7 +319,7 @@ void PwmFan::continueTest()
 {
     if (!m_modeStream->device()->isWritable() || !m_pwmStream->device()->isWritable())
     {
-        KAuth::Action action = newFancontrolAction();
+        auto action = newFancontrolAction();
 
         if (action.status() != KAuth::Action::AuthorizedStatus)
         {
@@ -391,15 +405,15 @@ bool PwmFan::testing() const
 
 bool PwmFan::active() const
 {
-    KConfigGroup active = KSharedConfig::openConfig(QStringLiteral("fancontrol-gui"))->group("active");
-    KConfigGroup localActive = active.group(m_parent->name());
+    const auto active = KSharedConfig::openConfig(QStringLiteral("fancontrol-gui"))->group("active");
+    const auto localActive = active.group(m_parent->name());
     return localActive.readEntry("pwmfan" + QString::number(m_index), true);
 }
 
 void PwmFan::setActive(bool a)
 {
-    KConfigGroup active = KSharedConfig::openConfig(QStringLiteral("fancontrol-gui"))->group("active");
-    KConfigGroup localActive = active.group(m_parent->name());
+    const auto active = KSharedConfig::openConfig(QStringLiteral("fancontrol-gui"))->group("active");
+    auto localActive = active.group(m_parent->name());
     if (a != localActive.readEntry("pwmfan" + QString::number(m_index), true))
     {
         localActive.writeEntry("pwmfan" + QString::number(m_index), a);

import/src/pwmfanmodel.cpp

@@ -34,14 +34,17 @@ PwmFanModel::PwmFanModel(QObject *parent) : QStringListModel(parent)
 
 void PwmFanModel::setPwmFans(const QList<PwmFan *> &fans)
 {
+    if (m_fans == fans)
+        return;
+
     m_fans = fans;
     emit fansChanged();
 
     QStringList list;
 
-    foreach (PwmFan *const fan, fans)
+    foreach (const auto &fan, fans)
     {
-        connect(fan, SIGNAL(nameChanged()), this, SLOT(updateFan()));
+        connect(fan, &PwmFan::nameChanged, this, static_cast<void(PwmFanModel::*)()>(&PwmFanModel::updateFan));
         list << fan->name() + "  (" + fan->path() + ")";
     }
 
@@ -55,13 +58,13 @@ void PwmFanModel::addPwmFans(const QList<PwmFan *> &fans)
         m_fans += fans;
         emit fansChanged();
 
-        int oldSize = rowCount();
+        const auto oldSize = rowCount();
 
         insertRows(oldSize, fans.size());
 
-        foreach (PwmFan *const fan, fans)
+        foreach (const auto &fan, fans)
         {
-            connect(fan, SIGNAL(nameChanged()), this, SLOT(updateFan()));
+            connect(fan, &PwmFan::nameChanged, this, static_cast<void(PwmFanModel::*)()>(&PwmFanModel::updateFan));
             updateFan(fan);
         }
     }
@@ -72,35 +75,35 @@ void PwmFanModel::updateFan(PwmFan *fan)
     if (!fan)
         return;
 
-    int i = m_fans.indexOf(fan);
+    const auto i = m_fans.indexOf(fan);
     if (i == -1)
         return;
 
-    QString string = fan->name() + "  (" + fan->path() + ")";
+    const auto string = fan->name() + "  (" + fan->path() + ")";
     setData(index(i, 0), string);
     emit dataChanged(index(i, 0), index(i, 0));
 }
 
 void PwmFanModel::updateFan()
 {
-    PwmFan *fan = qobject_cast<PwmFan *>(sender());
+    const auto fan = qobject_cast<PwmFan *>(sender());
 
     if (!fan)
         return;
 
-    int i = m_fans.indexOf(fan);
+    const auto i = m_fans.indexOf(fan);
     if (i == -1)
         return;
 
-    QString string = fan->name() + "  (" + fan->path() + ")";
+    const auto string = fan->name() + "  (" + fan->path() + ")";
     setData(index(i, 0), string);
     emit dataChanged(index(i, 0), index(i, 0));
 }
 
 QList<QObject *> PwmFanModel::fans() const
 {
-    QList<QObject *> list;
-    foreach(PwmFan *const fan, m_fans)
+    auto list = QList<QObject *>();
+    foreach(const auto &fan, m_fans)
         list << qobject_cast<QObject *>(fan);
     return list;
 }

import/src/systemdcommunicator.cpp

@@ -107,7 +107,7 @@ void SystemdCommunicator::setServiceName(const QString &name)
         {
             QVariantList arguments;
             arguments << QVariant(m_serviceName + ".service");
-            QDBusMessage dbusreply = m_managerInterface->callWithArgumentList(QDBus::AutoDetect, QStringLiteral("LoadUnit"), arguments);
+            const auto dbusreply = m_managerInterface->callWithArgumentList(QDBus::AutoDetect, QStringLiteral("LoadUnit"), arguments);
             if (dbusreply.type() == QDBusMessage::ErrorMessage)
             {
                 m_error = dbusreply.errorMessage();
@@ -158,7 +158,7 @@ bool SystemdCommunicator::serviceExists()
     }
     SystemdUnitFileList list = qdbus_cast<SystemdUnitFileList>(dbusreply.arguments().at(0));
 
-    foreach (const SystemdUnitFile &unitFile, list)
+    foreach (const auto &unitFile, list)
     {
         if (unitFile.path.contains(m_serviceName + ".service"))
             return true;
@@ -195,9 +195,9 @@ bool SystemdCommunicator::setServiceEnabled(bool enabled)
     {
         if (enabled != serviceEnabled())
         {
-            QString action = enabled ? QStringLiteral("EnableUnitFiles") : QStringLiteral("DisableUnitFiles");
-            QStringList files = QStringList() << m_serviceName + ".service";
-            QVariantList arguments = QVariantList() << files << false;
+            const auto action = enabled ? QStringLiteral("EnableUnitFiles") : QStringLiteral("DisableUnitFiles");
+            const auto files = QStringList() << m_serviceName + ".service";
+            auto arguments = QVariantList() << files << false;
             if (enabled)
                 arguments << true;
 
@@ -224,8 +224,8 @@ bool SystemdCommunicator::setServiceActive(bool active)
     {
         if (active != serviceActive())
         {
-            QVariantList args = QVariantList() << m_serviceName + ".service" << "replace";
-            QString action = active ? QStringLiteral("ReloadOrRestartUnit") : QStringLiteral("StopUnit");
+            auto args = QVariantList() << m_serviceName + ".service" << "replace";
+            const auto action = active ? QStringLiteral("ReloadOrRestartUnit") : QStringLiteral("StopUnit");
 
             if (dbusAction(action, args))
             {
@@ -241,44 +241,37 @@ bool SystemdCommunicator::setServiceActive(bool active)
 
 bool SystemdCommunicator::dbusAction(const QString &method, const QVariantList &arguments)
 {
-    QDBusMessage dbusreply;
-
-    if (m_managerInterface->isValid())
-    {
-        if (arguments.isEmpty())
-            dbusreply = m_managerInterface->call(QDBus::AutoDetect, method);
-        else
-            dbusreply = m_managerInterface->callWithArgumentList(QDBus::AutoDetect, method, arguments);
-    }
-    else
+    if (!m_managerInterface->isValid())
     {
         qDebug() << "Invalid manager interface!";
         return false;
+
     }
 
-    if (dbusreply.type() == QDBusMessage::ErrorMessage)
+    const auto dbusreply = arguments.isEmpty() ? m_managerInterface->call(QDBus::AutoDetect, method) : m_managerInterface->callWithArgumentList(QDBus::AutoDetect, method, arguments);
+
+    if (dbusreply.type() != QDBusMessage::ErrorMessage)
+        return true;
+
+    if (dbusreply.errorMessage() == QStringLiteral("Interactive authentication required."))
     {
-        if (dbusreply.errorMessage() == QStringLiteral("Interactive authentication required."))
-        {
-            KAuth::Action action = newFancontrolAction();
-            QVariantMap map;
-            map[QStringLiteral("action")] = "dbusaction";
-            map[QStringLiteral("method")] = method;
-            map[QStringLiteral("arguments")] = arguments;
-            action.setArguments(map);
+        auto action = newFancontrolAction();
+        QVariantMap map;
+        map[QStringLiteral("action")] = "dbusaction";
+        map[QStringLiteral("method")] = method;
+        map[QStringLiteral("arguments")] = arguments;
+        action.setArguments(map);
 
-            KAuth::ExecuteJob *job = action.execute();
-            connect(job, &KAuth::ExecuteJob::result, this, &SystemdCommunicator::handleDbusActionResult);
-            job->start();
+        const auto job = action.execute();
+        connect(job, &KAuth::ExecuteJob::result, this, &SystemdCommunicator::handleDbusActionResult);
+        job->start();
 
-            return true;
-        }
-        
-        setError(dbusreply.errorMessage());
-        return false;
+        return true;
     }
 
-    return true;
+    setError(dbusreply.errorMessage());
+    return false;
+
 }
 
 void SystemdCommunicator::handleDbusActionResult(KJob *job)
@@ -289,10 +282,10 @@ void SystemdCommunicator::handleDbusActionResult(KJob *job)
         {
             qDebug() << "Helper busy...";
 
-            KAuth::ExecuteJob *executeJob = static_cast<KAuth::ExecuteJob *>(job);
+            const auto executeJob = static_cast<KAuth::ExecuteJob *>(job);
             if (executeJob)
             {
-                KAuth::ExecuteJob *newJob = executeJob->action().execute();
+                const auto newJob = executeJob->action().execute();
                 connect(newJob, &KAuth::ExecuteJob::result, this, &SystemdCommunicator::handleDbusActionResult);
                 
                 QTimer::singleShot(50, newJob, &KAuth::ExecuteJob::start);
@@ -310,6 +303,7 @@ bool SystemdCommunicator::restartService()
     {
         QVariantList args;
         args << m_serviceName + ".service" << "replace";
+
         return dbusAction(QStringLiteral("ReloadOrRestartUnit"), args);
     }
 

import/src/temp.cpp

@@ -43,8 +43,8 @@ Temp::Temp(Hwmon *parent, uint index) :
 {
     if (QDir(parent->path()).isReadable())
     {
-        QFile *valueFile = new QFile(parent->path() + "/temp" + QString::number(index) + "_input", this);
-        QFile labelFile(parent->path() + "/temp" + QString::number(index) + "_label");
+        const auto valueFile = new QFile(parent->path() + "/temp" + QString::number(index) + "_input", this);
+        const auto labelFile = new QFile(parent->path() + "/temp" + QString::number(index) + "_label");
 
         if (valueFile->open(QFile::ReadOnly))
         {
@@ -53,23 +53,36 @@ Temp::Temp(Hwmon *parent, uint index) :
             m_value /= 1000;
         }
         else
+        {
+            delete valueFile;
             qCritical() << "Can't open valueFile " << parent->path() + "/temp" + QString::number(index) + "_input";
+        }
 
-        if (labelFile.open(QFile::ReadOnly))
-            m_label = QTextStream(&labelFile).readLine();
+        if (labelFile->exists())
+        {
+            if (labelFile->open(QFile::ReadOnly))
+                m_label = QTextStream(labelFile).readLine();
+            else
+                qWarning() << "Can't open labelFile " << parent->path() + "/temp" + QString::number(index) + "_label";
+        }
+        else
+            qWarning() << parent->path() + "/temp" + QString::number(index) << "has no label.";
+
+        delete labelFile;
     }
 }
 
 Temp::~Temp()
 {
+    delete m_valueStream->device();
     delete m_valueStream;
 }
 
 QString Temp::name() const
 {
-    KConfigGroup names = KSharedConfig::openConfig(QStringLiteral("fancontrol-gui"))->group("names");
-    KConfigGroup localNames = names.group(m_parent->name());
-    QString name = localNames.readEntry("temp" + QString::number(m_index), QString());
+    const auto names = KSharedConfig::openConfig(QStringLiteral("fancontrol-gui"))->group("names");
+    const auto localNames = names.group(m_parent->name());
+    const auto name = localNames.readEntry("temp" + QString::number(m_index), QString());
     
     if (name.isEmpty())
     {
@@ -83,8 +96,9 @@ QString Temp::name() const
 
 void Temp::setName(const QString &name)
 {
-    KConfigGroup names = KSharedConfig::openConfig(QStringLiteral("fancontrol-gui"))->group("names");
-    KConfigGroup localNames = names.group(m_parent->name());
+    const auto names = KSharedConfig::openConfig(QStringLiteral("fancontrol-gui"))->group("names");
+    auto localNames = names.group(m_parent->name());
+
     if (name != localNames.readEntry("temp" + QString::number(m_index), QString())
         && !name.isEmpty())
     {
@@ -95,13 +109,12 @@ void Temp::setName(const QString &name)
 
 void Temp::reset()
 {
-    QIODevice *oldFile = m_valueStream->device();
+    delete m_valueStream->device();
     delete m_valueStream;
-    delete oldFile;
 
     if (QDir(m_parent->path()).isReadable())
     {
-        QFile *valueFile = new QFile(m_parent->path() + "/temp" + QString::number(m_index) + "_input", this);
+        const auto valueFile = new QFile(m_parent->path() + "/temp" + QString::number(m_index) + "_input", this);
 
         if (valueFile->open(QFile::ReadOnly))
         {
@@ -116,10 +129,13 @@ void Temp::reset()
 
 void Temp::update()
 {
+    auto success = false;
+
     m_valueStream->seek(0);
-    int value;
-    *m_valueStream >> value;
-    value /= 1000;
+    const auto value = m_valueStream->readAll().toInt(&success) / 1000;
+
+    if (!success)
+        qCritical() << "Can't update value of temp:" << m_parent->path() + "/temp" + QString::number(m_index);
     
     if (value != m_value)
     {

import/src/tempmodel.cpp

@@ -46,12 +46,12 @@ void TempModel::setTemps(const QList<Temp *> &temps)
     m_temps = temps;
     emit tempsChanged();
 
-    QStringList list;
+    auto list = QStringList();
 
-    foreach (Temp *const temp, temps)
+    foreach (const auto &temp, temps)
     {
-        connect(temp, SIGNAL(nameChanged()), this, SLOT(updateTemp()));
-        connect(temp, SIGNAL(valueChanged()), this, SLOT(updateTemp()));
+        connect(temp, &Temp::nameChanged, this, static_cast<void(TempModel::*)()>(&TempModel::updateTemp));
+        connect(temp, &Temp::valueChanged, this, static_cast<void(TempModel::*)()>(&TempModel::updateTemp));
         list << composeText(temp);
     }
 
@@ -65,14 +65,14 @@ void TempModel::addTemps(const QList<Temp *> &temps)
         m_temps += temps;
         emit tempsChanged();
 
-        int oldSize = rowCount();
+        const auto oldSize = rowCount();
 
         insertRows(oldSize, temps.size());
 
-        foreach (Temp *const temp, temps)
+        foreach (const auto &temp, temps)
         {
-            connect(temp, SIGNAL(nameChanged()), this, SLOT(updateTemp()));
-            connect(temp, SIGNAL(valueChanged()), this, SLOT(updateTemp()));
+            connect(temp, &Temp::nameChanged, this, static_cast<void(TempModel::*)()>(&TempModel::updateTemp));
+            connect(temp, &Temp::valueChanged, this, static_cast<void(TempModel::*)()>(&TempModel::updateTemp));
             updateTemp(temp);
         }
     }
@@ -83,7 +83,7 @@ void TempModel::updateTemp(Temp *temp)
     if (!temp)
         return;
 
-    int i = m_temps.indexOf(temp);
+    const auto i = m_temps.indexOf(temp);
     if (i == -1)
         return;
 
@@ -93,7 +93,7 @@ void TempModel::updateTemp(Temp *temp)
 
 void TempModel::updateTemp()
 {
-    Temp *temp = qobject_cast<Temp *>(sender());
+    const auto temp = qobject_cast<Temp *>(sender());
 
     updateTemp(temp);
 }
@@ -101,18 +101,18 @@ void TempModel::updateTemp()
 void TempModel::updateAll()
 {
     for (int i=0; i<m_temps.size(); i++)
-    {
-        Temp *temp = m_temps.at(i);
-        setData(index(i, 0), composeText(temp));
-    }
+        setData(index(i, 0), composeText(m_temps.at(i)));
+
     emit dataChanged(index(0, 0), index(m_temps.size(), 0));
 }
 
 QList<QObject *> TempModel::temps() const
 {
     QList<QObject *> list;
-    foreach(Temp *const temp, m_temps)
+
+    foreach(const auto &temp, m_temps)
         list << qobject_cast<QObject *>(temp);
+
     return list;
 }
 

kcm/src/fancontrolkcm.cpp

@@ -33,15 +33,15 @@ K_PLUGIN_FACTORY_WITH_JSON(FancontrolKCMFactory, "kcm_fancontrol.json", register
 FancontrolKCM::FancontrolKCM(QObject *parent, const QVariantList& args)
     : ConfigModule(parent, args)
 {
-    KAboutData *about = new KAboutData(QStringLiteral("kcm_fancontrol"),
-                                       i18n("Fancontrol-KCM"),
-                                       QStringLiteral("0.3"),
-                                       i18n("KDE Fancontrol Module"),
-                                       KAboutLicense::KAboutLicense::GPL_V2,
-                                       QStringLiteral("Copyright (C) 2015 Malte Veerman"),
-                                       QString(),
-                                       QStringLiteral("http://github.com/maldela/fancontrol-gui"),
-                                       QStringLiteral("http://github.com/maldela/fancontrol-gui/issues"));
+    auto about = new KAboutData(QStringLiteral("kcm_fancontrol"),
+                                i18n("Fancontrol-KCM"),
+                                QStringLiteral("0.3"),
+                                i18n("KDE Fancontrol Module"),
+                                KAboutLicense::KAboutLicense::GPL_V2,
+                                QStringLiteral("Copyright (C) 2015 Malte Veerman"),
+                                QString(),
+                                QStringLiteral("http://github.com/maldela/fancontrol-gui"),
+                                QStringLiteral("http://github.com/maldela/fancontrol-gui/issues"));
     about->addAuthor(i18n("Malte Veerman"), i18n("Main Developer"), QStringLiteral("maldela@halloarsch.de"));
     setAboutData(about);