added new Settings class

10 files changed, 757 insertions, 32 deletions

diff --git a/configdialog.cpp b/configdialog.cpp
index 0c3f79e1..15ea86e8 100644
--- a/configdialog.cpp
+++ b/configdialog.cpp
@@ -257,7 +257,7 @@ void ConfigDialog::on_checkBoxAutoclearPanel_clicked() {
 /**
  * @brief ConfigDialog::useClipboard set the clipboard use from MainWindow.
  */
-void ConfigDialog::useClipboard(MainWindow::clipBoardType useClipboard) {
+void ConfigDialog::useClipboard(Enums::clipBoardType useClipboard) {
   ui->comboBoxClipboard->setCurrentIndex(static_cast<int>(useClipboard));
   on_comboBoxClipboard_activated(static_cast<int>(useClipboard));
 }
@@ -304,8 +304,8 @@ void ConfigDialog::setAutoclearPanel(int seconds) {
  * @brief ConfigDialog::useClipboard set the use of clipboard from MainWindow.
  * @return
  */
-MainWindow::clipBoardType ConfigDialog::useClipboard() {
-  return static_cast<MainWindow::clipBoardType>(
+Enums::clipBoardType ConfigDialog::useClipboard() {
+  return static_cast<Enums::clipBoardType>(
       ui->comboBoxClipboard->currentIndex());
 }
 
diff --git a/configdialog.h b/configdialog.h
index 43f4136c..e9f4a121 100644
--- a/configdialog.h
+++ b/configdialog.h
@@ -31,7 +31,7 @@ public:
   void setStorePath(QString);
   void setProfiles(QHash<QString, QString>, QString);
   void usePass(bool usePass);
-  void useClipboard(MainWindow::clipBoardType);
+  void useClipboard(Enums::clipBoardType);
   void useAutoclear(bool useAutoclear);
   void setAutoclear(int seconds);
   void useAutoclearPanel(bool useAutoclearPanel);
@@ -45,7 +45,7 @@ public:
   QString getStorePath();
   QHash<QString, QString> getProfiles();
   bool usePass();
-  MainWindow::clipBoardType useClipboard();
+  Enums::clipBoardType useClipboard();
   bool useAutoclear();
   int getAutoclear();
   bool useAutoclearPanel();
diff --git a/enums.cpp b/enums.cpp
new file mode 100644
index 00000000..4abc3f6c
--- /dev/null
+++ b/enums.cpp
@@ -0,0 +1 @@
+#include "enums.h"
diff --git a/enums.h b/enums.h
new file mode 100644
index 00000000..5c9f0ead
--- /dev/null
+++ b/enums.h
@@ -0,0 +1,21 @@
+#ifndef ENUMS_H
+#define ENUMS_H
+
+
+class Enums
+{
+public:
+    /**
+     * @brief MainWindow::clipBoardType enum
+     * 0 Never
+     * 1 Always
+     * 2 On demand
+     */
+    enum clipBoardType {
+      CLIPBOARD_NEVER = 0,
+      CLIPBOARD_ALWAYS = 1,
+      CLIPBOARD_ON_DEMAND = 2
+    };
+};
+
+#endif // ENUMS_H
diff --git a/mainwindow.cpp b/mainwindow.cpp
index 56371e45..7f0eb891 100644
--- a/mainwindow.cpp
+++ b/mainwindow.cpp
@@ -226,12 +226,6 @@ bool MainWindow::checkConfig() {
 
   usePass = (settings.value("usePass") == "true");
 
-  useClipboard = CLIPBOARD_NEVER;
-  if (settings.value("useClipboard") == "true" ||
-      settings.value("useClipboard") == "1")
-    useClipboard = CLIPBOARD_ALWAYS;
-  else if (settings.value("useClipboard") == "2")
-    useClipboard = CLIPBOARD_ON_DEMAND;
   useAutoclear = (settings.value("useAutoclear") == "true");
   autoclearSeconds = settings.value("autoclearSeconds").toInt();
   useAutoclearPanel = (settings.value("useAutoclearPanel") == "true");
@@ -517,10 +511,10 @@ void MainWindow::config() {
       settings.setValue("passStore", passStore);
       settings.setValue("usePass", usePass ? "true" : "false");
       switch (useClipboard) {
-      case CLIPBOARD_ALWAYS:
+      case Enums::CLIPBOARD_ALWAYS:
         settings.setValue("useClipboard", "true");
         break;
-      case CLIPBOARD_ON_DEMAND:
+      case Enums::CLIPBOARD_ON_DEMAND:
         settings.setValue("useClipboard", "2");
         break;
       default:
@@ -813,9 +807,9 @@ void MainWindow::readyRead(bool finished = false) {
       QStringList tokens = output.split("\n");
       QString password = tokens.at(0);
 
-      if (useClipboard != CLIPBOARD_NEVER && !output.isEmpty()) {
+      if (useClipboard != Enums::CLIPBOARD_NEVER && !output.isEmpty()) {
         clippedText=tokens[0];
-        if (useClipboard == CLIPBOARD_ALWAYS)
+        if (useClipboard == Enums::CLIPBOARD_ALWAYS)
           copyTextToClipboard(tokens[0]);
         if (useAutoclearPanel) {
           QTimer::singleShot(1000 * autoclearPanelSeconds, this,
@@ -1876,7 +1870,7 @@ void MainWindow::editPassword() {
  * generator
  * @return the password
  */
-QString MainWindow::generatePassword(int length, clipBoardType selection) {
+QString MainWindow::generatePassword(int length, Enums::clipBoardType selection) {
   QString passwd;
   if (usePwgen) {
     waitFor(2);
diff --git a/mainwindow.h b/mainwindow.h
index 7462c61a..d64f099f 100644
--- a/mainwindow.h
+++ b/mainwindow.h
@@ -3,6 +3,7 @@
 
 #include "storemodel.h"
 #include "trayicon.h"
+#include "enums.h"
 #include <QFileSystemModel>
 #include <QMainWindow>
 #include <QProcess>
@@ -10,6 +11,7 @@
 #include <QSettings>
 #include <QTimer>
 #include <QTreeView>
+
 #if SINGLE_APP
 #include "singleapplication.h"
 #else
@@ -87,17 +89,6 @@ class MainWindow : public QMainWindow {
   enum actionType { GPG, GIT, EDIT, DELETE, GPG_INTERNAL, PWGEN };
 
 public:
-  /**
-   * @brief MainWindow::clipBoardType enum
-   * 0 Never
-   * 1 Always
-   * 2 On demand
-   */
-  enum clipBoardType {
-    CLIPBOARD_NEVER = 0,
-    CLIPBOARD_ALWAYS = 1,
-    CLIPBOARD_ON_DEMAND = 2
-  };
 
   explicit MainWindow(QWidget *parent = 0);
   ~MainWindow();
@@ -111,7 +102,7 @@ public:
   QStringList getSecretKeys();
   void generateKeyPair(QString, QDialog *);
   void userDialog(QString = "");
-  QString generatePassword(int length, clipBoardType selection);
+  QString generatePassword(int length, Enums::clipBoardType selection);
   void config();
   void executePassGitInit();
   void copyTextToClipboard(const QString &text);
@@ -172,7 +163,7 @@ private:
   QScopedPointer<QProcess> process;
   QTreeView *treeView;
   bool usePass;
-  clipBoardType useClipboard;
+  Enums::clipBoardType useClipboard;
   bool useAutoclear;
   bool useAutoclearPanel;
   bool hidePassword;
diff --git a/passworddialog.cpp b/passworddialog.cpp
index 1c91f7e2..fbbcb792 100644
--- a/passworddialog.cpp
+++ b/passworddialog.cpp
@@ -41,7 +41,7 @@ void PasswordDialog::on_createPasswordButton_clicked() {
   ui->widget->setEnabled(false);
   ui->lineEditPassword->setText(mainWindow->generatePassword(
       ui->spinBox_pwdLength->value(),
-      (MainWindow::clipBoardType)ui->passwordTemplateSwitch->currentIndex()));
+      (Enums::clipBoardType)ui->passwordTemplateSwitch->currentIndex()));
   ui->widget->setEnabled(true);
 }
 
diff --git a/qtpass.pro b/qtpass.pro
index f64ca412..a7ac4441 100644
--- a/qtpass.pro
+++ b/qtpass.pro
@@ -32,7 +32,9 @@ SOURCES   += main.cpp\
              trayicon.cpp \
              passworddialog.cpp \
              qprogressindicator.cpp \
-             qpushbuttonwithclipboard.cpp
+             qpushbuttonwithclipboard.cpp \
+             qtpasssettings.cpp \
+             enums.cpp
 
 HEADERS   += mainwindow.h \
              configdialog.h \
@@ -44,7 +46,9 @@ HEADERS   += mainwindow.h \
              passworddialog.h \
              qprogressindicator.h \
              deselectabletreeview.h \
-             qpushbuttonwithclipboard.h
+             qpushbuttonwithclipboard.h \
+             qtpasssettings.h \
+             enums.h
 
 FORMS     += mainwindow.ui \
              configdialog.ui \
diff --git a/qtpasssettings.cpp b/qtpasssettings.cpp
new file mode 100644
index 00000000..645e0bde
--- /dev/null
+++ b/qtpasssettings.cpp
@@ -0,0 +1,525 @@
+#include "qtpasssettings.h"
+
+QtPassSettings::QtPassSettings(QObject *parent) : QObject(parent)
+{
+
+}
+
+QString QtPassSettings::getVersion(const QString &defaultValue)
+{
+    return getStringValue("version", defaultValue);
+}
+
+QString QtPassSettings::setVersion(const QString &version)
+{
+
+}
+
+QByteArray QtPassSettings::getGeometry(const QByteArray &defaultValue)
+{
+    return getByteArrayValue("geometry", defaultValue);
+}
+
+QByteArray QtPassSettings::setGeometry(const QByteArray &geometry)
+{
+
+}
+
+QByteArray QtPassSettings::getSavestate(const QByteArray &defaultValue)
+{
+    return getByteArrayValue("savestate", defaultValue);
+}
+
+QByteArray QtPassSettings::setSavestate(const QByteArray &saveState)
+{
+
+}
+
+QPoint QtPassSettings::getPos(const QPoint &defaultValue)
+{
+    return getPointValue("pos", defaultValue);
+}
+
+QPoint QtPassSettings::setPos(const QPoint &pos)
+{
+
+}
+
+QSize QtPassSettings::getSize(const QSize &defaultValue)
+{
+    return getSizeValue("size", defaultValue);
+}
+
+QSize QtPassSettings::setSize(const QSize &size)
+{
+
+}
+
+int QtPassSettings::getSplitterLeft(const int &defaultValue)
+{
+    return getIntValue("splitterLeft", defaultValue);
+}
+
+int QtPassSettings::setSplitterLeft(const int &splitterLeft)
+{
+
+}
+
+int QtPassSettings::getSplitterRight(const int &defaultValue)
+{
+    return getIntValue("splitterRight", defaultValue);
+}
+
+int QtPassSettings::setSplitterRight(const int &splitterRight)
+{
+
+}
+
+bool QtPassSettings::isMaximized(const bool &defaultValue)
+{
+    return getBoolValue("maximized", defaultValue);
+}
+
+bool QtPassSettings::setMaximized(const bool &maximized)
+{
+
+}
+
+bool QtPassSettings::isUsePass(const bool &defaultValue)
+{
+    return getBoolValue("usePass", defaultValue);
+}
+
+bool QtPassSettings::setUsePass(const bool &usePass)
+{
+
+}
+
+Enums::clipBoardType QtPassSettings::getClipBoardType(const Enums::clipBoardType &defaultvalue)
+{
+    return static_cast<Enums::clipBoardType>(getIntValue("clipBoardType",static_cast<int>(defaultvalue)));
+}
+
+Enums::clipBoardType QtPassSettings::setClipBoardType(const Enums::clipBoardType &clipBoardType)
+{
+
+}
+
+bool QtPassSettings::isUseAutoclear(const bool &defaultValue)
+{
+    return getBoolValue("useAutoclear", defaultValue);
+}
+
+bool QtPassSettings::setUseAutoclear(const bool &useAutoclear)
+{
+
+}
+
+int QtPassSettings::getAutoclearSeconds(const int &defaultValue)
+{
+    return getIntValue("autoclearSeconds", defaultValue);
+}
+
+int QtPassSettings::setAutoclearSeconds(const int &autoClearSeconds)
+{
+
+}
+
+bool QtPassSettings::isUseAutoclearPanel(const bool &defaultValue)
+{
+    return getBoolValue("useAutoclearPanel", defaultValue);
+}
+
+bool QtPassSettings::setUseAutoclearPanel(const bool &useAutoclearPanel)
+{
+
+}
+
+int QtPassSettings::getAutoclearPanelSeconds(const int &defaultValue)
+{
+    return getIntValue("autoclearPanelSeconds", defaultValue);
+}
+
+int QtPassSettings::setAutoclearPanelSeconds(const int &autoClearPanelSeconds)
+{
+
+}
+
+bool QtPassSettings::isHidePassword(const bool &defaultValue)
+{
+    return getBoolValue("hidePassword", defaultValue);
+}
+
+bool QtPassSettings::setHidePassword(const bool &hidePassword)
+{
+
+}
+
+bool QtPassSettings::isHideContent(const bool &defaultValue)
+{
+    return getBoolValue("hideContent", defaultValue);
+}
+
+bool QtPassSettings::setHideContent(const bool &hideContent)
+{
+
+}
+
+bool QtPassSettings::isAddGPGId(const bool &defaultValue)
+{
+    return getBoolValue("addGPGId", defaultValue);
+}
+
+bool QtPassSettings::setAddGPGId(const bool &addGPGId)
+{
+
+}
+
+QString QtPassSettings::getPassStore(const QString &defaultValue)
+{
+    return getStringValue("passStore", defaultValue);
+}
+
+QString QtPassSettings::setPassStore(const QString &passStore)
+{
+
+}
+
+QString QtPassSettings::getPassExecutable(const QString &defaultValue)
+{
+    return getStringValue("passExecutable", defaultValue);
+}
+
+QString QtPassSettings::setPassExecutable(const QString &passExecutable)
+{
+
+}
+
+QString QtPassSettings::getGitExecutable(const QString &defaultValue)
+{
+    return getStringValue("gitExecutable", defaultValue);
+}
+
+QString QtPassSettings::setGitExecutable(const QString &gitExecutable)
+{
+
+}
+
+QString QtPassSettings::getGpgExecutable(const QString &defaultValue)
+{
+    return getStringValue("gpgExecutable", defaultValue);
+}
+
+QString QtPassSettings::setGpgExecutable(const QString &gpgExecutable)
+{
+
+}
+
+QString QtPassSettings::getPwgenExecutable(const QString &defaultValue)
+{
+    return getStringValue("pwgenExecutable", defaultValue);
+}
+
+QString QtPassSettings::setPwgenExecutable(const QString &pwgenExecutable)
+{
+
+}
+
+QString QtPassSettings::getGpgHome(const QString &defaultValue)
+{
+    return getStringValue("gpgHome", defaultValue);
+}
+
+QString QtPassSettings::setGpgHome(const QString &gpgHome)
+{
+
+}
+
+bool QtPassSettings::isUseWebDav(const bool &defaultValue)
+{
+    return getBoolValue("useWebDav", defaultValue);
+}
+
+bool QtPassSettings::setUseWebDav(const bool &useWebDav)
+{
+
+}
+
+QString QtPassSettings::getWebDavUrl(const QString &defaultValue)
+{
+    return getStringValue("webDavUrl", defaultValue);
+}
+
+QString QtPassSettings::setWebDavUrl(const QString &webDavUrl)
+{
+
+}
+
+QString QtPassSettings::getWebDavUser(const QString &defaultValue)
+{
+    return getStringValue("webDavUser", defaultValue);
+}
+
+QString QtPassSettings::setWebDavUser(const QString &webDavUser)
+{
+
+}
+
+QString QtPassSettings::getWebDavPassword(const QString &defaultValue)
+{
+    return getStringValue("webDavPassword", defaultValue);
+}
+
+QString QtPassSettings::setWebDavPassword(const QString &webDavPassword)
+{
+
+}
+
+QString QtPassSettings::getProfile(const QString &defaultValue)
+{
+    return getStringValue("profile", defaultValue);
+}
+
+QString QtPassSettings::setProfile(const QString &profile)
+{
+
+}
+
+bool QtPassSettings::isUseGit(const bool &defaultValue)
+{
+    return getBoolValue("useGit", defaultValue);
+}
+
+bool QtPassSettings::setUseGit(const bool &useGit)
+{
+
+}
+
+bool QtPassSettings::isUsePwgen(const bool &defaultValue)
+{
+    return getBoolValue("usePwgen", defaultValue);
+}
+
+bool QtPassSettings::setUsePwgen(const bool &usePwgen)
+{
+
+}
+
+bool QtPassSettings::isAvoidCapitals(const bool &defaultValue)
+{
+    return getBoolValue("avoidCapitals", defaultValue);
+}
+
+bool QtPassSettings::setAvoidCapitals(const bool &avoidCapitals)
+{
+
+}
+
+bool QtPassSettings::isAvoidNumbers(const bool &defaultValue)
+{
+    return getBoolValue("avoidNumbers", defaultValue);
+}
+
+bool QtPassSettings::setAvoidNumbers(const bool &AvoidNumbers)
+{
+
+}
+
+bool QtPassSettings::isLessRandom(const bool &defaultValue)
+{
+    return getBoolValue("lessRandom", defaultValue);
+}
+
+bool QtPassSettings::setLessRandom(const bool &lessRandom)
+{
+
+}
+
+bool QtPassSettings::isUseSymbols(const bool &defaultValue)
+{
+    return getBoolValue("useSymbols", defaultValue);
+}
+
+bool QtPassSettings::setUseSymbols(const bool &useSymbols)
+{
+
+}
+
+int QtPassSettings::getPasswordCharsSelected(const int &defaultValue)
+{
+    return getIntValue("passwordCharsSelected", defaultValue);
+}
+
+int QtPassSettings::setPasswordCharsSelected(const int &passwordCharsSelected)
+{
+
+}
+
+int QtPassSettings::getPasswordLength(const int &defaultValue)
+{
+    return getIntValue("passwordLength", defaultValue);
+}
+
+int QtPassSettings::setPasswordLength(const int &passwordLength)
+{
+
+}
+
+int QtPassSettings::getPasswordCharsselection(const int &defaultValue)
+{
+    return getIntValue("passwordCharsselection", defaultValue);
+}
+
+int QtPassSettings::setPasswordCharsselection(const int &passwordCharsselection)
+{
+
+}
+
+QString QtPassSettings::getPasswordChars(const QString &defaultValue)
+{
+    return getStringValue("passwordChars", defaultValue);
+}
+
+QString QtPassSettings::setPasswordChars(const QString &passwordChars)
+{
+
+}
+
+bool QtPassSettings::isUseTrayIcon(const bool &defaultValue)
+{
+    return getBoolValue("useTrayIcon", defaultValue);
+}
+
+bool QtPassSettings::setUseTrayIcon(const bool &useTrayIcon)
+{
+
+}
+
+bool QtPassSettings::isHideOnClose(const bool &defaultValue)
+{
+    return getBoolValue("hideOnClose", defaultValue);
+}
+
+bool QtPassSettings::setHideOnClose(const bool &hideOnClose)
+{
+
+}
+
+bool QtPassSettings::isStartMinimized(const bool &defaultValue)
+{
+    return getBoolValue("startMinimized", defaultValue);
+}
+
+bool QtPassSettings::setStartMinimized(const bool &startMinimized)
+{
+
+}
+
+bool QtPassSettings::isAlwaysOnTop(const bool &defaultValue)
+{
+    return getBoolValue("alwaysOnTop", defaultValue);
+}
+
+bool QtPassSettings::setAlwaysOnTop(const bool &alwaysOnTop)
+{
+
+}
+
+bool QtPassSettings::isAutoPull(const bool &defaultValue)
+{
+    return getBoolValue("autoPull", defaultValue);
+}
+
+bool QtPassSettings::setAutoPull(const bool &autoPull)
+{
+
+}
+
+bool QtPassSettings::isAutoPush(const bool &defaultValue)
+{
+    return getBoolValue("autoPush", defaultValue);
+}
+
+bool QtPassSettings::setAutoPush(const bool &autoPush)
+{
+
+}
+
+QString QtPassSettings::getPassTemplate(const QString &defaultValue)
+{
+    return getStringValue("passTemplate", defaultValue);
+}
+
+QString QtPassSettings::setPassTemplate(const QString &passTemplate)
+{
+
+}
+
+bool QtPassSettings::isUseTemplate(const bool &defaultValue)
+{
+    return getBoolValue("useTemplate", defaultValue);
+}
+
+bool QtPassSettings::setUseTemplate(const bool &useTemplate)
+{
+
+}
+
+bool QtPassSettings::isTemplateAllFields(const bool &defaultValue)
+{
+    return getBoolValue("templateAllFields", defaultValue);
+}
+
+bool QtPassSettings::setTemplateAllFields(const bool &templateAllFields)
+{
+
+}
+
+
+QSettings &QtPassSettings::getSettings() {
+
+  if (!settings) {
+    QString portable_ini = QCoreApplication::applicationDirPath() +
+                           QDir::separator() + "qtpass.ini";
+    // qDebug() << "Settings file: " + portable_ini;
+    if (QFile(portable_ini).exists()) {
+      // qDebug() << "Settings file exists, loading it in";
+      settings.reset(new QSettings(portable_ini, QSettings::IniFormat));
+    } else {
+      // qDebug() << "Settings file does not exist, use defaults";
+      settings.reset(new QSettings("IJHack", "QtPass"));
+    }
+  }
+  return *settings;
+}
+
+QString QtPassSettings::getStringValue(const QString &key, const QString &defaultValue)
+{
+    return getSettings().value(key, defaultValue).toString();
+}
+
+int QtPassSettings::getIntValue(const QString &key, const int &defaultValue)
+{
+    return getSettings().value(key, defaultValue).toInt();
+}
+
+bool QtPassSettings::getBoolValue(const QString &key, const bool &defaultValue)
+{
+    return getSettings().value(key, defaultValue).toBool();
+}
+
+QByteArray QtPassSettings::getByteArrayValue(const QString &key, const QByteArray &defaultValue)
+{
+    return getSettings().value(key, defaultValue).toByteArray();
+}
+
+QPoint QtPassSettings::getPointValue(const QString &key, const QPoint &defaultValue)
+{
+    return getSettings().value(key, defaultValue).toPoint();
+}
+
+QSize QtPassSettings::getSizeValue(const QString &key, const QSize &defaultValue)
+{
+    return getSettings().value(key, defaultValue).toSize();
+}
+
diff --git a/qtpasssettings.h b/qtpasssettings.h
new file mode 100644
index 00000000..29795c83
--- /dev/null
+++ b/qtpasssettings.h
@@ -0,0 +1,189 @@
+#ifndef QTPASSSETTINGS_H
+#define QTPASSSETTINGS_H
+
+#include <QObject>
+#include <QSettings>
+#include <QCoreApplication>
+#include <QFile>
+#include <QDir>
+#include <QVariant>
+#include <QByteArray>
+#include <QPoint>
+#include <QSize>
+
+#include "enums.h"
+#include "mainwindow.h"
+
+
+
+class QtPassSettings : public QObject
+{
+    Q_OBJECT
+public:
+    explicit QtPassSettings(QObject *parent = 0);
+
+    QString getVersion(const QString &defaultValue = QVariant().toString());
+    QString setVersion(const QString &version);
+
+    QByteArray getGeometry(const QByteArray &defaultValue = QVariant().toByteArray());
+    QByteArray setGeometry(const QByteArray &geometry);
+
+    QByteArray getSavestate(const QByteArray &defaultValue = QVariant().toByteArray());
+    QByteArray setSavestate(const QByteArray &saveState);
+
+    QPoint getPos(const QPoint &defaultValue = QVariant().toPoint());
+    QPoint setPos(const QPoint &pos);
+
+    QSize getSize(const QSize &defaultValue = QVariant().toSize());
+    QSize setSize(const QSize &size);
+
+    int getSplitterLeft(const int &defaultValue = QVariant().toInt());
+    int setSplitterLeft(const int &splitterLeft);
+
+    int getSplitterRight(const int &defaultValue = QVariant().toInt());
+    int setSplitterRight(const int &splitterRight);
+
+    bool isMaximized(const bool &defaultValue = QVariant().toBool());
+    bool setMaximized(const bool &maximized);
+
+    bool isUsePass(const bool &defaultValue = QVariant().toBool());
+    bool setUsePass(const bool &usePass);
+
+    Enums::clipBoardType getClipBoardType(const Enums::clipBoardType &defaultvalue = Enums::CLIPBOARD_NEVER);
+    Enums::clipBoardType setClipBoardType(const Enums::clipBoardType &clipBoardType);
+
+    bool isUseAutoclear(const bool &defaultValue = QVariant().toBool());
+    bool setUseAutoclear(const bool &useAutoclear);
+
+    int getAutoclearSeconds(const int &defaultValue = QVariant().toInt());
+    int setAutoclearSeconds(const int &autoClearSeconds);
+
+    bool isUseAutoclearPanel(const bool &defaultValue = QVariant().toBool());
+    bool setUseAutoclearPanel(const bool &useAutoclearPanel);
+
+    int getAutoclearPanelSeconds(const int &defaultValue = QVariant().toInt());
+    int setAutoclearPanelSeconds(const int &autoClearPanelSeconds);
+
+    bool isHidePassword(const bool &defaultValue = QVariant().toBool());
+    bool setHidePassword(const bool &hidePassword);
+
+    bool isHideContent(const bool &defaultValue = QVariant().toBool());
+    bool setHideContent(const bool &hideContent);
+
+    bool isAddGPGId(const bool &defaultValue = QVariant().toBool());
+    bool setAddGPGId(const bool &addGPGId);
+
+    QString getPassStore(const QString &defaultValue = QVariant().toString());
+    QString setPassStore(const QString &passStore);
+
+    QString getPassExecutable(const QString &defaultValue = QVariant().toString());
+    QString setPassExecutable(const QString &passExecutable);
+
+    QString getGitExecutable(const QString &defaultValue = QVariant().toString());
+    QString setGitExecutable(const QString &gitExecutable);
+
+    QString getGpgExecutable(const QString &defaultValue = QVariant().toString());
+    QString setGpgExecutable(const QString &gpgExecutable);
+
+    QString getPwgenExecutable(const QString &defaultValue = QVariant().toString());
+    QString setPwgenExecutable(const QString &pwgenExecutable);
+
+    QString getGpgHome(const QString &defaultValue = QVariant().toString());
+    QString setGpgHome(const QString &gpgHome);
+
+    bool isUseWebDav(const bool &defaultValue = QVariant().toBool());
+    bool setUseWebDav(const bool &useWebDav);
+
+    QString getWebDavUrl(const QString &defaultValue = QVariant().toString());
+    QString setWebDavUrl(const QString &webDavUrl);
+
+    QString getWebDavUser(const QString &defaultValue = QVariant().toString());
+    QString setWebDavUser(const QString &webDavUser);
+
+    QString getWebDavPassword(const QString &defaultValue = QVariant().toString());
+    QString setWebDavPassword(const QString &webDavPassword);
+
+    QString getProfile(const QString &defaultValue = QVariant().toString());
+    QString setProfile(const QString &profile);
+
+    bool isUseGit(const bool &defaultValue = QVariant().toBool());
+    bool setUseGit(const bool &useGit);
+
+    bool isUsePwgen(const bool &defaultValue = QVariant().toBool());
+    bool setUsePwgen(const bool &usePwgen);
+
+    bool isAvoidCapitals(const bool &defaultValue = QVariant().toBool());
+    bool setAvoidCapitals(const bool &avoidCapitals);
+
+    bool isAvoidNumbers(const bool &defaultValue = QVariant().toBool());
+    bool setAvoidNumbers(const bool &AvoidNumbers);
+
+    bool isLessRandom(const bool &defaultValue = QVariant().toBool());
+    bool setLessRandom(const bool &lessRandom);
+
+    bool isUseSymbols(const bool &defaultValue = QVariant().toBool());
+    bool setUseSymbols(const bool &useSymbols);
+
+    int getPasswordCharsSelected(const int &defaultValue = QVariant().toInt());
+    int setPasswordCharsSelected(const int &passwordCharsSelected);
+
+    int getPasswordLength(const int &defaultValue = QVariant().toInt());
+    int setPasswordLength(const int &passwordLength);
+
+    int getPasswordCharsselection(const int &defaultValue = QVariant().toInt());
+    int setPasswordCharsselection(const int &passwordCharsselection);
+
+    QString getPasswordChars(const QString &defaultValue = QVariant().toString());
+    QString setPasswordChars(const QString &passwordChars);
+
+    bool isUseTrayIcon(const bool &defaultValue = QVariant().toBool());
+    bool setUseTrayIcon(const bool &useTrayIcon);
+
+    bool isHideOnClose(const bool &defaultValue = QVariant().toBool());
+    bool setHideOnClose(const bool &hideOnClose);
+
+    bool isStartMinimized(const bool &defaultValue = QVariant().toBool());
+    bool setStartMinimized(const bool &startMinimized);
+
+    bool isAlwaysOnTop(const bool &defaultValue = QVariant().toBool());
+    bool setAlwaysOnTop(const bool &alwaysOnTop);
+
+    bool isAutoPull(const bool &defaultValue = QVariant().toBool());
+    bool setAutoPull(const bool &autoPull);
+
+    bool isAutoPush(const bool &defaultValue = QVariant().toBool());
+    bool setAutoPush(const bool &autoPush);
+
+    QString getPassTemplate(const QString &defaultValue = QVariant().toString());
+    QString setPassTemplate(const QString &passTemplate);
+
+    bool isUseTemplate(const bool &defaultValue = QVariant().toBool());
+    bool setUseTemplate(const bool &useTemplate);
+
+    bool isTemplateAllFields(const bool &defaultValue = QVariant().toBool());
+    bool setTemplateAllFields(const bool &templateAllFields);
+
+signals:
+
+public slots:
+
+private:
+    // member
+    QScopedPointer<QSettings> settings;
+    // functions
+    QSettings &getSettings();
+    QString getStringValue(const QString &key,const QString &defaultValue);
+    int getIntValue(const QString &key, const int &defaultValue);
+    bool getBoolValue(const QString &key, const bool &defaultValue);
+    QByteArray getByteArrayValue(const QString &key, const QByteArray &defaultValue);
+    QPoint getPointValue(const QString &key, const QPoint &defaultValue);
+    QSize getSizeValue(const QString &key, const QSize &defaultValue);
+
+
+
+
+
+
+};
+
+#endif // QTPASSSETTINGS_H