Merge pull request #25 from saturneric/develop

Merge version 2.0.1 beta

1 files changed, 493 insertions, 360 deletions

diff --git a/src/ui/KeyServerImportDialog.cpp b/src/ui/KeyServerImportDialog.cpp
index a1355120..17db7d65 100644
--- a/src/ui/KeyServerImportDialog.cpp
+++ b/src/ui/KeyServerImportDialog.cpp
@@ -1,7 +1,7 @@
 /**
- * This file is part of GPGFrontend.
+ * This file is part of GpgFrontend.
  *
- * GPGFrontend is free software: you can redistribute it and/or modify
+ * GpgFrontend is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
@@ -26,27 +26,32 @@
 
 #include <utility>
 
-KeyServerImportDialog::KeyServerImportDialog(GpgME::GpgContext *ctx, KeyList *keyList, bool automatic,
-                                             QWidget *parent)
-        : QDialog(parent), appPath(qApp->applicationDirPath()),
-          settings(RESOURCE_DIR(appPath) + "/conf/gpgfrontend.ini", QSettings::IniFormat),
-          mCtx(ctx), mKeyList(keyList), mAutomatic(automatic) {
+#include "gpg/function/GpgKeyImportExportor.h"
+#include "ui/SignalStation.h"
+#include "ui/settings/GlobalSettingStation.h"
 
-    if(automatic) {
-        setWindowFlags(Qt::Window | Qt::WindowTitleHint | Qt::CustomizeWindowHint);
-    }
+namespace GpgFrontend::UI {
+
+KeyServerImportDialog::KeyServerImportDialog(bool automatic, QWidget* parent)
+    : QDialog(parent), mAutomatic(automatic) {
+  // Layout for messagebox
+  auto* messageLayout = new QHBoxLayout;
 
+  if (automatic) {
+    setWindowFlags(Qt::Window | Qt::WindowTitleHint | Qt::CustomizeWindowHint);
+  } else {
     // Buttons
-    closeButton = createButton(tr("&Close"), SLOT(close()));
-    importButton = createButton(tr("&Import ALL"), SLOT(slotImport()));
-    searchButton = createButton(tr("&Search"), SLOT(slotSearch()));
+    closeButton = createButton(_("Close"), SLOT(close()));
+    importButton = createButton(_("Import ALL"), SLOT(slotImport()));
+    importButton->setDisabled(true);
+    searchButton = createButton(_("Search"), SLOT(slotSearch()));
 
     // Line edit for search string
-    searchLabel = new QLabel(tr("Search String:"));
+    searchLabel = new QLabel(QString(_("Search String")) + _(": "));
     searchLineEdit = new QLineEdit();
 
     // combobox for keyserverlist
-    keyServerLabel = new QLabel(tr("Key Server:"));
+    keyServerLabel = new QLabel(QString(_("Key Server")) + _(": "));
     keyServerComboBox = createComboBox();
 
     // table containing the keys found
@@ -56,421 +61,549 @@ KeyServerImportDialog::KeyServerImportDialog(GpgME::GpgContext *ctx, KeyList *ke
     icon = new QLabel;
     icon->setFixedHeight(24);
 
-    // Network Waiting
-    waitingBar = new QProgressBar();
-    waitingBar->setVisible(false);
-    waitingBar->setRange(0, 0);
-    waitingBar->setFixedWidth(200);
-
-    // Layout for messagebox
-    auto *messageLayout = new QHBoxLayout;
     messageLayout->addWidget(icon);
     messageLayout->addWidget(message);
-    messageLayout->addWidget(waitingBar);
     messageLayout->addStretch();
+  }
+
+  // Network Waiting
+  waitingBar = new QProgressBar();
+  waitingBar->setVisible(false);
+  waitingBar->setRange(0, 0);
+  waitingBar->setFixedWidth(200);
+  messageLayout->addWidget(waitingBar);
+
+  auto* mainLayout = new QGridLayout;
+
+  // 自动化调用界面布局
+  if (automatic) {
+    mainLayout->addLayout(messageLayout, 0, 0, 1, 3);
+  } else {
+    mainLayout->addWidget(searchLabel, 1, 0);
+    mainLayout->addWidget(searchLineEdit, 1, 1);
+    mainLayout->addWidget(searchButton, 1, 2);
+    mainLayout->addWidget(keyServerLabel, 2, 0);
+    mainLayout->addWidget(keyServerComboBox, 2, 1);
+    mainLayout->addWidget(keysTable, 3, 0, 1, 3);
+    mainLayout->addLayout(messageLayout, 4, 0, 1, 3);
 
     // Layout for import and close button
-    auto *buttonsLayout = new QHBoxLayout;
+    auto* buttonsLayout = new QHBoxLayout;
     buttonsLayout->addStretch();
-    if(!automatic)
-        buttonsLayout->addWidget(importButton);
+    buttonsLayout->addWidget(importButton);
     buttonsLayout->addWidget(closeButton);
-
-    auto *mainLayout = new QGridLayout;
-
-    // 自动化调用界面布局
-    if(automatic) {
-        mainLayout->addLayout(messageLayout, 0, 0, 1, 3);
-    } else {
-        mainLayout->addWidget(searchLabel, 1, 0);
-        mainLayout->addWidget(searchLineEdit, 1, 1);
-        mainLayout->addWidget(searchButton, 1, 2);
-        mainLayout->addWidget(keyServerLabel, 2, 0);
-        mainLayout->addWidget(keyServerComboBox, 2, 1);
-        mainLayout->addWidget(keysTable, 3, 0, 1, 3);
-        mainLayout->addLayout(messageLayout, 4, 0, 1, 3);
-        mainLayout->addLayout(buttonsLayout, 6, 0, 1, 3);
+    mainLayout->addLayout(buttonsLayout, 6, 0, 1, 3);
+  }
+
+  this->setLayout(mainLayout);
+  if (automatic)
+    this->setWindowTitle(_("Update Keys from Keyserver"));
+  else
+    this->setWindowTitle(_("Import Keys from Keyserver"));
+
+  if (automatic) {
+    this->setFixedSize(240, 42);
+  } else {
+    auto pos = QPoint(150, 150);
+    LOG(INFO) << "parent" << parent;
+    if (parent) pos += parent->pos();
+    LOG(INFO) << "pos default" << pos.x() << pos.y();
+    auto size = QSize(800, 500);
+
+    try {
+      auto& settings = GlobalSettingStation::GetInstance().GetUISettings();
+
+      int x, y, width, height;
+      x = settings.lookup("window.import_from_keyserver.position.x");
+      y = settings.lookup("window.import_from_keyserver.position.y");
+      width = settings.lookup("window.import_from_keyserver.size.width");
+      height = settings.lookup("window.import_from_keyserver.size.height");
+      pos = QPoint(x, y);
+      size = QSize(width, height);
+
+    } catch (...) {
+      LOG(WARNING) << "cannot read pos or size from settings";
     }
 
-    this->setLayout(mainLayout);
-    if(automatic)
-        this->setWindowTitle(tr("Update Keys from Keyserver"));
-    else
-        this->setWindowTitle(tr("Import Keys from Keyserver"));
+    this->resize(size);
+    this->move(pos);
+  }
 
-    if(automatic) {
-        this->setFixedSize(240, 42);
-    } else {
-        // Restore window size & location
-        if (this->settings.value("ImportKeyFromServer/setWindowSize").toBool()) {
-            QPoint pos = settings.value("ImportKeyFromServer/pos", QPoint(150, 150)).toPoint();
-            QSize size = settings.value("ImportKeyFromServer/size", QSize(500, 300)).toSize();
-            qDebug() << "Settings size" << size << "pos" << pos;
-            this->setMinimumSize(size);
-            this->move(pos);
-        } else {
-            qDebug() << "Use default min windows size and pos";
-            QPoint defaultPoint(150, 150);
-            QSize defaultMinSize(500, 300);
-            this->setMinimumSize(defaultMinSize);
-            this->move(defaultPoint);
-            this->settings.setValue("ImportKeyFromServer/pos", defaultPoint);
-            this->settings.setValue("ImportKeyFromServer/size", defaultMinSize);
-            this->settings.setValue("ImportKeyFromServer/setWindowSize", true);
-        }
-    }
+  this->setModal(true);
 
-    this->setModal(true);
-}
+  connect(this, SIGNAL(signalKeyImported()), SignalStation::GetInstance(),
+          SIGNAL(KeyDatabaseRefresh()));
 
-QPushButton *KeyServerImportDialog::createButton(const QString &text, const char *member) {
-    auto *button = new QPushButton(text);
-    connect(button, SIGNAL(clicked()), this, member);
-    return button;
+  // save window pos and size to configure file
+  connect(this, SIGNAL(finished(int)), this, SLOT(slotSaveWindowState()));
 }
 
-QComboBox *KeyServerImportDialog::createComboBox() {
-    auto *comboBox = new QComboBox;
-    comboBox->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
+QPushButton* KeyServerImportDialog::createButton(const QString& text,
+                                                 const char* member) {
+  auto* button = new QPushButton(text);
+  connect(button, SIGNAL(clicked()), this, member);
+  return button;
+}
 
-    // Read keylist from ini-file and fill it into combobox
-    comboBox->addItems(settings.value("keyserver/keyServerList").toStringList());
+QComboBox* KeyServerImportDialog::createComboBox() {
+  auto* comboBox = new QComboBox;
+  comboBox->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
 
-    // set default keyserver in combobox
-    QString keyserver = settings.value("keyserver/defaultKeyServer").toString();
-    comboBox->setCurrentIndex(comboBox->findText(keyserver));
+  auto& settings = GlobalSettingStation::GetInstance().GetUISettings();
 
-    return comboBox;
+  try {
+    auto& server_list = settings.lookup("keyserver.server_list");
+    const auto server_list_size = server_list.getLength();
+    for (int i = 0; i < server_list_size; i++) {
+      std::string server_url = server_list[i];
+      comboBox->addItem(server_url.c_str());
+    }
+  } catch (...) {
+    LOG(ERROR) << _("Setting Operation Error") << _("server_list");
+  }
+
+  // set default keyserver in combobox
+  try {
+    std::string default_server = settings.lookup("keyserver.default_server");
+    comboBox->setCurrentText(default_server.c_str());
+  } catch (...) {
+    LOG(ERROR) << _("Setting Operation Error") << _("default_server");
+  }
+
+  return comboBox;
 }
 
 void KeyServerImportDialog::createKeysTable() {
-    keysTable = new QTableWidget();
-    keysTable->setColumnCount(4);
+  keysTable = new QTableWidget();
+  keysTable->setColumnCount(4);
 
-    // always a whole row is marked
-    keysTable->setSelectionBehavior(QAbstractItemView::SelectRows);
-    keysTable->setEditTriggers(QAbstractItemView::NoEditTriggers);
+  // always a whole row is marked
+  keysTable->setSelectionBehavior(QAbstractItemView::SelectRows);
+  keysTable->setEditTriggers(QAbstractItemView::NoEditTriggers);
 
-    // Make just one row selectable
-    keysTable->setSelectionMode(QAbstractItemView::SingleSelection);
+  // Make just one row selectable
+  keysTable->setSelectionMode(QAbstractItemView::SingleSelection);
 
-    QStringList labels;
-    labels << tr("UID") << tr("Creation date") << tr("KeyID") << tr("Tag");
-    keysTable->horizontalHeader()->setSectionResizeMode(0, QHeaderView::ResizeToContents);
-    keysTable->setHorizontalHeaderLabels(labels);
-    keysTable->verticalHeader()->hide();
+  QStringList labels;
+  labels << _("UID") << _("Creation date") << _("KeyID") << _("Tag");
+  keysTable->horizontalHeader()->setSectionResizeMode(
+      0, QHeaderView::ResizeToContents);
+  keysTable->setHorizontalHeaderLabels(labels);
+  keysTable->verticalHeader()->hide();
 
-    connect(keysTable, SIGNAL(cellActivated(int, int)),
-            this, SLOT(slotImport()));
+  connect(keysTable, SIGNAL(cellActivated(int, int)), this, SLOT(slotImport()));
 }
 
-void KeyServerImportDialog::setMessage(const QString &text, bool error) {
-    message->setText(text);
-    if (error) {
-        icon->setPixmap(QPixmap(":error.png").scaled(QSize(24, 24), Qt::KeepAspectRatio));
-    } else {
-        icon->setPixmap(QPixmap(":info.png").scaled(QSize(24, 24), Qt::KeepAspectRatio));
-    }
+void KeyServerImportDialog::setMessage(const QString& text, bool error) {
+  if (mAutomatic) return;
+  
+  message->setText(text);
+  if (error) {
+    icon->setPixmap(
+        QPixmap(":error.png").scaled(QSize(24, 24), Qt::KeepAspectRatio));
+  } else {
+    icon->setPixmap(
+        QPixmap(":info.png").scaled(QSize(24, 24), Qt::KeepAspectRatio));
+  }
 }
 
 void KeyServerImportDialog::slotSearch() {
+  if (searchLineEdit->text().isEmpty()) {
+    setMessage("<h4>" + QString(_("Text is empty.")) + "</h4>", false);
+    return;
+  }
 
-    if (searchLineEdit->text().isEmpty()) {
-        setMessage("<h4>" + tr("Text is empty.") + "</h4>", false);
-        return;
-    }
-
-    QUrl urlFromRemote = keyServerComboBox->currentText() + "/pks/lookup?search=" + searchLineEdit->text() +
+  QUrl url_from_remote = keyServerComboBox->currentText() +
+                         "/pks/lookup?search=" + searchLineEdit->text() +
                          "&op=index&options=mr";
-    qnam = new QNetworkAccessManager(this);
-    QNetworkReply *reply = qnam->get(QNetworkRequest(urlFromRemote));
-
-    connect(reply, SIGNAL(finished()),
-            this, SLOT(slotSearchFinished()));
-
-    setLoading(true);
-
-    while (reply->isRunning()) {
-        QApplication::processEvents();
-    }
-
-    setLoading(false);
-
+  qnam = new QNetworkAccessManager(this);
+  QNetworkReply* reply = qnam->get(QNetworkRequest(url_from_remote));
+
+  connect(reply, SIGNAL(finished()), this, SLOT(slotSearchFinished()));
+
+  setLoading(true);
+  this->searchButton->setDisabled(true);
+  this->keyServerComboBox->setDisabled(true);
+  this->searchLineEdit->setReadOnly(true);
+  this->importButton->setDisabled(true);
+
+  while (reply->isRunning()) {
+    QApplication::processEvents();
+  }
+
+  this->searchButton->setDisabled(false);
+  this->keyServerComboBox->setDisabled(false);
+  this->searchLineEdit->setReadOnly(false);
+  this->importButton->setDisabled(false);
+  setLoading(false);
 }
 
 void KeyServerImportDialog::slotSearchFinished() {
-    auto *reply = qobject_cast<QNetworkReply *>(sender());
-
-    keysTable->clearContents();
-    keysTable->setRowCount(0);
-    QString firstLine = QString(reply->readLine(1024));
-
-    auto error = reply->error();
-    if (error != QNetworkReply::NoError) {
-        qDebug() << "Error From Reply" << reply->errorString();
-        switch (error) {
-            case QNetworkReply::ContentNotFoundError :
-                setMessage(tr("Not Key Found"), true);
-                break;
-            case QNetworkReply::TimeoutError :
-                setMessage(tr("Timeout"), true);
-                break;
-            case QNetworkReply::HostNotFoundError :
-                setMessage(tr("Key Server Not Found"), true);
-                break;
-            default:
-                setMessage(tr("Connection Error"), true);
-        }
+  LOG(INFO) << "KeyServerImportDialog::slotSearchFinished Called";
+
+  auto* reply = qobject_cast<QNetworkReply*>(sender());
+
+  keysTable->clearContents();
+  keysTable->setRowCount(0);
+  QString first_line = QString(reply->readLine(1024));
+
+  auto error = reply->error();
+  if (error != QNetworkReply::NoError) {
+    qDebug() << "Error From Reply" << reply->errorString();
+    switch (error) {
+      case QNetworkReply::ContentNotFoundError:
+        setMessage(_("Not Key Found"), true);
+        break;
+      case QNetworkReply::TimeoutError:
+        setMessage(_("Timeout"), true);
+        break;
+      case QNetworkReply::HostNotFoundError:
+        setMessage(_("Key Server Not Found"), true);
+        break;
+      default:
+        setMessage(_("Connection Error"), true);
+    }
+    return;
+  }
+
+  if (first_line.contains("Error")) {
+    QString text = QString(reply->readLine(1024));
+    if (text.contains("Too many responses")) {
+      setMessage(
+          "<h4>" + QString(_("Too many responses from keyserver!")) + "</h4>",
+          true);
+      return;
+    } else if (text.contains("No keys found")) {
+      // if string looks like hex string, search again with 0x prepended
+      QRegExp rx("[0-9A-Fa-f]*");
+      QString query = searchLineEdit->text();
+      if (rx.exactMatch(query)) {
+        setMessage(
+            "<h4>" +
+                QString(_("No keys found, input may be kexId, retrying search "
+                          "with 0x.")) +
+                "</h4>",
+            true);
+        searchLineEdit->setText(query.prepend("0x"));
+        this->slotSearch();
         return;
+      } else {
+        setMessage(
+            "<h4>" + QString(_("No keys found containing the search string!")) +
+                "</h4>",
+            true);
+        return;
+      }
+    } else if (text.contains("Insufficiently specific words")) {
+      setMessage("<h4>" + QString(_("Insufficiently specific search string!")) +
+                     "</h4>",
+                 true);
+      return;
+    } else {
+      setMessage(text, true);
+      return;
     }
+  } else {
+    int row = 0;
+    bool strikeout = false;
+    while (reply->canReadLine()) {
+      auto line_buff = reply->readLine().trimmed();
+      QString decoded =
+          QString::fromUtf8(line_buff.constData(), line_buff.size());
+      QStringList line = decoded.split(":");
+      // TODO: have a look at two following pub lines
+      if (line[0] == "pub") {
+        strikeout = false;
+
+        QString flags = line[line.size() - 1];
+        keysTable->setRowCount(row + 1);
+
+        // flags can be "d" for disabled, "r" for revoked
+        // or "e" for expired
+        if (flags.contains("r") or flags.contains("d") or flags.contains("e")) {
+          strikeout = true;
+          if (flags.contains("e")) {
+            keysTable->setItem(row, 3,
+                               new QTableWidgetItem(QString("expired")));
+          }
+          if (flags.contains("r")) {
+            keysTable->setItem(row, 3,
+                               new QTableWidgetItem(QString(_("revoked"))));
+          }
+          if (flags.contains("d")) {
+            keysTable->setItem(row, 3,
+                               new QTableWidgetItem(QString(_("disabled"))));
+          }
+        }
+
+        QStringList line2 = QString(reply->readLine()).split(":");
 
-    if (firstLine.contains("Error")) {
-        QString text = QString(reply->readLine(1024));
-        if (text.contains("Too many responses")) {
-            setMessage("<h4>" +tr("Too many responses from keyserver!") + "</h4>", true);
-            return;
-        } else if (text.contains("No keys found")) {
-            // if string looks like hex string, search again with 0x prepended
-            QRegExp rx("[0-9A-Fa-f]*");
-            QString query = searchLineEdit->text();
-            if (rx.exactMatch(query)) {
-                setMessage("<h4>" + tr("No keys found, input may be kexId, retrying search with 0x.") + "</h4>", true);
-                searchLineEdit->setText(query.prepend("0x"));
-                this->slotSearch();
-                return;
-            } else {
-                setMessage("<h4>" +tr("No keys found containing the search string!") + "</h4>", true);
-                return;
-            }
-        } else if (text.contains("Insufficiently specific words")) {
-            setMessage("<h4>" + tr("Insufficiently specific search string!") + "</h4>", true);
-            return;
-        } else {
-            setMessage(text, true);
-            return;
+        auto* uid = new QTableWidgetItem();
+        if (line2.size() > 1) {
+          uid->setText(line2[1]);
+          keysTable->setItem(row, 0, uid);
         }
-    } else {
-        int row = 0;
-        bool strikeout = false;
-        while (reply->canReadLine()) {
-            auto line_buff = reply->readLine().trimmed();
-            QString decoded = QString::fromUtf8(line_buff.constData(), line_buff.size());
-            QStringList line = decoded.split(":");
-            //TODO: have a look at two following pub lines
-            if (line[0] == "pub") {
-                strikeout = false;
-
-                QString flags = line[line.size() - 1];
-                keysTable->setRowCount(row + 1);
-
-                // flags can be "d" for disabled, "r" for revoked
-                // or "e" for expired
-                if (flags.contains("r") or flags.contains("d") or flags.contains("e")) {
-                    strikeout = true;
-                    if (flags.contains("e")) {
-                        keysTable->setItem(row, 3, new QTableWidgetItem(QString("expired")));
-                    }
-                    if (flags.contains("r")) {
-                        keysTable->setItem(row, 3, new QTableWidgetItem(QString(tr("revoked"))));
-                    }
-                    if (flags.contains("d")) {
-                        keysTable->setItem(row, 3, new QTableWidgetItem(QString(tr("disabled"))));
-                    }
-                }
-
-                QStringList line2 = QString(reply->readLine()).split(":");
-
-                auto *uid = new QTableWidgetItem();
-                if (line2.size() > 1) {
-                    uid->setText(line2[1]);
-                    keysTable->setItem(row, 0, uid);
-                }
-                auto *creation_date = new QTableWidgetItem(
-                        QDateTime::fromTime_t(line[4].toInt()).toString("dd. MMM. yyyy"));
-                keysTable->setItem(row, 1, creation_date);
-                auto *keyid = new QTableWidgetItem(line[1]);
-                keysTable->setItem(row, 2, keyid);
-                if (strikeout) {
-                    QFont strike = uid->font();
-                    strike.setStrikeOut(true);
-                    uid->setFont(strike);
-                    creation_date->setFont(strike);
-                    keyid->setFont(strike);
-                }
-                row++;
-            } else {
-                if (line[0] == "uid") {
-                    QStringList l;
-                    int height = keysTable->rowHeight(row - 1);
-                    keysTable->setRowHeight(row - 1, height + 16);
-                    QString tmp = keysTable->item(row - 1, 0)->text();
-                    tmp.append(QString("\n") + line[1]);
-                    auto *tmp1 = new QTableWidgetItem(tmp);
-                    keysTable->setItem(row - 1, 0, tmp1);
-                    if (strikeout) {
-                        QFont strike = tmp1->font();
-                        strike.setStrikeOut(true);
-                        tmp1->setFont(strike);
-                    }
-                }
-            }
-            setMessage(tr("<h4>%1 keys found. Double click a key to import it.</h4>").arg(row), false);
+        auto* creation_date = new QTableWidgetItem(
+            QDateTime::fromTime_t(line[4].toInt()).toString("dd. MMM. yyyy"));
+        keysTable->setItem(row, 1, creation_date);
+        auto* keyid = new QTableWidgetItem(line[1]);
+        keysTable->setItem(row, 2, keyid);
+        if (strikeout) {
+          QFont strike = uid->font();
+          strike.setStrikeOut(true);
+          uid->setFont(strike);
+          creation_date->setFont(strike);
+          keyid->setFont(strike);
+        }
+        row++;
+      } else {
+        if (line[0] == "uid") {
+          QStringList l;
+          int height = keysTable->rowHeight(row - 1);
+          keysTable->setRowHeight(row - 1, height + 16);
+          QString tmp = keysTable->item(row - 1, 0)->text();
+          tmp.append(QString("\n") + line[1]);
+          auto* tmp1 = new QTableWidgetItem(tmp);
+          keysTable->setItem(row - 1, 0, tmp1);
+          if (strikeout) {
+            QFont strike = tmp1->font();
+            strike.setStrikeOut(true);
+            tmp1->setFont(strike);
+          }
         }
-        keysTable->resizeColumnsToContents();
+      }
+      setMessage(
+          QString("<h4>") +
+              QString(_("%1 keys found. Double click a key to import it."))
+                  .arg(row) +
+              "</h4>",
+          false);
     }
-    reply->deleteLater();
+    keysTable->resizeColumnsToContents();
+    importButton->setDisabled(keysTable->size().isEmpty());
+  }
+  reply->deleteLater();
 }
 
 void KeyServerImportDialog::slotImport() {
-    if (keysTable->currentRow() > -1) {
-        QString keyid = keysTable->item(keysTable->currentRow(), 2)->text();
-        slotImport(QStringList(keyid), keyServerComboBox->currentText());
-    }
-}
-
-void KeyServerImportDialog::slotImport(const QStringList& keyIds) {
-    QString keyserver = settings.value("keyserver/defaultKeyServer").toString();
-    qDebug() << "Select Key Server" << keyserver;
-    slotImport(keyIds, QUrl(keyserver));
+  LOG(INFO) << _("Current Row") << keysTable->currentRow();
+  if (keysTable->currentRow() > -1) {
+    QString keyid = keysTable->item(keysTable->currentRow(), 2)->text();
+    slotImport(QStringList(keyid), keyServerComboBox->currentText());
+  }
 }
 
-void KeyServerImportDialog::slotImportKey(const QVector<GpgKey>& keys) {
-    QString keyserver = settings.value("keyserver/defaultKeyServer").toString();
-    qDebug() << "Select Key Server" << keyserver;
-    auto keyIds = QStringList();
-    for(const auto &key : keys) {
-        keyIds.append(key.id);
+void KeyServerImportDialog::slotImport(const KeyIdArgsListPtr& keys) {
+  std::string target_keyserver;
+  if (keyServerComboBox != nullptr) {
+    target_keyserver = keyServerComboBox->currentText().toStdString();
+  }
+  if (target_keyserver.empty()) {
+    try {
+      auto& settings = GlobalSettingStation::GetInstance().GetUISettings();
+
+      target_keyserver = settings.lookup("keyserver.default_server").c_str();
+
+      LOG(INFO) << _("Set target Key Server to default Key Server")
+                << target_keyserver;
+    } catch (...) {
+      LOG(ERROR) << _("Cannot read default_keyserver From Settings");
+      QMessageBox::critical(
+          nullptr, _("Default Keyserver Not Found"),
+          _("Cannot read default keyserver from your settings, "
+            "please set a default keyserver first"));
+      return;
     }
-    slotImport(keyIds, QUrl(keyserver));
+  }
+  auto key_ids = QStringList();
+  for (const auto& key_id : *keys)
+    key_ids.append(QString::fromStdString(key_id));
+  slotImport(key_ids, QUrl(target_keyserver.c_str()));
 }
 
+void KeyServerImportDialog::slotImport(const QStringList& keyIds,
+                                       const QUrl& keyServerUrl) {
+  for (const auto& keyId : keyIds) {
+    QUrl req_url(keyServerUrl.scheme() + "://" + keyServerUrl.host() +
+                 "/pks/lookup?op=get&search=0x" + keyId + "&options=mr");
 
-void KeyServerImportDialog::slotImport(const QStringList& keyIds, const QUrl &keyServerUrl) {
-    for (const auto &keyId : keyIds) {
-        QUrl reqUrl(
-                keyServerUrl.scheme() + "://" + keyServerUrl.host() + "/pks/lookup?op=get&search=0x" + keyId +
-                "&options=mr");
-        qDebug() << "slotImport reqUrl" << reqUrl;
-        auto pManager = new QNetworkAccessManager(this);
-
-        QNetworkReply *reply = pManager->get(QNetworkRequest(reqUrl));
-
-        connect(reply, SIGNAL(finished()),
-                this, SLOT(slotImportFinished()));
-
-        setLoading(true);
-
-        while(reply->isRunning()) {
-            QApplication::processEvents();
-        }
+    LOG(INFO) << "request url" << req_url.toString().toStdString();
+    auto manager = new QNetworkAccessManager(this);
 
-        setLoading(false);
-    }
+    QNetworkReply* reply = manager->get(QNetworkRequest(req_url));
+    connect(reply, &QNetworkReply::finished, this,
+            [&, keyId]() { this->slotImportFinished(keyId); });
+    LOG(INFO) << "loading start";
+    setLoading(true);
+    while (reply->isRunning()) QApplication::processEvents();
+    setLoading(false);
+    LOG(INFO) << "loading done";
+  }
 }
 
-void KeyServerImportDialog::slotImportFinished() {
-    auto *reply = qobject_cast<QNetworkReply *>(sender());
-
-    QByteArray key = reply->readAll();
-
-    QVariant redirectionTarget = reply->attribute(QNetworkRequest::RedirectionTargetAttribute);
-
-    auto error = reply->error();
-    if (error != QNetworkReply::NoError) {
-        qDebug() << "Error From Reply" << reply->errorString();
-        switch (error) {
-            case QNetworkReply::ContentNotFoundError :
-                setMessage(tr("Key Not Found"), true);
-                break;
-            case QNetworkReply::TimeoutError :
-                setMessage(tr("Timeout"), true);
-                break;
-            case QNetworkReply::HostNotFoundError :
-                setMessage(tr("Key Server Not Found"), true);
-                break;
-            default:
-                setMessage(tr("Connection Error"), true);
-        }
-        if(mAutomatic) {
-            setWindowFlags(Qt::Window | Qt::WindowTitleHint | Qt::CustomizeWindowHint | Qt::WindowCloseButtonHint);
-        }
-        return;
+void KeyServerImportDialog::slotImportFinished(QString keyid) {
+  LOG(INFO) << _("Called");
+
+  auto* reply = qobject_cast<QNetworkReply*>(sender());
+
+  QByteArray key = reply->readAll();
+
+  auto error = reply->error();
+  if (error != QNetworkReply::NoError) {
+    LOG(ERROR) << "Error From Reply" << reply->errorString().toStdString();
+    if (!mAutomatic) {
+      switch (error) {
+        case QNetworkReply::ContentNotFoundError:
+          setMessage(_("Key Not Found"), true);
+          break;
+        case QNetworkReply::TimeoutError:
+          setMessage(_("Timeout"), true);
+          break;
+        case QNetworkReply::HostNotFoundError:
+          setMessage(_("Key Server Not Found"), true);
+          break;
+        default:
+          setMessage(_("Connection Error"), true);
+      }
+    } else {
+      switch (error) {
+        case QNetworkReply::ContentNotFoundError:
+          QMessageBox::critical(
+              nullptr, _("Public key Not Found"),
+              QString(_("Public key fingerprint %1 not found in the Keyserver"))
+                  .arg(keyid));
+          break;
+        case QNetworkReply::TimeoutError:
+          QMessageBox::critical(nullptr, _("Timeout"), "Connection timeout");
+          break;
+        case QNetworkReply::HostNotFoundError:
+          QMessageBox::critical(nullptr, _("Host Not Found"),
+                                "cannot resolve the default Keyserver");
+          break;
+        default:
+          QMessageBox::critical(nullptr, _("Connection Error"),
+                                _("General Connection Error"));
+      }
     }
-
-    // Add keyserver to list in config-file, if it isn't contained
-    QStringList keyServerList = settings.value("keyserver/keyServerList").toStringList();
-    if (!keyServerList.contains(keyServerComboBox->currentText())) {
-        keyServerList.append(keyServerComboBox->currentText());
-        settings.setValue("keyserver/keyServerList", keyServerList);
+    if (mAutomatic) {
+      setWindowFlags(Qt::Window | Qt::WindowTitleHint |
+                     Qt::CustomizeWindowHint | Qt::WindowCloseButtonHint);
     }
-    reply->deleteLater();
+    return;
+  }
 
-    this->importKeys(key.constData());
-    if(mAutomatic) {
-        setMessage(tr("<h4>Key Updated</h4>"), false);
-    } else {
-        setMessage(tr("<h4>Key Imported</h4>"), false);
-    }
+  reply->deleteLater();
 
+  this->importKeys(std::make_unique<ByteArray>(key.constData(), key.length()));
 
+  if (!mAutomatic) {
+    setMessage(QString("<h4>") + _("Key Imported") + "</h4>", false);
+  }
 }
 
-void KeyServerImportDialog::importKeys(QByteArray inBuffer) {
-    GpgImportInformation result = mCtx->importKey(std::move(inBuffer));
-    if(mAutomatic) {
-        new KeyImportDetailDialog(mCtx, result, false, this);
-        this->accept();
-    } else {
-        new KeyImportDetailDialog(mCtx, result, false, this);
-    }
+void KeyServerImportDialog::importKeys(ByteArrayPtr in_data) {
+  GpgImportInformation result =
+      GpgKeyImportExportor::GetInstance().ImportKey(std::move(in_data));
+  emit signalKeyImported();
+  if (mAutomatic) {
+    auto dialog = new KeyImportDetailDialog(result, true, nullptr);
+    dialog->show();
+    this->accept();
+  } else {
+    auto dialog = new KeyImportDetailDialog(result, false, this);
+    dialog->exec();
+  }
 }
 
 void KeyServerImportDialog::setLoading(bool status) {
-    if (status) {
-        waitingBar->setVisible(true);
-        icon->setVisible(false);
-        message->setVisible(false);
-    } else {
-        waitingBar->setVisible(false);
-        icon->setVisible(true);
-        message->setVisible(true);
-    }
+  waitingBar->setVisible(status);
+  if (!mAutomatic) {
+    icon->setVisible(!status);
+    message->setVisible(!status);
+  }
 }
 
-KeyServerImportDialog::KeyServerImportDialog(GpgME::GpgContext *ctx, QWidget *parent)
-        : QDialog(parent), appPath(qApp->applicationDirPath()),
-          settings(RESOURCE_DIR(appPath) + "/conf/gpgfrontend.ini", QSettings::IniFormat),
-          mCtx(ctx), mAutomatic(true) {
+KeyServerImportDialog::KeyServerImportDialog(QWidget* parent)
+    : QDialog(parent), mAutomatic(true) {
+  setWindowFlags(Qt::Window | Qt::WindowTitleHint | Qt::CustomizeWindowHint);
 
-    setWindowFlags(Qt::Window | Qt::WindowTitleHint | Qt::CustomizeWindowHint);
+  message = new QLabel;
+  message->setFixedHeight(24);
+  icon = new QLabel;
+  icon->setFixedHeight(24);
 
-    message = new QLabel;
-    message->setFixedHeight(24);
-    icon = new QLabel;
-    icon->setFixedHeight(24);
+  // Network Waiting
+  waitingBar = new QProgressBar();
+  waitingBar->setVisible(false);
+  waitingBar->setRange(0, 0);
+  waitingBar->setFixedHeight(24);
+  waitingBar->setFixedWidth(200);
 
-    // Network Waiting
-    waitingBar = new QProgressBar();
-    waitingBar->setVisible(false);
-    waitingBar->setRange(0, 0);
-    waitingBar->setFixedHeight(24);
-    waitingBar->setFixedWidth(200);
+  // Layout for messagebox
+  auto* messageLayout = new QHBoxLayout;
+  messageLayout->addWidget(icon);
+  messageLayout->addWidget(message);
+  messageLayout->addWidget(waitingBar);
+  messageLayout->addStretch();
 
-    // Layout for messagebox
-    auto *messageLayout = new QHBoxLayout;
-    messageLayout->addWidget(icon);
-    messageLayout->addWidget(message);
-    messageLayout->addWidget(waitingBar);
-    messageLayout->addStretch();
+  keyServerComboBox = createComboBox();
 
-    keyServerComboBox = createComboBox();
+  auto* mainLayout = new QGridLayout;
 
-    auto *mainLayout = new QGridLayout;
+  mainLayout->addLayout(messageLayout, 0, 0, 1, 3);
 
-    mainLayout->addLayout(messageLayout, 0, 0, 1, 3);
+  this->setLayout(mainLayout);
+  this->setWindowTitle(_("Upload Keys from Keyserver"));
+  this->setFixedSize(200, 42);
+  this->setModal(true);
+}
 
-    this->setLayout(mainLayout);
-    this->setWindowTitle(tr("Upload Keys from Keyserver"));
-    this->setFixedSize(200, 42);
-    this->setModal(true);
+void KeyServerImportDialog::slotSaveWindowState() {
+  LOG(INFO) << _("Called");
+
+  if (mAutomatic) return;
+
+  auto& settings =
+      GpgFrontend::UI::GlobalSettingStation::GetInstance().GetUISettings();
+
+  if (!settings.exists("window") ||
+      settings.lookup("window").getType() != libconfig::Setting::TypeGroup)
+    settings.add("window", libconfig::Setting::TypeGroup);
+
+  auto& window = settings["window"];
+
+  if (!window.exists("import_from_keyserver") ||
+      window.lookup("import_from_keyserver").getType() !=
+          libconfig::Setting::TypeGroup)
+    window.add("import_from_keyserver", libconfig::Setting::TypeGroup);
+
+  auto& import_from_keyserver = window["import_from_keyserver"];
+
+  if (!import_from_keyserver.exists("position") ||
+      import_from_keyserver.lookup("position").getType() !=
+          libconfig::Setting::TypeGroup) {
+    auto& position =
+        import_from_keyserver.add("position", libconfig::Setting::TypeGroup);
+    position.add("x", libconfig::Setting::TypeInt) = pos().x();
+    position.add("y", libconfig::Setting::TypeInt) = pos().y();
+  } else {
+    import_from_keyserver["position"]["x"] = pos().x();
+    import_from_keyserver["position"]["y"] = pos().y();
+  }
+
+  if (!import_from_keyserver.exists("size") ||
+      import_from_keyserver.lookup("size").getType() !=
+          libconfig::Setting::TypeGroup) {
+    auto& size =
+        import_from_keyserver.add("size", libconfig::Setting::TypeGroup);
+    size.add("width", libconfig::Setting::TypeInt) = QWidget::width();
+    size.add("height", libconfig::Setting::TypeInt) = QWidget::height();
+  } else {
+    import_from_keyserver["size"]["width"] = QWidget::width();
+    import_from_keyserver["size"]["height"] = QWidget::height();
+  }
+
+  GlobalSettingStation::GetInstance().Sync();
 }
+
+}  // namespace GpgFrontend::UI