made use of QStringLiteral and some other minor speedups

fancontrol-gui/src/main.cpp

@@ -36,16 +36,16 @@ int main(int argc, char *argv[])
 
     KLocalizedString::setApplicationDomain("kcm_fancontrol");
 
-    KAboutData about("fancontrol_gui",
-                    i18n("Fancontrol-GUI"),
-                    "0.1",
-                    i18n("Graphical user interface for fancontrol"),
-                    KAboutLicense::KAboutLicense::GPL_V2,
-                    "Copyright (C) 2015 Malte Veerman",
-                    QString(),
-                    "http://github.com/maldela/fancontrol-gui",
-                    "http://github.com/maldela/fancontrol-gui/issues");
-    about.addAuthor(i18n("Malte Veerman"), i18n("Main Developer"), "maldela@halloarsch.de");
+    KAboutData about(QStringLiteral("fancontrol_gui"),
+                     i18n("Fancontrol-GUI"),
+                     QStringLiteral("0.1"),
+                     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);
 
     QScopedPointer<QQmlApplicationEngine> engine(new QQmlApplicationEngine);
@@ -57,14 +57,14 @@ int main(int argc, char *argv[])
 
     Fancontrol::GUIBase base;
     base.load();
-    context->setContextProperty("base", &base);
+    context->setContextProperty(QStringLiteral("base"), &base);
     
     WindowConfig *windowConfig = WindowConfig::instance();
-    context->setContextProperty("windowConfig", windowConfig);
+    context->setContextProperty(QStringLiteral("windowConfig"), windowConfig);
 
-    KPackage::Package package = KPackage::PackageLoader::self()->loadPackage("KPackage/GenericQML");
-    package.setDefaultPackageRoot("kpackage/kcms");
-    package.setPath("kcm_fancontrol");
+    KPackage::Package package = KPackage::PackageLoader::self()->loadPackage(QStringLiteral("KPackage/GenericQML"));
+    package.setDefaultPackageRoot(QStringLiteral("kpackage/kcms"));
+    package.setPath(QStringLiteral("kcm_fancontrol"));
 
     engine->load(QUrl::fromLocalFile(package.path() + "/contents/ui/Application.qml"));
 

helper/src/helper.cpp

@@ -35,16 +35,16 @@ ActionReply Helper::action(const QVariantMap &arguments)
     ActionReply reply;
 
 #ifndef NO_SYSTEMD
