qtpasssettings uses settingsconstants as well

3 files changed, 136 insertions, 121 deletions

diff --git a/qtpasssettings.cpp b/qtpasssettings.cpp
index bfe2ca48..c2e0c330 100644
--- a/qtpasssettings.cpp
+++ b/qtpasssettings.cpp
@@ -19,30 +19,30 @@ QHash<QString, bool> QtPassSettings::boolSettings;
 void QtPassSettings::saveAllSettings()
 {
 
-    for(QHash<QString, QString>::iterator i=stringSettings.begin(); i != QtPassSettings::stringSettings.end(); ++i)
-    {
-        getSettings().setValue(i.key(),i.value());
-    }
-    for(QHash<QString, QByteArray>::iterator i=QtPassSettings::byteArraySettings.begin(); i != QtPassSettings::byteArraySettings.end(); ++i)
-    {
-        getSettings().setValue(i.key(),i.value());
-    }
-    for(QHash<QString, QPoint>::iterator i=QtPassSettings::pointSettings.begin(); i != QtPassSettings::pointSettings.end(); ++i)
-    {
-        getSettings().setValue(i.key(),i.value());
-    }
-    for(QHash<QString, QSize>::iterator i=QtPassSettings::sizeSettings.begin(); i != QtPassSettings::sizeSettings.end(); ++i)
-    {
-        getSettings().setValue(i.key(),i.value());
-    }
-    for(QHash<QString, int>::iterator i=QtPassSettings::intSettings.begin(); i != QtPassSettings::intSettings.end(); ++i)
-    {
-        getSettings().setValue(i.key(),i.value());
-    }
-    for(QHash<QString, bool>::iterator i=QtPassSettings::boolSettings.begin(); i !=QtPassSettings::boolSettings.end(); ++i)
-    {
-        getSettings().setValue(i.key(),i.value());
-    }
+//    for(QHash<QString, QString>::iterator i=stringSettings.begin(); i != QtPassSettings::stringSettings.end(); ++i)
+//    {
+//    //    getSettings().setValue(i.key(),i.value());
+//    }
+//    for(QHash<QString, QByteArray>::iterator i=QtPassSettings::byteArraySettings.begin(); i != QtPassSettings::byteArraySettings.end(); ++i)
+//    {
+//    //    getSettings().setValue(i.key(),i.value());
+//    }
+//    for(QHash<QString, QPoint>::iterator i=QtPassSettings::pointSettings.begin(); i != QtPassSettings::pointSettings.end(); ++i)
+//    {
+//    //    getSettings().setValue(i.key(),i.value());
+//    }
+//    for(QHash<QString, QSize>::iterator i=QtPassSettings::sizeSettings.begin(); i != QtPassSettings::sizeSettings.end(); ++i)
+//    {
+//    //    getSettings().setValue(i.key(),i.value());
+//    }
+//    for(QHash<QString, int>::iterator i=QtPassSettings::intSettings.begin(); i != QtPassSettings::intSettings.end(); ++i)
+//    {
+//    //    getSettings().setValue(i.key(),i.value());
+//    }
+//    for(QHash<QString, bool>::iterator i=QtPassSettings::boolSettings.begin(); i !=QtPassSettings::boolSettings.end(); ++i)
+//    {
+//        getSettings().setValue(i.key(),i.value());
+//    }
 }
 
 QString QtPassSettings::getVersion(const QString &defaultValue)
