1 files changed, 263 insertions, 179 deletions

diff --git a/src/ui/widgets/KeyList.cpp b/src/ui/widgets/KeyList.cpp
index f9f33d78..5931e337 100644
--- a/src/ui/widgets/KeyList.cpp
+++ b/src/ui/widgets/KeyList.cpp
@@ -31,61 +31,24 @@
 
 namespace GpgFrontend::UI {
 
-KeyList::KeyList(KeyListRow::KeyType selectType,
-                 KeyListColumn::InfoType infoType, QWidget* parent)
-    : QWidget(parent),
-      appPath(qApp->applicationDirPath()),
-      settings(RESOURCE_DIR(appPath) + "/conf/gpgfrontend.ini",
-               QSettings::IniFormat),
-      mSelectType(selectType),
-      mInfoType(infoType) {
-  mKeyList = new QTableWidget(this);
-  mKeyList->setColumnCount(7);
-  mKeyList->horizontalHeader()->setSectionResizeMode(
-      QHeaderView::ResizeToContents);
-  mKeyList->verticalHeader()->hide();
-  mKeyList->setShowGrid(false);
-  mKeyList->sortByColumn(2, Qt::AscendingOrder);
-  mKeyList->setSelectionBehavior(QAbstractItemView::SelectRows);
-  mKeyList->setSelectionMode(QAbstractItemView::SingleSelection);
-
-  // table items not editable
-  mKeyList->setEditTriggers(QAbstractItemView::NoEditTriggers);
-  // no focus (rectangle around table items)
-  // maybe it should focus on whole row
-  mKeyList->setFocusPolicy(Qt::NoFocus);
-
-  mKeyList->setAlternatingRowColors(true);
-
-  // Hidden Column For Purpose
-  if (!(mInfoType & KeyListColumn::TYPE)) {
-    mKeyList->setColumnHidden(1, true);
-  }
-  if (!(mInfoType & KeyListColumn::NAME)) {
-    mKeyList->setColumnHidden(2, true);
-  }
-  if (!(mInfoType & KeyListColumn::EmailAddress)) {
-    mKeyList->setColumnHidden(3, true);
-  }
-  if (!(mInfoType & KeyListColumn::Usage)) {
-    mKeyList->setColumnHidden(4, true);
-  }
-  if (!(mInfoType & KeyListColumn::Validity)) {
-    mKeyList->setColumnHidden(5, true);
-  }
-  if (!(mInfoType & KeyListColumn::FingerPrint)) {
-    mKeyList->setColumnHidden(6, true);
-  }
+KeyList::KeyList(QWidget* parent) : QWidget(parent) { init(); }
 
-  QStringList labels;
-  labels << _("Select") << _("Type") << _("Name") << _("Email Address")
-         << _("Usage") << _("Validity") << _("Finger Print");
+KeyList::KeyList(KeyListRow::KeyType selectType,
+                 KeyListColumn::InfoType infoType,
+                 const std::function<bool(const GpgKey&)>& filter,
+                 QWidget* parent)
+    : QWidget(parent) {
+  init();
+  addListGroupTab(_("Default"), selectType, infoType, filter);
+}
 
-  mKeyList->setHorizontalHeaderLabels(labels);
-  mKeyList->horizontalHeader()->setStretchLastSection(false);
+void KeyList::init() {
+  mGroupTab = new QTabWidget();
+  mGroupTab->setMovable(true);
+  mGroupTab->setTabsClosable(false);
 
   auto* layout = new QVBoxLayout;
-  layout->addWidget(mKeyList);
+  layout->addWidget(mGroupTab);
   layout->setContentsMargins(0, 0, 0, 0);
   layout->setSpacing(3);
   setLayout(layout);
@@ -95,136 +58,97 @@ KeyList::KeyList(KeyListRow::KeyType selectType,
   // register key database refresh signal
   connect(SignalStation::GetInstance(), SIGNAL(KeyDatabaseRefresh()), this,
           SLOT(slotRefresh()));
-  connect(mKeyList, SIGNAL(doubleClicked(const QModelIndex&)), this,
-          SLOT(slotDoubleClicked(const QModelIndex&)));
 
   setAcceptDrops(true);
-  slotRefresh();
 }
 
-void KeyList::slotRefresh() {
-  LOG(INFO) << "KeyList::slotRefresh Called";
-
-  auto keyList = getChecked();
-  // while filling the table, sort enabled causes errors
-  mKeyList->setSortingEnabled(false);
-  mKeyList->clearContents();
-
-  auto keys = GpgKeyGetter::GetInstance().FetchKey();
-
-  auto it = keys->begin();
-
-  int row_count = 0;
-
-  while (it != keys->end()) {
-    if (mFilter != nullptr) {
-      if (!mFilter(*it)) {
-        it = keys->erase(it);
-        continue;
-      }
-    }
-    if (!excluded_key_ids.empty()) {
-      auto iterator =
-          std::find_if(excluded_key_ids.begin(), excluded_key_ids.end(),
-                       [it](const auto& key_id) -> bool {
-                         if (it->id() == key_id)
-                           return true;
-                         else
-                           return false;
-                       });
-
-      if (iterator != excluded_key_ids.end()) {
-        it = keys->erase(it);
-        continue;
-      }
-    }
-    if (mSelectType == KeyListRow::ONLY_SECRET_KEY && !it->is_private_key()) {
-      it = keys->erase(it);
-      continue;
-    }
-    row_count++;
-    it++;
+void KeyList::addListGroupTab(
+    const QString& name, KeyListRow::KeyType selectType,
+    KeyListColumn::InfoType infoType,
+    const std::function<bool(const GpgKey&)>& filter) {
+  auto key_list = new QTableWidget(this);
+  if (mKeyList == nullptr) {
+    mKeyList = key_list;
   }
+  mGroupTab->addTab(key_list, name);
+  mKeyTables.emplace_back(key_list, selectType, infoType, filter);
 
-  mKeyList->setRowCount(row_count);
-
-  int row_index = 0;
-  it = keys->begin();
-  buffered_keys.clear();
+  key_list->setColumnCount(7);
+  key_list->horizontalHeader()->setSectionResizeMode(
+      QHeaderView::ResizeToContents);
+  key_list->verticalHeader()->hide();
+  key_list->setShowGrid(false);
+  key_list->sortByColumn(2, Qt::AscendingOrder);
+  key_list->setSelectionBehavior(QAbstractItemView::SelectRows);
+  key_list->setSelectionMode(QAbstractItemView::SingleSelection);
 
-  while (it != keys->end()) {
-    buffered_keys.push_back(GpgKeyGetter::GetInstance().GetKey(it->id()));
+  // table items not editable
+  key_list->setEditTriggers(QAbstractItemView::NoEditTriggers);
+  // no focus (rectangle around table items)
+  // maybe it should focus on whole row
+  key_list->setFocusPolicy(Qt::NoFocus);
 
-    auto* tmp0 = new QTableWidgetItem(QString::number(row_index));
-    tmp0->setFlags(Qt::ItemIsUserCheckable | Qt::ItemIsEnabled |
-                   Qt::ItemIsSelectable);
-    tmp0->setTextAlignment(Qt::AlignCenter);
-    tmp0->setCheckState(Qt::Unchecked);
-    mKeyList->setItem(row_index, 0, tmp0);
+  key_list->setAlternatingRowColors(true);
 
-    QString type_str;
-    QTextStream type_steam(&type_str);
-    if (it->is_private_key()) {
-      type_steam << "pub/sec";
-    } else {
-      type_steam << "pub";
-    }
-
-    if (it->is_private_key() && !it->has_master_key()) {
-      type_steam << "#";
-    }
-    auto* tmp1 = new QTableWidgetItem(type_str);
-    mKeyList->setItem(row_index, 1, tmp1);
+  // Hidden Column For Purpose
+  if (!(infoType & KeyListColumn::TYPE)) {
+    key_list->setColumnHidden(1, true);
+  }
+  if (!(infoType & KeyListColumn::NAME)) {
+    key_list->setColumnHidden(2, true);
+  }
+  if (!(infoType & KeyListColumn::EmailAddress)) {
+    key_list->setColumnHidden(3, true);
+  }
+  if (!(infoType & KeyListColumn::Usage)) {
+    key_list->setColumnHidden(4, true);
+  }
+  if (!(infoType & KeyListColumn::Validity)) {
+    key_list->setColumnHidden(5, true);
+  }
+  if (!(infoType & KeyListColumn::FingerPrint)) {
+    key_list->setColumnHidden(6, true);
+  }
 
-    auto* tmp2 = new QTableWidgetItem(QString::fromStdString(it->name()));
-    mKeyList->setItem(row_index, 2, tmp2);
-    auto* tmp3 = new QTableWidgetItem(QString::fromStdString(it->email()));
-    mKeyList->setItem(row_index, 3, tmp3);
+  QStringList labels;
+  labels << _("Select") << _("Type") << _("Name") << _("Email Address")
+         << _("Usage") << _("Validity") << _("Finger Print");
 
-    QString usage;
-    QTextStream usage_steam(&usage);
+  key_list->setHorizontalHeaderLabels(labels);
+  key_list->horizontalHeader()->setStretchLastSection(false);
 
-    if (it->CanCertActual()) usage_steam << "C";
-    if (it->CanEncrActual()) usage_steam << "E";
-    if (it->CanSignActual()) usage_steam << "S";
-    if (it->CanAuthActual()) usage_steam << "A";
+  connect(key_list, &QTableWidget::doubleClicked, this,
+          &KeyList::slotDoubleClicked);
 
-    auto* temp_usage = new QTableWidgetItem(usage);
-    temp_usage->setTextAlignment(Qt::AlignCenter);
-    mKeyList->setItem(row_index, 4, temp_usage);
+  // refresh
+  mKeyTables.back().Refresh();
+}
 
-    auto* temp_validity =
-        new QTableWidgetItem(QString::fromStdString(it->owner_trust()));
-    temp_validity->setTextAlignment(Qt::AlignCenter);
-    mKeyList->setItem(row_index, 5, temp_validity);
+void KeyList::slotRefresh() {
+  LOG(INFO) << _("called");
 
-    auto* temp_fpr = new QTableWidgetItem(QString::fromStdString(it->fpr()));
-    temp_fpr->setTextAlignment(Qt::AlignCenter);
-    mKeyList->setItem(row_index, 6, temp_fpr);
+  for (auto& key_table : mKeyTables) {
+    key_table.Refresh();
+  }
+}
 
-    // strike out expired keys
-    if (it->expired() || it->revoked()) {
-      QFont strike = tmp2->font();
-      strike.setStrikeOut(true);
-      tmp0->setFont(strike);
-      temp_usage->setFont(strike);
-      temp_fpr->setFont(strike);
-      temp_validity->setFont(strike);
-      tmp1->setFont(strike);
-      tmp2->setFont(strike);
-      tmp3->setFont(strike);
+KeyIdArgsListPtr KeyList::getChecked(const KeyTable& key_table) {
+  auto ret = std::make_unique<KeyIdArgsList>();
+  for (int i = 0; i < key_table.key_list->rowCount(); i++) {
+    if (key_table.key_list->item(i, 0)->checkState() == Qt::Checked) {
+      ret->push_back(key_table.buffered_keys[i].id());
     }
-    it++;
-    ++row_index;
   }
-
-  setChecked(keyList);
+  return ret;
 }
 
 KeyIdArgsListPtr KeyList::getChecked() {
+  auto key_list = qobject_cast<QTableWidget*>(mGroupTab->currentWidget());
+  const auto& buffered_keys =
+      mKeyTables[mGroupTab->currentIndex()].buffered_keys;
   auto ret = std::make_unique<KeyIdArgsList>();
-  for (int i = 0; i < mKeyList->rowCount(); i++) {
-    if (mKeyList->item(i, 0)->checkState() == Qt::Checked) {
+  for (int i = 0; i < key_list->rowCount(); i++) {
+    if (key_list->item(i, 0)->checkState() == Qt::Checked) {
       ret->push_back(buffered_keys[i].id());
     }
   }
@@ -232,9 +156,12 @@ KeyIdArgsListPtr KeyList::getChecked() {
 }
 
 KeyIdArgsListPtr KeyList::getAllPrivateKeys() {
+  auto key_list = qobject_cast<QTableWidget*>(mGroupTab->currentWidget());
+  const auto& buffered_keys =
+      mKeyTables[mGroupTab->currentIndex()].buffered_keys;
   auto ret = std::make_unique<KeyIdArgsList>();
-  for (int i = 0; i < mKeyList->rowCount(); i++) {
-    if (mKeyList->item(i, 1) && buffered_keys[i].is_private_key()) {
+  for (int i = 0; i < key_list->rowCount(); i++) {
+    if (key_list->item(i, 1) && buffered_keys[i].is_private_key()) {
       ret->push_back(buffered_keys[i].id());
     }
   }
@@ -243,21 +170,44 @@ KeyIdArgsListPtr KeyList::getAllPrivateKeys() {
 
 KeyIdArgsListPtr KeyList::getPrivateChecked() {
   auto ret = std::make_unique<KeyIdArgsList>();
-  for (int i = 0; i < mKeyList->rowCount(); i++) {
-    if ((mKeyList->item(i, 0)->checkState() == Qt::Checked) &&
-        (mKeyList->item(i, 1))) {
+  if (mGroupTab->size().isEmpty()) return ret;
+
+  auto key_list = qobject_cast<QTableWidget*>(mGroupTab->currentWidget());
+  const auto& buffered_keys =
+      mKeyTables[mGroupTab->currentIndex()].buffered_keys;
+
+  for (int i = 0; i < key_list->rowCount(); i++) {
+    if ((key_list->item(i, 0)->checkState() == Qt::Checked) &&
+        (key_list->item(i, 1))) {
       ret->push_back(buffered_keys[i].id());
     }
   }
   return ret;
 }
 
+void KeyList::setChecked(const KeyIdArgsListPtr& keyIds,
+                         const KeyTable& key_table) {
+  if (!keyIds->empty()) {
+    for (int i = 0; i < key_table.key_list->rowCount(); i++) {
+      if (std::find(keyIds->begin(), keyIds->end(),
+                    key_table.buffered_keys[i].id()) != keyIds->end()) {
+        key_table.key_list->item(i, 0)->setCheckState(Qt::Checked);
+      }
+    }
+  }
+}
+
 void KeyList::setChecked(const KeyIdArgsListPtr& keyIds) {
+  if (mGroupTab->size().isEmpty()) return;
+  auto key_list = qobject_cast<QTableWidget*>(mGroupTab->currentWidget());
+  const auto& buffered_keys =
+      mKeyTables[mGroupTab->currentIndex()].buffered_keys;
+
   if (!keyIds->empty()) {
-    for (int i = 0; i < mKeyList->rowCount(); i++) {
+    for (int i = 0; i < key_list->rowCount(); i++) {
       if (std::find(keyIds->begin(), keyIds->end(), buffered_keys[i].id()) !=
           keyIds->end()) {
-        mKeyList->item(i, 0)->setCheckState(Qt::Checked);
+        key_list->item(i, 0)->setCheckState(Qt::Checked);
       }
     }
   }
@@ -265,9 +215,14 @@ void KeyList::setChecked(const KeyIdArgsListPtr& keyIds) {
 
 KeyIdArgsListPtr KeyList::getSelected() {
   auto ret = std::make_unique<KeyIdArgsList>();
+  if (mGroupTab->size().isEmpty()) return ret;
 
-  for (int i = 0; i < mKeyList->rowCount(); i++) {
-    if (mKeyList->item(i, 0)->isSelected() == 1) {
+  auto key_list = qobject_cast<QTableWidget*>(mGroupTab->currentWidget());
+  const auto& buffered_keys =
+      mKeyTables[mGroupTab->currentIndex()].buffered_keys;
+
+  for (int i = 0; i < key_list->rowCount(); i++) {
+    if (key_list->item(i, 0)->isSelected() == 1) {
       ret->push_back(buffered_keys[i].id());
     }
   }
@@ -275,6 +230,9 @@ KeyIdArgsListPtr KeyList::getSelected() {
 }
 
 [[maybe_unused]] bool KeyList::containsPrivateKeys() {
+  if (mGroupTab->size().isEmpty()) return false;
+  mKeyList = qobject_cast<QTableWidget*>(mGroupTab->currentWidget());
+
   for (int i = 0; i < mKeyList->rowCount(); i++) {
     if (mKeyList->item(i, 1)) {
       return true;
@@ -284,10 +242,16 @@ KeyIdArgsListPtr KeyList::getSelected() {
 }
 
 void KeyList::setColumnWidth(int row, int size) {
+  if (mGroupTab->size().isEmpty()) return;
+  mKeyList = qobject_cast<QTableWidget*>(mGroupTab->currentWidget());
+
   mKeyList->setColumnWidth(row, size);
 }
 
 void KeyList::contextMenuEvent(QContextMenuEvent* event) {
+  if (mGroupTab->size().isEmpty()) return;
+  mKeyList = qobject_cast<QTableWidget*>(mGroupTab->currentWidget());
+
   if (mKeyList->selectedItems().length() > 0) {
     popupMenu->exec(event->globalPos());
   }
@@ -374,18 +338,10 @@ void KeyList::importKeys(const QByteArray& inBuffer) {
   new KeyImportDetailDialog(result, false, this);
 }
 
-void KeyList::setExcludeKeys(std::initializer_list<std::string> key_ids) {
-  excluded_key_ids.clear();
-  for (auto& key_id : key_ids) {
-    excluded_key_ids.push_back(key_id);
-  }
-}
-
-void KeyList::setFilter(std::function<bool(const GpgKey&)> filter) {
-  this->mFilter = std::move(filter);
-}
-
 void KeyList::slotDoubleClicked(const QModelIndex& index) {
+  if (mGroupTab->size().isEmpty()) return;
+  const auto& buffered_keys =
+      mKeyTables[mGroupTab->currentIndex()].buffered_keys;
   if (mAction != nullptr) {
     const auto key =
         GpgKeyGetter::GetInstance().GetKey(buffered_keys[index.row()].id());
@@ -399,6 +355,10 @@ void KeyList::setDoubleClickedAction(
 }
 
 std::string KeyList::getSelectedKey() {
+  if (mGroupTab->size().isEmpty()) return {};
+  const auto& buffered_keys =
+      mKeyTables[mGroupTab->currentIndex()].buffered_keys;
+
   for (int i = 0; i < mKeyList->rowCount(); i++) {
     if (mKeyList->item(i, 0)->isSelected() == 1) {
       return buffered_keys[i].id();
@@ -407,4 +367,128 @@ std::string KeyList::getSelectedKey() {
   return {};
 }
 
+KeyIdArgsListPtr KeyTable::GetChecked() {
+  auto ret = std::make_unique<KeyIdArgsList>();
+  for (int i = 0; i < key_list->rowCount(); i++) {
+    if (key_list->item(i, 0)->checkState() == Qt::Checked) {
+      ret->push_back(buffered_keys[i].id());
+    }
+  }
+  return ret;
+}
+
+void KeyTable::SetChecked(const KeyIdArgsListPtr& key_ids) {
+  if (!key_ids->empty()) {
+    for (int i = 0; i < key_list->rowCount(); i++) {
+      if (std::find(key_ids->begin(), key_ids->end(), buffered_keys[i].id()) !=
+          key_ids->end()) {
+        key_list->item(i, 0)->setCheckState(Qt::Checked);
+      }
+    }
+  }
+}
+
+void KeyTable::Refresh() {
+  auto checked_key_list = GetChecked();
+  // while filling the table, sort enabled causes errors
+
+  key_list->setSortingEnabled(false);
+  key_list->clearContents();
+
+  auto keys = GpgKeyGetter::GetInstance().FetchKey();
+  auto it = keys->begin();
+  int row_count = 0;
+
+  while (it != keys->end()) {
+    if (filter != nullptr) {
+      if (!filter(*it)) {
+        it = keys->erase(it);
+        continue;
+      }
+    }
+    if (select_type == KeyListRow::ONLY_SECRET_KEY && !it->is_private_key()) {
+      it = keys->erase(it);
+      continue;
+    }
+    row_count++;
+    it++;
+  }
+
+  key_list->setRowCount(row_count);
+
+  int row_index = 0;
+  it = keys->begin();
+
+  auto& table_buffered_keys = buffered_keys;
+
+  table_buffered_keys.clear();
+
+  while (it != keys->end()) {
+    table_buffered_keys.push_back(GpgKeyGetter::GetInstance().GetKey(it->id()));
+
+    auto* tmp0 = new QTableWidgetItem(QString::number(row_index));
+    tmp0->setFlags(Qt::ItemIsUserCheckable | Qt::ItemIsEnabled |
+                   Qt::ItemIsSelectable);
+    tmp0->setTextAlignment(Qt::AlignCenter);
+    tmp0->setCheckState(Qt::Unchecked);
+    key_list->setItem(row_index, 0, tmp0);
+
+    QString type_str;
+    QTextStream type_steam(&type_str);
+    if (it->is_private_key()) {
+      type_steam << "pub/sec";
+    } else {
+      type_steam << "pub";
+    }
+
+    if (it->is_private_key() && !it->has_master_key()) {
+      type_steam << "#";
+    }
+    auto* tmp1 = new QTableWidgetItem(type_str);
+    key_list->setItem(row_index, 1, tmp1);
+
+    auto* tmp2 = new QTableWidgetItem(QString::fromStdString(it->name()));
+    key_list->setItem(row_index, 2, tmp2);
+    auto* tmp3 = new QTableWidgetItem(QString::fromStdString(it->email()));
+    key_list->setItem(row_index, 3, tmp3);
+
+    QString usage;
+    QTextStream usage_steam(&usage);
+
+    if (it->CanCertActual()) usage_steam << "C";
+    if (it->CanEncrActual()) usage_steam << "E";
+    if (it->CanSignActual()) usage_steam << "S";
+    if (it->CanAuthActual()) usage_steam << "A";
+
+    auto* temp_usage = new QTableWidgetItem(usage);
+    temp_usage->setTextAlignment(Qt::AlignCenter);
+    key_list->setItem(row_index, 4, temp_usage);
+
+    auto* temp_validity =
+        new QTableWidgetItem(QString::fromStdString(it->owner_trust()));
+    temp_validity->setTextAlignment(Qt::AlignCenter);
+    key_list->setItem(row_index, 5, temp_validity);
+
+    auto* temp_fpr = new QTableWidgetItem(QString::fromStdString(it->fpr()));
+    temp_fpr->setTextAlignment(Qt::AlignCenter);
+    key_list->setItem(row_index, 6, temp_fpr);
+
+    // strike out expired keys
+    if (it->expired() || it->revoked()) {
+      QFont strike = tmp2->font();
+      strike.setStrikeOut(true);
+      tmp0->setFont(strike);
+      temp_usage->setFont(strike);
+      temp_fpr->setFont(strike);
+      temp_validity->setFont(strike);
+      tmp1->setFont(strike);
+      tmp2->setFont(strike);
+      tmp3->setFont(strike);
+    }
+    it++;
+    ++row_index;
+  }
+
+  SetChecked(checked_key_list);
+}
 }  // namespace GpgFrontend::UI