-    if (arguments["action"] == "dbusaction")
+    if (arguments[QStringLiteral("action")] == "dbusaction")
     {
-        QString method = arguments["method"].toString();
-        QVariantList argsForCall = arguments["arguments"].toList();
+        QString method = arguments[QStringLiteral("method")].toString();
+        QVariantList argsForCall = arguments[QStringLiteral("arguments")].toList();
 
         QDBusConnection systembus = QDBusConnection::systemBus();
 
-        QDBusInterface *iface = new QDBusInterface ("org.freedesktop.systemd1",
-                                                    "/org/freedesktop/systemd1",
-                                                    "org.freedesktop.systemd1.Manager",
+        QDBusInterface *iface = new QDBusInterface (QStringLiteral("org.freedesktop.systemd1"),
+                                                    QStringLiteral("/org/freedesktop/systemd1"),
+                                                    QStringLiteral("org.freedesktop.systemd1.Manager"),
                                                     systembus,
                                                     this);
 
@@ -54,7 +54,7 @@ ActionReply Helper::action(const QVariantMap &arguments)
             dbusreply = iface->callWithArgumentList(QDBus::AutoDetect, method, argsForCall);
         delete iface;
 
-        if (method != "Reexecute")
+        if (method != QStringLiteral("Reexecute"))
         {
             if (dbusreply.type() == QDBusMessage::ErrorMessage)
             {
@@ -65,9 +65,9 @@ ActionReply Helper::action(const QVariantMap &arguments)
     }
     else
 #endif
-    if (arguments["action"] == "read")
+        if (arguments[QStringLiteral("action")] == "read")
     {
-        QString filename = arguments["filename"].toString();
+        QString filename = arguments[QStringLiteral("filename")].toString();
         QFile file(filename);
 
         if (!file.open(QIODevice::ReadOnly))
@@ -82,14 +82,14 @@ ActionReply Helper::action(const QVariantMap &arguments)
         QString content = stream.readAll();
 
         QVariantMap returnData;
-        returnData["content"] = content;
+        returnData[QStringLiteral("content")] = content;
 
         reply.setData(returnData);
     }
 
-    else if (arguments["action"] == "write")
+    else if (arguments[QStringLiteral("action")] == "write")
     {
-        QString filename = arguments["filename"].toString();
+        QString filename = arguments[QStringLiteral("filename")].toString();
         QFile file(filename);
 
         if (!file.open(QIODevice::WriteOnly))
@@ -101,13 +101,13 @@ ActionReply Helper::action(const QVariantMap &arguments)
         }
 
         QTextStream stream(&file);
-        stream << arguments["content"].toString();
+        stream << arguments[QStringLiteral("content")].toString();
     }
 
-    else if (arguments["action"] == "detectSensors")
+    else if (arguments[QStringLiteral("action")] == "detectSensors")
     {
-        QString program = "sensors-detect";
-        QStringList arguments = QStringList() << "--auto";
+        QString program = QStringLiteral("sensors-detect");
+        QStringList arguments = QStringList() << QStringLiteral("--auto");
         
         QProcess process;
         process.start(program, arguments);

kcm/src/fancontrolkcm.cpp

@@ -40,20 +40,20 @@ FancontrolKCM::FancontrolKCM(QObject *parent, const QVariantList& args)
     if (!m_base->hasSystemdCommunicator())
         qFatal("Fancontrol-gui-lib was compiled without systemd support!");
 
-    KAboutData *about = new KAboutData("kcm_fancontrol",
+    KAboutData *about = new KAboutData(QStringLiteral("kcm_fancontrol"),
                                        i18n("Fancontrol-KCM"),
-                                       "0.1",
+                                       QStringLiteral("0.1"),
                                        i18n("KDE Fancontrol Module"),
                                        KAboutLicense::KAboutLicense::GPL_V2,
-                                       "Copyright (C) 2015 Malte Veerman",
+                                       QStringLiteral("Copyright (C) 2015 Malte Veerman"),
                                        QString(),
-                                       "http://github.com/maldela/fancontrol-gui",
-                                       "http://github.com/maldela/fancontrol-gui/issues");
-    about->addAuthor(i18n("Malte Veerman"), i18n("Main Developer"), "maldela@halloarsch.de");
+                                       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);
 
     setButtons(Apply | Default);
-    setAuthActionName("fancontrol.gui.helper.action");
+    setAuthActionName(QStringLiteral("fancontrol.gui.helper.action"));
 
     connect(m_base->loader(), &Loader::configFileChanged, [this] () { setNeedsSave(true); });
     connect(m_base, &GUIBase::minTempChanged, [this] () { setNeedsSave(true); });

lib/src/config.cpp

@@ -41,13 +41,13 @@ namespace Fancontrol
 
 Config *Config::m_instance = Q_NULLPTR;
 
-Config::Config(QObject *parent) : KCoreConfigSkeleton(KSharedConfig::openConfig(CONFIG_NAME), parent)
+Config::Config(QObject *parent) : KCoreConfigSkeleton(KSharedConfig::openConfig(QStringLiteral(CONFIG_NAME)), parent)
 {
-    setCurrentGroup("preferences");
-    addItemDouble("MinTemp", m_minTemp, 30.0);
-    addItemDouble("MaxTemp", m_maxTemp, 90.0);
-    addItemString("ServiceName", m_serviceName, QString(STANDARD_SERVICE_NAME));
-    addItemPath("ConfigUrl", m_configUrl, QString("file://") + QString(STANDARD_CONFIG_FILE));
+    setCurrentGroup(QStringLiteral("preferences"));
+    addItemDouble(QStringLiteral("MinTemp"), m_minTemp, 30.0);
+    addItemDouble(QStringLiteral("MaxTemp"), m_maxTemp, 90.0);
+    addItemString(QStringLiteral("ServiceName"), m_serviceName, QStringLiteral(STANDARD_SERVICE_NAME));
+    addItemPath(QStringLiteral("ConfigUrl"), m_configUrl, QStringLiteral("file://") + QStringLiteral(STANDARD_CONFIG_FILE));
     
     load();
 }

lib/src/fan.cpp

@@ -35,7 +35,7 @@ namespace Fancontrol
 {
 
 Fan::Fan(Hwmon *parent, uint index) :
-    Sensor(parent, index, QString(parent->name() + QString("/fan") + QString::number(index))),
+    Sensor(parent, index, QString(parent->name() + QStringLiteral("/fan") + QString::number(index))),
     m_rpmStream(new QTextStream)
 {
     if (QDir(parent->path()).isReadable())
@@ -59,7 +59,7 @@ Fan::~Fan()
 
 QString Fan::name() const
 {
-    KConfigGroup names = KSharedConfig::openConfig("fancontrol-gui")->group("names");
+    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());
     if (name.isEmpty())
@@ -69,7 +69,7 @@ QString Fan::name() const
 
 void Fan::setName(const QString &name)
 {
-    KConfigGroup names = KSharedConfig::openConfig("fancontrol-gui")->group("names");
+    KConfigGroup names = KSharedConfig::openConfig(QStringLiteral("fancontrol-gui"))->group("names");
     KConfigGroup localNames = names.group(m_parent->name());
     if (name != localNames.readEntry("fan" + QString::number(m_index), QString())
         && !name.isEmpty())

lib/src/fancontrolaction.h

@@ -34,8 +34,8 @@ namespace Fancontrol
 
 inline KAuth::Action newFancontrolAction()
 {
-    KAuth::Action action("fancontrol.gui.helper.action");
-    action.setHelperId("fancontrol.gui.helper");
+    KAuth::Action action(QStringLiteral("fancontrol.gui.helper.action"));
+    action.setHelperId(QStringLiteral("fancontrol.gui.helper"));
     
     if (!action.isValid())
         qDebug() << "Action is invalid!";

lib/src/guibase.cpp

@@ -91,29 +91,29 @@ void GUIBase::save(bool saveLoader, const QUrl &url)
 
 qreal GUIBase::maxTemp() const
 {
-    return m_config->findItem("MaxTemp")->property().toReal();
+    return m_config->findItem(QStringLiteral("MaxTemp"))->property().toReal();
 }
 
 qreal GUIBase::minTemp() const
 {
-    return m_config->findItem("MinTemp")->property().toReal();
+    return m_config->findItem(QStringLiteral("MinTemp"))->property().toReal();
 }
 
 QString GUIBase::serviceName() const
 {
-    return m_config->findItem("ServiceName")->property().toString();
+    return m_config->findItem(QStringLiteral("ServiceName"))->property().toString();
 }
 
 QUrl GUIBase::configUrl() const
 {
-    return QUrl::fromLocalFile(m_config->findItem("ConfigUrl")->property().toString());
+    return QUrl::fromLocalFile(m_config->findItem(QStringLiteral("ConfigUrl"))->property().toString());
 }
 
 void GUIBase::setMaxTemp(qreal temp)
 {
     if (temp != maxTemp())
     {
-        m_config->findItem("MaxTemp")->setProperty(temp);
+        m_config->findItem(QStringLiteral("MaxTemp"))->setProperty(temp);
         emit maxTempChanged();
     }
 }
@@ -122,7 +122,7 @@ void GUIBase::setMinTemp(qreal temp)
 {
     if (temp != minTemp())
     {
-        m_config->findItem("MinTemp")->setProperty(temp);
+        m_config->findItem(QStringLiteral("MinTemp"))->setProperty(temp);
         emit minTempChanged();
     }
 }
@@ -131,7 +131,7 @@ void GUIBase::setServiceName(const QString& name)
 {
     if(name != serviceName())
     {
-        m_config->findItem("ServiceName")->setProperty(name);
+        m_config->findItem(QStringLiteral("ServiceName"))->setProperty(name);
 
 #ifndef NO_SYSTEMD
         m_com->setServiceName(name);
@@ -145,7 +145,7 @@ void GUIBase::setConfigUrl(const QUrl &url)
 {
     if (url != configUrl())
     {
-        m_config->findItem("ConfigUrl")->setProperty(url.toString(QUrl::PreferLocalFile));
+        m_config->findItem(QStringLiteral("ConfigUrl"))->setProperty(url.toString(QUrl::PreferLocalFile));
         m_configValid = m_loader->load(url);
         emit configUrlChanged();
     }

lib/src/hwmon.cpp

@@ -39,7 +39,7 @@ Hwmon::Hwmon(const QString &path, QObject *parent) : QObject(parent),
     }
 
     bool success;
-    m_index = path.split('/').last().remove("hwmon").toInt(&success);
+    m_index = path.split('/').last().remove(QStringLiteral("hwmon")).toInt(&success);
     if (!success)
     {
         emit errorChanged(path + "is invalid!");
@@ -65,11 +65,11 @@ void Hwmon::initialize()
 {
     QDir dir(m_path);
     QStringList entrys = dir.entryList(QDir::Files | QDir::NoDotAndDotDot);
-    foreach (QString entry, entrys)
+    foreach (const QString &entry, entrys)
     {
         QString str = entry;
         uint index = str.remove(QRegExp("\\D+")).toUInt();
-        if (entry.contains("fan") && entry.contains("input"))
+        if (entry.contains(QStringLiteral("fan")) && entry.contains(QStringLiteral("input")))
         {
             if (QFile::exists(m_path + "/pwm" + QString::number(index)))
             {
@@ -124,7 +124,7 @@ void Hwmon::initialize()
             }
         }
 
-        if (entry.contains("temp") && entry.contains("input"))
+        if (entry.contains(QStringLiteral("temp")) && entry.contains(QStringLiteral("input")))
         {
             Temp *newTemp = Q_NULLPTR;
 

lib/src/loader.cpp

@@ -45,8 +45,7 @@ namespace Fancontrol
 
 Loader::Loader(QObject *parent) : QObject(parent),
     m_interval(10),
-    m_configUrl(QUrl::fromLocalFile(STANDARD_CONFIG_FILE)),
-    m_error(""),
+    m_configUrl(QUrl::fromLocalFile(QStringLiteral(STANDARD_CONFIG_FILE))),
     m_timer(new QTimer(this))
 {
     parseHwmons();
@@ -59,19 +58,19 @@ Loader::Loader(QObject *parent) : QObject(parent),
 
 void Loader::parseHwmons()
 {
-    QDir hwmonDir(HWMON_PATH);
+    QDir hwmonDir(QStringLiteral(HWMON_PATH));
     QStringList list;
     if (hwmonDir.isReadable())
         list = hwmonDir.entryList(QDir::AllEntries | QDir::NoDotAndDotDot);
 
     else if (hwmonDir.exists())
     {
-        setError(i18n("%1 is not readable!", QString(HWMON_PATH)), true);
+        setError(i18n("%1 is not readable!", QStringLiteral(HWMON_PATH)), true);
         return;
     }
     else
     {
-        setError(i18n("%1 does not exist!", QString(HWMON_PATH)), true);
+        setError(i18n("%1 does not exist!", QStringLiteral(HWMON_PATH)), true);
         return;
     }
 
@@ -156,7 +155,7 @@ QPair<int, int> Loader::getEntryNumbers(const QString &entry)
     QString hwmon = list.at(0);
     QString sensor = list.at(1);
 
-    if (!hwmon.startsWith("hwmon"))
+    if (!hwmon.startsWith(QStringLiteral("hwmon")))
     {
         qWarning() << "Invalid entry to parse:" << entry << "Should begin with \"hwmon\"";
         return QPair<int, int>(-1, -1);
@@ -169,9 +168,9 @@ QPair<int, int> Loader::getEntryNumbers(const QString &entry)
 
     bool success;
 
-    hwmon.remove("hwmon");
+    hwmon.remove(QStringLiteral("hwmon"));
     sensor.remove(QRegExp("^(pwm|fan|temp)"));
-    sensor.remove("_input");
+    sensor.remove(QStringLiteral("_input"));
 
     int hwmonResult = hwmon.toInt(&success);
     if (!success)
@@ -267,8 +266,8 @@ bool Loader::load(const QUrl &url)
     {
         KAuth::Action action = newFancontrolAction();
         QVariantMap map;
-        map["action"] = "read";
-        map["filename"] = fileName;
+        map[QStringLiteral("action")] = QVariant("read");
+        map[QStringLiteral("filename")] = fileName;
         action.setArguments(map);
         KAuth::ExecuteJob *reply = action.execute();
         if (!reply->exec())
@@ -285,7 +284,7 @@ bool Loader::load(const QUrl &url)
                 emit configUrlChanged();
             }
 
-            fileContent = reply->data()["content"].toString();
+            fileContent = reply->data().value(QStringLiteral("content")).toString();
         }
     }
     else
@@ -327,9 +326,9 @@ bool Loader::load(const QUrl &url)
 
     foreach (QString line, lines)
     {
-        if (line.startsWith("INTERVAL="))
+        if (line.startsWith(QStringLiteral("INTERVAL=")))
         {
-            line.remove("INTERVAL=");
+            line.remove(QStringLiteral("INTERVAL="));
             bool success;
             int interval = line.toInt(&success);
             if (success)
@@ -346,9 +345,9 @@ bool Loader::load(const QUrl &url)
                 return false;
             }
         }
-        else if (line.startsWith("FCTEMPS="))
+        else if (line.startsWith(QStringLiteral("FCTEMPS=")))
         {
-            line.remove("FCTEMPS=");
+            line.remove(QStringLiteral("FCTEMPS="));
             QStringList fctemps = line.split(' ');
             foreach (const QString &fctemp, fctemps)
             {
@@ -371,9 +370,9 @@ bool Loader::load(const QUrl &url)
                     qWarning() << "Invalid entry:" << fctemp;
             }
         }
-        else if (line.startsWith("DEVNAME="))
+        else if (line.startsWith(QStringLiteral("DEVNAME=")))
         {
-            line.remove("DEVNAME=");
+            line.remove(QStringLiteral("DEVNAME="));
             QStringList devnames = line.split(' ');
             foreach (const QString &devname, devnames)
             {
@@ -383,7 +382,7 @@ bool Loader::load(const QUrl &url)
                     QString hwmon = indexNamePair.at(0);
                     QString name = indexNamePair.at(1);
                     bool success;
-                    Hwmon *hwmonPointer = m_hwmons.value(hwmon.remove("hwmon").toInt(&success), Q_NULLPTR);
+                    Hwmon *hwmonPointer = m_hwmons.value(hwmon.remove(QStringLiteral("hwmon")).toInt(&success), Q_NULLPTR);
                     if (!success)
                     {
                         //Connect hwmons again
@@ -406,38 +405,38 @@ bool Loader::load(const QUrl &url)
                 }
             }
         }
-        else if (line.startsWith("MINTEMP="))
+        else if (line.startsWith(QStringLiteral("MINTEMP=")))
         {
-            line.remove("MINTEMP=");
+            line.remove(QStringLiteral("MINTEMP="));
             parseConfigLine(line, &PwmFan::setMinTemp);
         }
-        else if (line.startsWith("MAXTEMP="))
+        else if (line.startsWith(QStringLiteral("MAXTEMP=")))
         {
-            line.remove("MAXTEMP=");
+            line.remove(QStringLiteral("MAXTEMP="));
             parseConfigLine(line, &PwmFan::setMaxTemp);
         }
-        else if (line.startsWith("MINSTART="))
+        else if (line.startsWith(QStringLiteral("MINSTART=")))
         {
-            line.remove("MINSTART=");
+            line.remove(QStringLiteral("MINSTART="));
             parseConfigLine(line, &PwmFan::setMinStart);
         }
-        else if (line.startsWith("MINSTOP="))
+        else if (line.startsWith(QStringLiteral("MINSTOP=")))
         {
-            line.remove("MINSTOP=");
+            line.remove(QStringLiteral("MINSTOP="));
             parseConfigLine(line, &PwmFan::setMinStop);
         }
-        else if (line.startsWith("MINPWM="))
+        else if (line.startsWith(QStringLiteral("MINPWM=")))
         {
-            line.remove("MINPWM=");
+            line.remove(QStringLiteral("MINPWM="));
             parseConfigLine(line, &PwmFan::setMinPwm);
         }
-        else if (line.startsWith("MAXPWM="))
+        else if (line.startsWith(QStringLiteral("MAXPWM=")))
         {
-            line.remove("MAXPWM=");
+            line.remove(QStringLiteral("MAXPWM="));
             parseConfigLine(line, &PwmFan::setMaxPwm);
         }
-        else if (!line.startsWith("DEVPATH=") &&
-                 !line.startsWith("FCFANS="))
+        else if (!line.startsWith(QStringLiteral("DEVPATH=")) &&
+            !line.startsWith(QStringLiteral("FCFANS=")))
         {
             //Connect hwmons again
             foreach (Hwmon *hwmon, m_hwmons)
@@ -487,9 +486,9 @@ bool Loader::save(const QUrl &url)
     {
         KAuth::Action action = newFancontrolAction();
         QVariantMap map;
-        map["action"] = "write";
-        map["filename"] = fileName;
-        map["content"] = m_configFile;
+        map[QStringLiteral("action")] = QVariant("write");
+        map[QStringLiteral("filename")] = fileName;
+        map[QStringLiteral("content")] = m_configFile;
 
         action.setArguments(map);
         KAuth::ExecuteJob *reply = action.execute();
@@ -525,105 +524,105 @@ void Loader::createConfigFile()
         }
     }
 
-    QString configFile = "# This file was created by Fancontrol-GUI \n";
+    QString configFile = QStringLiteral("# This file was created by Fancontrol-GUI") + QChar(QChar::LineFeed);
 
     if (m_interval != 0)
-        configFile += "INTERVAL=" + QString::number(m_interval) + "\n";
+        configFile += QStringLiteral("INTERVAL=") + QString::number(m_interval) + QChar(QChar::LineFeed);
 
     if (!usedHwmons.isEmpty())
     {
-        configFile += "DEVPATH=";
+        configFile += QStringLiteral("DEVPATH=");
         foreach (Hwmon *hwmon, usedHwmons)
         {
             QString sanitizedPath = hwmon->path();
             sanitizedPath.remove(QRegExp("^/sys/"));
             sanitizedPath.remove(QRegExp("/hwmon/hwmon\\d\\s*$"));
-            configFile += "hwmon" + QString::number(hwmon->index()) + "=" + sanitizedPath + " ";
+            configFile += QStringLiteral("hwmon") + QString::number(hwmon->index()) + "=" + sanitizedPath + QChar(QChar::Space);
         }
-        configFile += "\n";
-
-        configFile += "DEVNAME=";
+        configFile += QChar(QChar::LineFeed);
+        
+        configFile += QStringLiteral("DEVNAME=");
         foreach (Hwmon *hwmon, usedHwmons)
         {
-            configFile += "hwmon" + QString::number(hwmon->index()) + "=" + hwmon->name().split('.').first() + " ";
+            configFile += QStringLiteral("hwmon") + QString::number(hwmon->index()) + "=" + hwmon->name().split('.').first() + QChar(QChar::Space);
         }
-        configFile += "\n";
-
+        configFile += QChar(QChar::LineFeed);
+        
         if (!usedFans.isEmpty())
         {
-            configFile += "FCTEMPS=";
+            configFile += QStringLiteral("FCTEMPS=");
             foreach (PwmFan *pwmFan, usedFans)
             {
-                configFile += "hwmon" + QString::number(pwmFan->parent()->index()) + "/";
-                configFile += "pwm" + QString::number(pwmFan->index()) + "=";
-                configFile += "hwmon" + QString::number(pwmFan->temp()->parent()->index()) + "/";
-                configFile += "temp" + QString::number(pwmFan->temp()->index()) + "_input ";
+                configFile += QStringLiteral("hwmon") + QString::number(pwmFan->parent()->index()) + "/";
+                configFile += QStringLiteral("pwm") + QString::number(pwmFan->index()) + "=";
+                configFile += QStringLiteral("hwmon") + QString::number(pwmFan->temp()->parent()->index()) + "/";
+                configFile += QStringLiteral("temp") + QString::number(pwmFan->temp()->index()) + QStringLiteral("_input ");
             }
-            configFile += "\n";
-
-            configFile += "FCFANS=";
+            configFile += QChar(QChar::LineFeed);
+            
+            configFile += QStringLiteral("FCFANS=");
             foreach (PwmFan *pwmFan, usedFans)
             {
-                configFile += "hwmon" + QString::number(pwmFan->parent()->index()) + "/";
-                configFile += "pwm" + QString::number(pwmFan->index()) + "=";
-                configFile += "hwmon" + QString::number(pwmFan->parent()->index()) + "/";
-                configFile += "fan" + QString::number(pwmFan->index()) + "_input ";
+                configFile += QStringLiteral("hwmon") + QString::number(pwmFan->parent()->index()) + "/";
+                configFile += QStringLiteral("pwm") + QString::number(pwmFan->index()) + "=";
+                configFile += QStringLiteral("hwmon") + QString::number(pwmFan->parent()->index()) + "/";
+                configFile += QStringLiteral("fan") + QString::number(pwmFan->index()) + QStringLiteral("_input ");
             }
-            configFile += "\n";
-
-            configFile += "MINTEMP=";
+            configFile += QChar(QChar::LineFeed);
+            
+            configFile += QStringLiteral("MINTEMP=");
             foreach (PwmFan *pwmFan, usedFans)
             {
-                configFile += "hwmon" + QString::number(pwmFan->parent()->index()) + "/";
-                configFile += "pwm" + QString::number(pwmFan->index()) + "=";
-                configFile += QString::number(pwmFan->minTemp()) + " ";
+                configFile += QStringLiteral("hwmon") + QString::number(pwmFan->parent()->index()) + "/";
+                configFile += QStringLiteral("pwm") + QString::number(pwmFan->index()) + "=";
+                configFile += QString::number(pwmFan->minTemp()) + QChar(QChar::Space);
             }
-            configFile += "\n";
-
-            configFile += "MAXTEMP=";
+            configFile += QChar(QChar::LineFeed);
+            
+            configFile += QStringLiteral("MAXTEMP=");
             foreach (PwmFan *pwmFan, usedFans)
             {
-                configFile += "hwmon" + QString::number(pwmFan->parent()->index()) + "/";
-                configFile += "pwm" + QString::number(pwmFan->index()) + "=";
-                configFile += QString::number(pwmFan->maxTemp()) + " ";
+                configFile += QStringLiteral("hwmon") + QString::number(pwmFan->parent()->index()) + "/";
+                configFile += QStringLiteral("pwm") + QString::number(pwmFan->index()) + "=";
+                configFile += QString::number(pwmFan->maxTemp()) + QChar(QChar::Space);
             }
-            configFile += "\n";
-
-            configFile += "MINSTART=";
+            configFile += QChar(QChar::LineFeed);
+            
+            configFile += QStringLiteral("MINSTART=");
             foreach (PwmFan *pwmFan, usedFans)
             {
-                configFile += "hwmon" + QString::number(pwmFan->parent()->index()) + "/";
-                configFile += "pwm" + QString::number(pwmFan->index()) + "=";
-                configFile += QString::number(pwmFan->minStart()) + " ";
+                configFile += QStringLiteral("hwmon") + QString::number(pwmFan->parent()->index()) + "/";
+                configFile += QStringLiteral("pwm") + QString::number(pwmFan->index()) + "=";
+                configFile += QString::number(pwmFan->minStart()) + QChar(QChar::Space);
             }
-            configFile += "\n";
-
-            configFile += "MINSTOP=";
+            configFile += QChar(QChar::LineFeed);
+            
+            configFile += QStringLiteral("MINSTOP=");
             foreach (PwmFan *pwmFan, usedFans)
             {
-                configFile += "hwmon" + QString::number(pwmFan->parent()->index()) + "/";
-                configFile += "pwm" + QString::number(pwmFan->index()) + "=";
-                configFile += QString::number(pwmFan->minStop()) + " ";
+                configFile += QStringLiteral("hwmon") + QString::number(pwmFan->parent()->index()) + "/";
+                configFile += QStringLiteral("pwm") + QString::number(pwmFan->index()) + "=";
+                configFile += QString::number(pwmFan->minStop()) + QChar(QChar::Space);
             }
-            configFile += "\n";
+            configFile += QChar(QChar::LineFeed);
 
-            configFile += "MINPWM=";
+            configFile += QStringLiteral("MINPWM=");
             foreach (PwmFan *pwmFan, usedFans)
             {
-                configFile += "hwmon" + QString::number(pwmFan->parent()->index()) + "/";
-                configFile += "pwm" + QString::number(pwmFan->index()) + "=";
-                configFile += QString::number(pwmFan->minPwm()) + " ";
+                configFile += QStringLiteral("hwmon") + QString::number(pwmFan->parent()->index()) + "/";
+                configFile += QStringLiteral("pwm") + QString::number(pwmFan->index()) + "=";
+                configFile += QString::number(pwmFan->minPwm()) + QChar(QChar::Space);
             }
-            configFile += "\n";
+            configFile += QChar(QChar::LineFeed);
 
-            configFile += "MAXPWM=";
+            configFile += QStringLiteral("MAXPWM=");
             foreach (PwmFan *pwmFan, usedFans)
             {
-                configFile += "hwmon" + QString::number(pwmFan->parent()->index()) + "/";
-                configFile += "pwm" + QString::number(pwmFan->index()) + "=";
-                configFile += QString::number(pwmFan->maxPwm()) + " ";
+                configFile += QStringLiteral("hwmon") + QString::number(pwmFan->parent()->index()) + "/";
+                configFile += QStringLiteral("pwm") + QString::number(pwmFan->index()) + "=";
+                configFile += QString::number(pwmFan->maxPwm()) + QChar(QChar::Space);
             }
-            configFile += "\n";
+            configFile += QChar(QChar::LineFeed);
         }
     }
 
@@ -666,7 +665,7 @@ void Loader::detectSensors()
 {
     KAuth::Action action = newFancontrolAction();
     QVariantMap map;
-    map["action"] = "detectSensors";
+    map[QStringLiteral("action")] = QVariant("detectSensors");
 
     action.setArguments(map);
     KAuth::ExecuteJob *job = action.execute();

lib/src/pwmfan.cpp

@@ -178,9 +178,9 @@ bool PwmFan::setPwm(int pwm, bool write)
             {
                 KAuth::Action action = newFancontrolAction();
                 QVariantMap map;
-                map["action"] = "write";
-                map["filename"] = qobject_cast<QFile *>(m_pwmStream->device())->fileName();
-                map["content"] = QString::number(pwm);
+                map[QStringLiteral("action")] = "write";
+                map[QStringLiteral("filename")] = qobject_cast<QFile *>(m_pwmStream->device())->fileName();
+                map[QStringLiteral("content")] = QString::number(pwm);
                 action.setArguments(map);
                 KAuth::ExecuteJob *job = action.execute();
                 connect(job, SIGNAL(result(KJob*)), this, SLOT(handleSetPwmResult(KJob*)));
@@ -226,9 +226,9 @@ bool PwmFan::setPwmMode(int pwmMode, bool write)
                 KAuth::Action action = newFancontrolAction();
                 
                 QVariantMap map;
-                map["action"] = "write";
-                map["filename"] = qobject_cast<QFile *>(m_modeStream->device())->fileName();
-                map["content"] = QString::number(pwmMode);
+                map[QStringLiteral("action")] = QVariant("write");
+                map[QStringLiteral("filename")] = qobject_cast<QFile *>(m_modeStream->device())->fileName();
+                map[QStringLiteral("content")] = QString::number(pwmMode);
                 action.setArguments(map);
                 KAuth::ExecuteJob *job = action.execute();
                 connect(job, SIGNAL(result(KJob*)), this, SLOT(handleSetPwmModeResult(KJob*)));
@@ -392,14 +392,14 @@ bool PwmFan::testing() const
 
 bool PwmFan::active() const
 {
-    KConfigGroup active = KSharedConfig::openConfig("fancontrol-gui")->group("active");
+    KConfigGroup active = KSharedConfig::openConfig(QStringLiteral("fancontrol-gui"))->group("active");
     KConfigGroup localActive = active.group(m_parent->name());
     return localActive.readEntry("pwmfan" + QString::number(m_index), true);
 }
 
 void PwmFan::setActive(bool a)
 {
-    KConfigGroup active = KSharedConfig::openConfig("fancontrol-gui")->group("active");
+    KConfigGroup active = KSharedConfig::openConfig(QStringLiteral("fancontrol-gui"))->group("active");
     KConfigGroup localActive = active.group(m_parent->name());
     if (a != localActive.readEntry("pwmfan" + QString::number(m_index), true))
     {

lib/src/systemdcommunicator.cpp

@@ -68,16 +68,15 @@ namespace Fancontrol
 {
 
 SystemdCommunicator::SystemdCommunicator(QObject *parent, const QString &serviceName) : QObject(parent),
-    m_error(""),
-    m_managerInterface(new QDBusInterface("org.freedesktop.systemd1",
-                                          "/org/freedesktop/systemd1",
-                                          "org.freedesktop.systemd1.Manager",
+    m_managerInterface(new QDBusInterface(QStringLiteral("org.freedesktop.systemd1"),
+                                          QStringLiteral("/org/freedesktop/systemd1"),
+                                          QStringLiteral("org.freedesktop.systemd1.Manager"),
                                           QDBusConnection::systemBus(),
                                           this)),
     m_serviceInterface(Q_NULLPTR)
 {
     if (serviceName.isEmpty())
-        setServiceName(STANDARD_SERVICE_NAME);
+        setServiceName(QStringLiteral(STANDARD_SERVICE_NAME));
     else
         setServiceName(serviceName);
 
@@ -92,10 +91,10 @@ void SystemdCommunicator::setServiceName(const QString &name)
     {
         if (m_serviceInterface)
         {
-            QDBusConnection::systemBus().disconnect("org.freedesktop.systemd1",
+            QDBusConnection::systemBus().disconnect(QStringLiteral("org.freedesktop.systemd1"),
                                                     m_serviceObjectPath,
-                                                    "org.freedesktop.DBus.Properties",
-                                                    "PropertiesChanged",
+                                                    QStringLiteral("org.freedesktop.DBus.Properties"),
+                                                    QStringLiteral("PropertiesChanged"),
                                                     this,
                                                     SLOT(updateServiceProperties(QString, QVariantMap, QStringList)));
             m_serviceInterface->deleteLater();
@@ -108,7 +107,7 @@ void SystemdCommunicator::setServiceName(const QString &name)
         {
             QVariantList arguments;
             arguments << QVariant(m_serviceName + ".service");
-            QDBusMessage dbusreply = m_managerInterface->callWithArgumentList(QDBus::AutoDetect, "LoadUnit", arguments);
+            QDBusMessage dbusreply = m_managerInterface->callWithArgumentList(QDBus::AutoDetect, QStringLiteral("LoadUnit"), arguments);
             if (dbusreply.type() == QDBusMessage::ErrorMessage)
             {
                 m_error = dbusreply.errorMessage();
@@ -119,15 +118,15 @@ void SystemdCommunicator::setServiceName(const QString &name)
             {
                 m_serviceObjectPath = qdbus_cast<QDBusObjectPath>(dbusreply.arguments().at(0)).path();
 
-                m_serviceInterface = new QDBusInterface("org.freedesktop.systemd1",
+                m_serviceInterface = new QDBusInterface(QStringLiteral("org.freedesktop.systemd1"),
                                                         m_serviceObjectPath,
-                                                        "org.freedesktop.systemd1.Unit",
+                                                        QStringLiteral("org.freedesktop.systemd1.Unit"),
                                                         QDBusConnection::systemBus(),
                                                         this);
-                QDBusConnection::systemBus().connect("org.freedesktop.systemd1",
+                QDBusConnection::systemBus().connect(QStringLiteral("org.freedesktop.systemd1"),
                                                      m_serviceObjectPath,
-                                                     "org.freedesktop.DBus.Properties",
-                                                     "PropertiesChanged",
+                                                     QStringLiteral("org.freedesktop.DBus.Properties"),
+                                                     QStringLiteral("PropertiesChanged"),
                                                      this,
                                                      SLOT(updateServiceProperties(QString, QVariantMap, QStringList)));
             }
@@ -150,7 +149,7 @@ bool SystemdCommunicator::serviceExists()
     QDBusMessage dbusreply;
 
     if (m_managerInterface && m_managerInterface->isValid())
-        dbusreply = m_managerInterface->call(QDBus::AutoDetect, "ListUnitFiles");
+        dbusreply = m_managerInterface->call(QDBus::AutoDetect, QStringLiteral("ListUnitFiles"));
 
     if (dbusreply.type() == QDBusMessage::ErrorMessage)
     {
@@ -173,7 +172,7 @@ bool SystemdCommunicator::serviceActive()
 {
     if (serviceExists() && m_serviceInterface)
     {
-        if (m_serviceInterface->property("ActiveState").toString() == "active")
+        if (m_serviceInterface->property("ActiveState").toString() == QStringLiteral("active"))
             return true;
     }
     return false;
@@ -183,7 +182,7 @@ bool SystemdCommunicator::serviceEnabled()
 {
     if (serviceExists() && m_serviceInterface)
     {
-        if (m_serviceInterface->property("UnitFileState").toString() == "enabled")
+        if (m_serviceInterface->property("UnitFileState").toString() == QStringLiteral("enabled"))
             return true;
 
     }
@@ -196,7 +195,7 @@ bool SystemdCommunicator::setServiceEnabled(bool enabled)
     {
         if (enabled != serviceEnabled())
         {
-            QString action = enabled ? "EnableUnitFiles" : "DisableUnitFiles";
+            QString action = enabled ? QStringLiteral("EnableUnitFiles") : QStringLiteral("DisableUnitFiles");
             QStringList files = QStringList() << m_serviceName + ".service";
             QVariantList arguments = QVariantList() << files << false;
             if (enabled)
@@ -204,7 +203,7 @@ bool SystemdCommunicator::setServiceEnabled(bool enabled)
 
             if (dbusAction(action, arguments))
             {
-                if (dbusAction("Reload"))
+                if (dbusAction(QStringLiteral("Reload")))
                 {
                     emit serviceEnabledChanged();
                     return true;
@@ -226,7 +225,7 @@ bool SystemdCommunicator::setServiceActive(bool active)
         if (active != serviceActive())
         {
             QVariantList args = QVariantList() << m_serviceName + ".service" << "replace";
-            QString action = active ? "ReloadOrRestartUnit" : "StopUnit";
+            QString action = active ? QStringLiteral("ReloadOrRestartUnit") : QStringLiteral("StopUnit");
 
             if (dbusAction(action, args))
             {
@@ -259,13 +258,13 @@ bool SystemdCommunicator::dbusAction(const QString &method, const QVariantList &
 
     if (dbusreply.type() == QDBusMessage::ErrorMessage)
     {
-        if (dbusreply.errorMessage() == "Interactive authentication required.")
+        if (dbusreply.errorMessage() == QStringLiteral("Interactive authentication required."))
         {
             KAuth::Action action = newFancontrolAction();
             QVariantMap map;
-            map["action"] = "dbusaction";
-            map["method"] = method;
-            map["arguments"] = arguments;
+            map[QStringLiteral("action")] = "dbusaction";
+            map[QStringLiteral("method")] = method;
+            map[QStringLiteral("arguments")] = arguments;
             action.setArguments(map);
 
             KAuth::ExecuteJob *job = action.execute();
@@ -310,7 +309,7 @@ bool SystemdCommunicator::restartService()
     {
         QVariantList args;
         args << m_serviceName + ".service" << "replace";
-        return dbusAction("ReloadOrRestartUnit", args);
+        return dbusAction(QStringLiteral("ReloadOrRestartUnit"), args);
     }
 
     setError(i18n("Service does not exist"));
@@ -319,10 +318,10 @@ bool SystemdCommunicator::restartService()
 
 void SystemdCommunicator::updateServiceProperties(QString, QVariantMap propchanged, QStringList)
 {
-    if (propchanged.value("ActiveState").isValid())
+    if (propchanged.value(QStringLiteral("ActiveState")).isValid())
         emit serviceActiveChanged();
 
-    if (propchanged.value("UnitFileState").isValid())
+    if (propchanged.value(QStringLiteral("UnitFileState")).isValid())
         emit serviceEnabledChanged();
 }
 

lib/src/temp.cpp

@@ -38,7 +38,7 @@ namespace Fancontrol
 {
 
 Temp::Temp(Hwmon *parent, uint index) :
-    Sensor(parent, index, QString(parent->name() + QString("/temp") + QString::number(index))),
+    Sensor(parent, index, QString(parent->name() + QStringLiteral("/temp") + QString::number(index))),
     m_valueStream(new QTextStream)
 {
     if (QDir(parent->path()).isReadable())
@@ -67,7 +67,7 @@ Temp::~Temp()
 
 QString Temp::name() const
 {
-    KConfigGroup names = KSharedConfig::openConfig("fancontrol-gui")->group("names");
+    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());
     if (name.isEmpty())
@@ -81,7 +81,7 @@ QString Temp::name() const
 
 void Temp::setName(const QString &name)
 {
-    KConfigGroup names = KSharedConfig::openConfig("fancontrol-gui")->group("names");
+    KConfigGroup names = KSharedConfig::openConfig(QStringLiteral("fancontrol-gui"))->group("names");
     KConfigGroup localNames = names.group(m_parent->name());
     if (name != localNames.readEntry("temp" + QString::number(m_index), QString())
         && !name.isEmpty())

lib/src/tempmodel.cpp

@@ -37,7 +37,7 @@ m_unit(0)
 
 QString TempModel::composeText(Temp *temp)
 {
-    QString suffix = m_unit == 0 ? "°C" : m_unit == 2 ? "°F" : "K";
+    QString suffix = m_unit == 0 ? QStringLiteral("°C") : m_unit == 2 ? QStringLiteral("°F") : QStringLiteral("K");
 
     return temp->name() + ": " + QString::number(temp->value()) + suffix + "   (" + temp->path() + ")";
 }