@@ -58,187 +58,201 @@ void QtPassSettings::setVersion(const QString &version)
 QByteArray QtPassSettings::getGeometry(const QByteArray &defaultValue)
 {
     beginMainwindowGroup();
-    QByteArray returnValue = getByteArrayValue("geometry", defaultValue);
+    QByteArray returnValue = getByteArrayValue(SettingsConstants::geometry, defaultValue);
     endSettingsGroup();
     return returnValue;
 }
 
 void QtPassSettings::setGeometry(const QByteArray &geometry)
 {
-    setByteArrayValue("geometry", geometry);
+    beginMainwindowGroup();
+    setByteArrayValue(SettingsConstants::geometry, geometry);
+    endSettingsGroup();
 }
 
 QByteArray QtPassSettings::getSavestate(const QByteArray &defaultValue)
 {
     beginMainwindowGroup();
-    QByteArray returnValue = getByteArrayValue("savestate", defaultValue);
+    QByteArray returnValue = getByteArrayValue(SettingsConstants::savestate, defaultValue);
     endSettingsGroup();
     return returnValue;
 }
 
 void QtPassSettings::setSavestate(const QByteArray &saveState)
 {
-    getByteArrayValue("savestate", saveState);
+    beginMainwindowGroup();
+    setByteArrayValue(SettingsConstants::savestate, saveState);
+    endSettingsGroup();
 }
 
 QPoint QtPassSettings::getPos(const QPoint &defaultValue)
 {
     beginMainwindowGroup();
-    QPoint returnValue = getPointValue("pos", defaultValue);
+    QPoint returnValue = getPointValue(SettingsConstants::pos, defaultValue);
     endSettingsGroup();
     return returnValue;
 }
 
 void QtPassSettings::setPos(const QPoint &pos)
 {
-    setPointValue("pos", pos);
+    beginMainwindowGroup();
+    setPointValue(SettingsConstants::pos, pos);
+    endSettingsGroup();
 }
 
 QSize QtPassSettings::getSize(const QSize &defaultValue)
 {
     beginMainwindowGroup();
-    QSize returnValue = getSizeValue("size", defaultValue);
+    QSize returnValue = getSizeValue(SettingsConstants::size, defaultValue);
     endSettingsGroup();
     return returnValue;
 }
 
 void QtPassSettings::setSize(const QSize &size)
 {
-    setSizeValue("size", size);
+    beginMainwindowGroup();
+    setSizeValue(SettingsConstants::size, size);
+    endSettingsGroup();
 }
 
 int QtPassSettings::getSplitterLeft(const int &defaultValue)
 {
     beginMainwindowGroup();
-    int returnValue = getIntValue("splitterLeft", defaultValue);
+    int returnValue = getIntValue(SettingsConstants::splitterLeft, defaultValue);
     endSettingsGroup();
     return returnValue;
 }
 
 void QtPassSettings::setSplitterLeft(const int &splitterLeft)
 {
-    setIntValue("splitterLeft", splitterLeft);
+    beginMainwindowGroup();
+    setIntValue(SettingsConstants::splitterLeft, splitterLeft);
+    endSettingsGroup();
 }
 
 int QtPassSettings::getSplitterRight(const int &defaultValue)
 {
     beginMainwindowGroup();
-    int returnValue = getIntValue("splitterRight", defaultValue);
+    int returnValue = getIntValue(SettingsConstants::splitterRight, defaultValue);
     endSettingsGroup();
     return returnValue;
 }
 
 void QtPassSettings::setSplitterRight(const int &splitterRight)
 {
-    setIntValue("splitterRight", splitterRight);
+    beginMainwindowGroup();
+    setIntValue(SettingsConstants::splitterRight, splitterRight);
+    endSettingsGroup();
 }
 
 bool QtPassSettings::isMaximized(const bool &defaultValue)
 {
     beginMainwindowGroup();
-    bool returnValue = getBoolValue("maximized", defaultValue);
+    bool returnValue = getBoolValue(SettingsConstants::maximized, defaultValue);
     endSettingsGroup();
     return returnValue;
 }
 
 void QtPassSettings::setMaximized(const bool &maximized)
 {
-    setBoolValue("maximized", maximized);
+    beginMainwindowGroup();
+    setBoolValue(SettingsConstants::maximized, maximized);
+    endSettingsGroup();
 }
 
 bool QtPassSettings::isUsePass(const bool &defaultValue)
 {
-    return getBoolValue("usePass", defaultValue);
+    return getBoolValue(SettingsConstants::usePass, defaultValue);
 }
 
 void QtPassSettings::setUsePass(const bool &usePass)
 {
-    setBoolValue("usePass", usePass);
+    setBoolValue(SettingsConstants::usePass, usePass);
 }
 
 Enums::clipBoardType QtPassSettings::getClipBoardType(const Enums::clipBoardType &defaultvalue)
 {
-    return static_cast<Enums::clipBoardType>(getIntValue("clipBoardType",static_cast<int>(defaultvalue)));
+    return static_cast<Enums::clipBoardType>(getIntValue(SettingsConstants::clipBoardType, static_cast<int>(defaultvalue)));
 }
 
 void QtPassSettings::setClipBoardType(const Enums::clipBoardType &clipBoardType)
 {
-    setIntValue("clipBoardType",static_cast<int>(clipBoardType));
+    setIntValue(SettingsConstants::clipBoardType ,static_cast<int>(clipBoardType));
 }
 
 bool QtPassSettings::isUseAutoclear(const bool &defaultValue)
 {
-    return getBoolValue("useAutoclear", defaultValue);
+    return getBoolValue(SettingsConstants::useAutoclear, defaultValue);
 }
 
 void QtPassSettings::setUseAutoclear(const bool &useAutoclear)
 {
-    setBoolValue("useAutoclear", useAutoclear);
+    setBoolValue(SettingsConstants::useAutoclear, useAutoclear);
 }
 
 int QtPassSettings::getAutoclearSeconds(const int &defaultValue)
 {
-    return getIntValue("autoclearSeconds", defaultValue);
+    return getIntValue(SettingsConstants::autoclearSeconds, defaultValue);
 }
 
 void QtPassSettings::setAutoclearSeconds(const int &autoClearSeconds)
 {
-    setIntValue("autoclearSeconds", autoClearSeconds);
+    setIntValue(SettingsConstants::autoclearSeconds, autoClearSeconds);
 }
 
 bool QtPassSettings::isUseAutoclearPanel(const bool &defaultValue)
 {
-    return getBoolValue("useAutoclearPanel", defaultValue);
+    return getBoolValue(SettingsConstants::useAutoclearPanel, defaultValue);
 }
 
 void QtPassSettings::setUseAutoclearPanel(const bool &useAutoclearPanel)
 {
-    setBoolValue("useAutoclearPanel", useAutoclearPanel);
+    setBoolValue(SettingsConstants::useAutoclearPanel, useAutoclearPanel);
 }
 
 int QtPassSettings::getAutoclearPanelSeconds(const int &defaultValue)
 {
-    return getIntValue("autoclearPanelSeconds", defaultValue);
+    return getIntValue(SettingsConstants::autoclearPanelSeconds, defaultValue);
 }
 
 void QtPassSettings::setAutoclearPanelSeconds(const int &autoClearPanelSeconds)
 {
-    setIntValue("autoclearPanelSeconds", autoClearPanelSeconds);
+    setIntValue(SettingsConstants::autoclearPanelSeconds, autoClearPanelSeconds);
 }
 
 bool QtPassSettings::isHidePassword(const bool &defaultValue)
 {
-    return getBoolValue("hidePassword", defaultValue);
+    return getBoolValue(SettingsConstants::hidePassword, defaultValue);
 }
 
 void QtPassSettings::setHidePassword(const bool &hidePassword)
 {
-    setBoolValue("hidePassword", hidePassword);
+    setBoolValue(SettingsConstants::hidePassword, hidePassword);
 }
 
 bool QtPassSettings::isHideContent(const bool &defaultValue)
 {
-    return getBoolValue("hideContent", defaultValue);
+    return getBoolValue(SettingsConstants::hideContent, defaultValue);
 }
 
 void QtPassSettings::setHideContent(const bool &hideContent)
 {
-    setBoolValue("hideContent", hideContent);
+    setBoolValue(SettingsConstants::hideContent, hideContent);
 }
 
 bool QtPassSettings::isAddGPGId(const bool &defaultValue)
 {
-    return getBoolValue("addGPGId", defaultValue);
+    return getBoolValue(SettingsConstants::addGPGId, defaultValue);
 }
 
 void QtPassSettings::setAddGPGId(const bool &addGPGId)
 {
-    setBoolValue("addGPGId", addGPGId);
+    setBoolValue(SettingsConstants::addGPGId, addGPGId);
 }
 
 QString QtPassSettings::getPassStore(const QString &defaultValue)
 {
-    QString returnValue = getStringValue("passStore", defaultValue);
+    QString returnValue = getStringValue(SettingsConstants::passStore, defaultValue);
     // ensure directory exists if never used pass or misconfigured.
     // otherwise process->setWorkingDirectory(passStore); will fail on execution.
     QDir().mkdir(returnValue);
@@ -247,297 +261,297 @@ QString QtPassSettings::getPassStore(const QString &defaultValue)
 
 void QtPassSettings::setPassStore(const QString &passStore)
 {
-    setStringValue("passStore", passStore);
+    setStringValue(SettingsConstants::passStore, passStore);
 }
 
 QString QtPassSettings::getPassExecutable(const QString &defaultValue)
 {
-    return getStringValue("passExecutable", defaultValue);
+    return getStringValue(SettingsConstants::passExecutable, defaultValue);
 }
 
 void QtPassSettings::setPassExecutable(const QString &passExecutable)
 {
-    setStringValue("passExecutable", passExecutable);
+    setStringValue(SettingsConstants::passExecutable, passExecutable);
 }
 
 QString QtPassSettings::getGitExecutable(const QString &defaultValue)
 {
-    return getStringValue("gitExecutable", defaultValue);
+    return getStringValue(SettingsConstants::gitExecutable, defaultValue);
 }
 
 void QtPassSettings::setGitExecutable(const QString &gitExecutable)
 {
-    setStringValue("gitExecutable", gitExecutable);
+    setStringValue(SettingsConstants::gitExecutable, gitExecutable);
 }
 
 QString QtPassSettings::getGpgExecutable(const QString &defaultValue)
 {
-    return getStringValue("gpgExecutable", defaultValue);
+    return getStringValue(SettingsConstants::gpgExecutable, defaultValue);
 }
 
 void QtPassSettings::setGpgExecutable(const QString &gpgExecutable)
 {
-    setStringValue("gpgExecutable", gpgExecutable);
+    setStringValue(SettingsConstants::gpgExecutable, gpgExecutable);
 }
 
 QString QtPassSettings::getPwgenExecutable(const QString &defaultValue)
 {
-    return getStringValue("pwgenExecutable", defaultValue);
+    return getStringValue(SettingsConstants::pwgenExecutable, defaultValue);
 }
 
 void QtPassSettings::setPwgenExecutable(const QString &pwgenExecutable)
 {
-    setStringValue("pwgenExecutable", pwgenExecutable);
+    setStringValue(SettingsConstants::pwgenExecutable, pwgenExecutable);
 }
 
 QString QtPassSettings::getGpgHome(const QString &defaultValue)
 {
-    return getStringValue("gpgHome", defaultValue);
+    return getStringValue(SettingsConstants::gpgHome, defaultValue);
 }
 
 void QtPassSettings::setGpgHome(const QString &gpgHome)
 {
-    setStringValue("gpgHome", gpgHome);
+    setStringValue(SettingsConstants::gpgHome, gpgHome);
 }
 
 bool QtPassSettings::isUseWebDav(const bool &defaultValue)
 {
-    return getBoolValue("useWebDav", defaultValue);
+    return getBoolValue(SettingsConstants::useWebDav, defaultValue);
 }
 
 void QtPassSettings::setUseWebDav(const bool &useWebDav)
 {
-    setBoolValue("useWebDav", useWebDav);
+    setBoolValue(SettingsConstants::useWebDav, useWebDav);
 }
 
 QString QtPassSettings::getWebDavUrl(const QString &defaultValue)
 {
-    return getStringValue("webDavUrl", defaultValue);
+    return getStringValue(SettingsConstants::webDavUrl, defaultValue);
 }
 
 void QtPassSettings::setWebDavUrl(const QString &webDavUrl)
 {
-    setStringValue("webDavUrl", webDavUrl);
+    setStringValue(SettingsConstants::webDavUrl, webDavUrl);
 }
 
 QString QtPassSettings::getWebDavUser(const QString &defaultValue)
 {
-    return getStringValue("webDavUser", defaultValue);
+    return getStringValue(SettingsConstants::webDavUser, defaultValue);
 }
 
 void QtPassSettings::setWebDavUser(const QString &webDavUser)
 {
-    setStringValue("webDavUser", webDavUser);
+    setStringValue(SettingsConstants::webDavUser, webDavUser);
 }
 
 QString QtPassSettings::getWebDavPassword(const QString &defaultValue)
 {
-    return getStringValue("webDavPassword", defaultValue);
+    return getStringValue(SettingsConstants::webDavPassword, defaultValue);
 }
 
 void QtPassSettings::setWebDavPassword(const QString &webDavPassword)
 {
-    setStringValue("webDavPassword", webDavPassword);
+    setStringValue(SettingsConstants::webDavPassword, webDavPassword);
 }
 
 QString QtPassSettings::getProfile(const QString &defaultValue)
 {
-    return getStringValue("profile", defaultValue);
+    return getStringValue(SettingsConstants::profile, defaultValue);
 }
 
 void QtPassSettings::setProfile(const QString &profile)
 {
-    setStringValue("profile", profile);
+    setStringValue(SettingsConstants::profile, profile);
 }
 
 bool QtPassSettings::isUseGit(const bool &defaultValue)
 {
-    return getBoolValue("useGit", defaultValue);
+    return getBoolValue(SettingsConstants::useGit, defaultValue);
 }
 
 void QtPassSettings::setUseGit(const bool &useGit)
 {
-    setBoolValue("useGit", useGit);
+    setBoolValue(SettingsConstants::useGit, useGit);
 }
 
 bool QtPassSettings::isUsePwgen(const bool &defaultValue)
 {
-    return getBoolValue("usePwgen", defaultValue);
+    return getBoolValue(SettingsConstants::usePwgen, defaultValue);
 }
 
 void QtPassSettings::setUsePwgen(const bool &usePwgen)
 {
-    setBoolValue("usePwgen", usePwgen);
+    setBoolValue(SettingsConstants::usePwgen, usePwgen);
 }
 
 bool QtPassSettings::isAvoidCapitals(const bool &defaultValue)
 {
-    return getBoolValue("avoidCapitals", defaultValue);
+    return getBoolValue(SettingsConstants::avoidCapitals, defaultValue);
 }
 
 void QtPassSettings::setAvoidCapitals(const bool &avoidCapitals)
 {
-    setBoolValue("avoidCapitals", avoidCapitals);
+    setBoolValue(SettingsConstants::avoidCapitals, avoidCapitals);
 }
 
 bool QtPassSettings::isAvoidNumbers(const bool &defaultValue)
 {
-    return getBoolValue("avoidNumbers", defaultValue);
+    return getBoolValue(SettingsConstants::avoidNumbers, defaultValue);
 }
 
 void QtPassSettings::setAvoidNumbers(const bool &avoidNumbers)
 {
-    setBoolValue("avoidNumbers", avoidNumbers);
+    setBoolValue(SettingsConstants::avoidNumbers, avoidNumbers);
 }
 
 bool QtPassSettings::isLessRandom(const bool &defaultValue)
 {
-    return getBoolValue("lessRandom", defaultValue);
+    return getBoolValue(SettingsConstants::lessRandom, defaultValue);
 }
 
 void QtPassSettings::setLessRandom(const bool &lessRandom)
 {
-    setBoolValue("lessRandom", lessRandom);
+    setBoolValue(SettingsConstants::lessRandom, lessRandom);
 }
 
 bool QtPassSettings::isUseSymbols(const bool &defaultValue)
 {
-    return getBoolValue("useSymbols", defaultValue);
+    return getBoolValue(SettingsConstants::useSymbols, defaultValue);
 }
 
 void QtPassSettings::setUseSymbols(const bool &useSymbols)
 {
-    setBoolValue("useSymbols", useSymbols);
+    setBoolValue(SettingsConstants::useSymbols, useSymbols);
 }
 
 int QtPassSettings::getPasswordCharsSelected(const int &defaultValue)
 {
-    return getIntValue("passwordCharsSelected", defaultValue);
+    return getIntValue(SettingsConstants::passwordCharsSelected, defaultValue);
 }
 
 void QtPassSettings::setPasswordCharsSelected(const int &passwordCharsSelected)
 {
-    setIntValue("passwordCharsSelected", passwordCharsSelected);
+    setIntValue(SettingsConstants::passwordCharsSelected, passwordCharsSelected);
 }
 
 int QtPassSettings::getPasswordLength(const int &defaultValue)
 {
-    return getIntValue("passwordLength", defaultValue);
+    return getIntValue(SettingsConstants::passwordLength, defaultValue);
 }
 
 void QtPassSettings::setPasswordLength(const int &passwordLength)
 {
-    setIntValue("passwordLength", passwordLength);
+    setIntValue(SettingsConstants::passwordLength, passwordLength);
 }
 
 int QtPassSettings::getPasswordCharsselection(const int &defaultValue)
 {
-    return getIntValue("passwordCharsselection", defaultValue);
+    return getIntValue(SettingsConstants::passwordCharsselection, defaultValue);
 }
 
 void QtPassSettings::setPasswordCharsselection(const int &passwordCharsselection)
 {
-    setIntValue("passwordCharsselection", passwordCharsselection);
+    setIntValue(SettingsConstants::passwordCharsselection, passwordCharsselection);
 }
 
 QString QtPassSettings::getPasswordChars(const QString &defaultValue)
 {
-    return getStringValue("passwordChars", defaultValue);
+    return getStringValue(SettingsConstants::passwordChars, defaultValue);
 }
 
 void QtPassSettings::setPasswordChars(const QString &passwordChars)
 {
-    setStringValue("passwordChars", passwordChars);
+    setStringValue(SettingsConstants::passwordChars, passwordChars);
 }
 
 bool QtPassSettings::isUseTrayIcon(const bool &defaultValue)
 {
-    return getBoolValue("useTrayIcon", defaultValue);
+    return getBoolValue(SettingsConstants::useTrayIcon, defaultValue);
 }
 
 void QtPassSettings::setUseTrayIcon(const bool &useTrayIcon)
 {
-    setBoolValue("useTrayIcon", useTrayIcon);
+    setBoolValue(SettingsConstants::useTrayIcon, useTrayIcon);
 }
 
 bool QtPassSettings::isHideOnClose(const bool &defaultValue)
 {
-    return getBoolValue("hideOnClose", defaultValue);
+    return getBoolValue(SettingsConstants::hideOnClose, defaultValue);
 }
 
 void QtPassSettings::setHideOnClose(const bool &hideOnClose)
 {
-    setBoolValue("hideOnClose", hideOnClose);
+    setBoolValue(SettingsConstants::hideOnClose, hideOnClose);
 }
 
 bool QtPassSettings::isStartMinimized(const bool &defaultValue)
 {
-    return getBoolValue("startMinimized", defaultValue);
+    return getBoolValue(SettingsConstants::startMinimized, defaultValue);
 }
 
 void QtPassSettings::setStartMinimized(const bool &startMinimized)
 {
-    setBoolValue("startMinimized", startMinimized);
+    setBoolValue(SettingsConstants::startMinimized, startMinimized);
 }
 
 bool QtPassSettings::isAlwaysOnTop(const bool &defaultValue)
 {
-    return getBoolValue("alwaysOnTop", defaultValue);
+    return getBoolValue(SettingsConstants::alwaysOnTop, defaultValue);
 }
 
 void QtPassSettings::setAlwaysOnTop(const bool &alwaysOnTop)
 {
-    setBoolValue("alwaysOnTop", alwaysOnTop);
+    setBoolValue(SettingsConstants::alwaysOnTop, alwaysOnTop);
 }
 
 bool QtPassSettings::isAutoPull(const bool &defaultValue)
 {
-    return getBoolValue("autoPull", defaultValue);
+    return getBoolValue(SettingsConstants::autoPull, defaultValue);
 }
 
 void QtPassSettings::setAutoPull(const bool &autoPull)
 {
-    setBoolValue("autoPull", autoPull);
+    setBoolValue(SettingsConstants::autoPull, autoPull);
 }
 
 bool QtPassSettings::isAutoPush(const bool &defaultValue)
 {
-    return getBoolValue("autoPush", defaultValue);
+    return getBoolValue(SettingsConstants::autoPush, defaultValue);
 }
 
 void QtPassSettings::setAutoPush(const bool &autoPush)
 {
-    setBoolValue("autoPush", autoPush);
+    setBoolValue(SettingsConstants::autoPush, autoPush);
 }
 
 QString QtPassSettings::getPassTemplate(const QString &defaultValue)
 {
-    return getStringValue("passTemplate", defaultValue);
+    return getStringValue(SettingsConstants::passTemplate, defaultValue);
 }
 
 void QtPassSettings::setPassTemplate(const QString &passTemplate)
 {
-    setStringValue("passTemplate", passTemplate);
+    setStringValue(SettingsConstants::passTemplate, passTemplate);
 }
 
 bool QtPassSettings::isUseTemplate(const bool &defaultValue)
 {
-    return getBoolValue("useTemplate", defaultValue);
+    return getBoolValue(SettingsConstants::useTemplate, defaultValue);
 }
 
 void QtPassSettings::setUseTemplate(const bool &useTemplate)
 {
-    setBoolValue("useTemplate", useTemplate);
+    setBoolValue(SettingsConstants::useTemplate, useTemplate);
 }
 
 bool QtPassSettings::isTemplateAllFields(const bool &defaultValue)
 {
-    return getBoolValue("templateAllFields", defaultValue);
+    return getBoolValue(SettingsConstants::templateAllFields, defaultValue);
 }
 
 void QtPassSettings::setTemplateAllFields(const bool &templateAllFields)
 {
-    setBoolValue("templateAllFields", templateAllFields);
+    setBoolValue(SettingsConstants::templateAllFields, templateAllFields);
 }
 
 QStringList QtPassSettings::getChildKeysFromCurrentGroup()
@@ -559,8 +573,8 @@ QHash<QString, QString> QtPassSettings::getProfiles()
 
 void QtPassSettings::setProfiles(QHash<QString, QString> &profiles)
 {
-    getSettings().remove("profiles");
-    beginSettingsGroup("profiles");
+    getSettings().remove(SettingsConstants::groupProfiles);
+    beginProfilesGroup();
     QHash<QString, QString>::iterator i=profiles.begin();
     for(; i !=profiles.end(); ++i)
     {
@@ -704,13 +718,13 @@ void QtPassSettings::endSettingsGroup()
 
 void QtPassSettings::beginMainwindowGroup()
 {
-    getSettings().beginGroup("mainwindow");
+    getSettings().beginGroup(SettingsConstants::groupMainwindow);
 
 }
 
 void QtPassSettings::beginProfilesGroup()
 {
-    getSettings().beginGroup("profiles");
+    getSettings().beginGroup(SettingsConstants::groupProfiles);
 
 }
 
diff --git a/settingsconstants.cpp b/settingsconstants.cpp
index 3386e0f1..f4b154c7 100644
--- a/settingsconstants.cpp
+++ b/settingsconstants.cpp
@@ -54,4 +54,4 @@ const QString SettingsConstants::autoPush = "autoPush";
 const QString SettingsConstants::passTemplate = "passTemplate";
 const QString SettingsConstants::useTemplate = "useTemplate";
 const QString SettingsConstants::templateAllFields = "templateAllFields";
-
+const QString SettingsConstants::clipBoardType = "clipBoardType";
diff --git a/settingsconstants.h b/settingsconstants.h
index f452976f..bcaea567 100644
--- a/settingsconstants.h
+++ b/settingsconstants.h
@@ -56,6 +56,7 @@ public:
     const static QString passTemplate;
     const static QString useTemplate;
     const static QString templateAllFields;
+    const static QString clipBoardType;
 
 private:
     explicit SettingsConstants();