1 files changed, 151 insertions, 151 deletions

diff --git a/src/ui/keypair_details/KeyPairUIDTab.cpp b/src/ui/keypair_details/KeyPairUIDTab.cpp
index 903b93f8..cc5902dc 100644
--- a/src/ui/keypair_details/KeyPairUIDTab.cpp
+++ b/src/ui/keypair_details/KeyPairUIDTab.cpp
@@ -33,20 +33,20 @@
 namespace GpgFrontend::UI {
 
 KeyPairUIDTab::KeyPairUIDTab(const std::string& key_id, QWidget* parent)
-    : QWidget(parent), mKey(GpgKeyGetter::GetInstance().GetKey(key_id)) {
-  createUIDList();
-  createSignList();
-  createManageUIDMenu();
-  createUIDPopupMenu();
-  createSignPopupMenu();
+    : QWidget(parent), m_key_(GpgKeyGetter::GetInstance().GetKey(key_id)) {
+  create_uid_list();
+  create_sign_list();
+  create_manage_uid_menu();
+  create_uid_popup_menu();
+  create_sign_popup_menu();
 
   auto uidButtonsLayout = new QGridLayout();
 
   auto addUIDButton = new QPushButton(_("New UID"));
   auto manageUIDButton = new QPushButton(_("UID Management"));
 
-  if (mKey.IsHasMasterKey()) {
-    manageUIDButton->setMenu(manageSelectedUIDMenu);
+  if (m_key_.IsHasMasterKey()) {
+    manageUIDButton->setMenu(manage_selected_uid_menu_);
   } else {
     manageUIDButton->setDisabled(true);
   }
@@ -56,7 +56,7 @@ KeyPairUIDTab::KeyPairUIDTab(const std::string& key_id, QWidget* parent)
 
   auto grid_layout = new QGridLayout();
 
-  grid_layout->addWidget(uidList, 0, 0);
+  grid_layout->addWidget(uid_list_, 0, 0);
   grid_layout->addLayout(uidButtonsLayout, 1, 0);
   grid_layout->setContentsMargins(0, 10, 0, 0);
 
@@ -69,12 +69,12 @@ KeyPairUIDTab::KeyPairUIDTab(const std::string& key_id, QWidget* parent)
   tofu_group_box->setLayout(tofu_vbox_layout);
   tofu_group_box->setTitle(_("TOFU"));
 #if !defined(RELEASE)
-  tofuTabs = new QTabWidget(this);
-  tofu_vbox_layout->addWidget(tofuTabs);
+  tofu_tabs_ = new QTabWidget(this);
+  tofu_vbox_layout->addWidget(tofu_tabs_);
 #endif
 
   auto sign_grid_layout = new QGridLayout();
-  sign_grid_layout->addWidget(sigList, 0, 0);
+  sign_grid_layout->addWidget(sig_list_, 0, 0);
   sign_grid_layout->setContentsMargins(0, 10, 0, 0);
 
   auto sign_group_box = new QGroupBox();
@@ -91,191 +91,191 @@ KeyPairUIDTab::KeyPairUIDTab(const std::string& key_id, QWidget* parent)
 
   vboxLayout->setContentsMargins(0, 0, 0, 0);
 
-  connect(addUIDButton, SIGNAL(clicked(bool)), this, SLOT(slotAddUID()));
-  connect(uidList, SIGNAL(itemSelectionChanged()), this,
-          SLOT(slotRefreshTOFUInfo()));
-  connect(uidList, SIGNAL(itemSelectionChanged()), this,
-          SLOT(slotRefreshSigList()));
+  connect(addUIDButton, SIGNAL(clicked(bool)), this, SLOT(slot_add_uid()));
+  connect(uid_list_, SIGNAL(itemSelectionChanged()), this,
+          SLOT(slot_refresh_tofu_info()));
+  connect(uid_list_, SIGNAL(itemSelectionChanged()), this,
+          SLOT(slot_refresh_sig_list()));
 
   // Key Database Refresh
   connect(SignalStation::GetInstance(), SIGNAL(KeyDatabaseRefresh()), this,
-          SLOT(slotRefreshKey()));
+          SLOT(slot_refresh_key()));
 
-  connect(this, SIGNAL(signalUpdateUIDInfo()), SignalStation::GetInstance(),
+  connect(this, SIGNAL(SignalUpdateUIDInfo()), SignalStation::GetInstance(),
           SIGNAL(KeyDatabaseRefresh()));
 
   setLayout(vboxLayout);
   setAttribute(Qt::WA_DeleteOnClose, true);
 
-  slotRefreshUIDList();
+  slot_refresh_uid_list();
 }
 
-void KeyPairUIDTab::createUIDList() {
-  uidList = new QTableWidget(this);
-  uidList->setColumnCount(4);
-  uidList->horizontalHeader()->setSectionResizeMode(
+void KeyPairUIDTab::create_uid_list() {
+  uid_list_ = new QTableWidget(this);
+  uid_list_->setColumnCount(4);
+  uid_list_->horizontalHeader()->setSectionResizeMode(
       QHeaderView::ResizeToContents);
-  uidList->verticalHeader()->hide();
-  uidList->setShowGrid(false);
-  uidList->setSelectionBehavior(QAbstractItemView::SelectRows);
-  uidList->setSelectionMode(QAbstractItemView::SingleSelection);
+  uid_list_->verticalHeader()->hide();
+  uid_list_->setShowGrid(false);
+  uid_list_->setSelectionBehavior(QAbstractItemView::SelectRows);
+  uid_list_->setSelectionMode(QAbstractItemView::SingleSelection);
 
   // tableitems not editable
-  uidList->setEditTriggers(QAbstractItemView::NoEditTriggers);
+  uid_list_->setEditTriggers(QAbstractItemView::NoEditTriggers);
 
   // no focus (rectangle around tableitems)
   // may be it should focus on whole row
-  uidList->setFocusPolicy(Qt::NoFocus);
-  uidList->setAlternatingRowColors(true);
+  uid_list_->setFocusPolicy(Qt::NoFocus);
+  uid_list_->setAlternatingRowColors(true);
 
   QStringList labels;
   labels << _("Select") << _("Name") << _("Email") << _("Comment");
-  uidList->setHorizontalHeaderLabels(labels);
-  uidList->horizontalHeader()->setStretchLastSection(true);
+  uid_list_->setHorizontalHeaderLabels(labels);
+  uid_list_->horizontalHeader()->setStretchLastSection(true);
 }
 
-void KeyPairUIDTab::createSignList() {
-  sigList = new QTableWidget(this);
-  sigList->setColumnCount(5);
-  sigList->horizontalHeader()->setSectionResizeMode(
+void KeyPairUIDTab::create_sign_list() {
+  sig_list_ = new QTableWidget(this);
+  sig_list_->setColumnCount(5);
+  sig_list_->horizontalHeader()->setSectionResizeMode(
       QHeaderView::ResizeToContents);
-  sigList->verticalHeader()->hide();
-  sigList->setShowGrid(false);
-  sigList->setSelectionBehavior(QAbstractItemView::SelectRows);
+  sig_list_->verticalHeader()->hide();
+  sig_list_->setShowGrid(false);
+  sig_list_->setSelectionBehavior(QAbstractItemView::SelectRows);
 
   // table items not editable
-  sigList->setEditTriggers(QAbstractItemView::NoEditTriggers);
+  sig_list_->setEditTriggers(QAbstractItemView::NoEditTriggers);
 
   // no focus (rectangle around table items)
   // may be it should focus on whole row
-  sigList->setFocusPolicy(Qt::NoFocus);
-  sigList->setAlternatingRowColors(true);
+  sig_list_->setFocusPolicy(Qt::NoFocus);
+  sig_list_->setAlternatingRowColors(true);
 
   QStringList labels;
   labels << _("Key ID") << _("Name") << _("Email") << _("Create Date (UTC)")
          << _("Expired Date (UTC)");
-  sigList->setHorizontalHeaderLabels(labels);
-  sigList->horizontalHeader()->setStretchLastSection(false);
+  sig_list_->setHorizontalHeaderLabels(labels);
+  sig_list_->horizontalHeader()->setStretchLastSection(false);
 }
 
-void KeyPairUIDTab::slotRefreshUIDList() {
+void KeyPairUIDTab::slot_refresh_uid_list() {
   int row = 0;
 
-  uidList->setSelectionMode(QAbstractItemView::SingleSelection);
+  uid_list_->setSelectionMode(QAbstractItemView::SingleSelection);
 
-  this->buffered_uids.clear();
+  this->buffered_uids_.clear();
 
-  auto uids = mKey.GetUIDs();
+  auto uids = m_key_.GetUIDs();
   for (auto& uid : *uids) {
     if (uid.GetInvalid() || uid.GetRevoked()) {
       continue;
     }
-    this->buffered_uids.push_back(std::move(uid));
+    this->buffered_uids_.push_back(std::move(uid));
   }
 
-  uidList->setRowCount(buffered_uids.size());
+  uid_list_->setRowCount(buffered_uids_.size());
 
-  for (const auto& uid : buffered_uids) {
+  for (const auto& uid : buffered_uids_) {
     auto* tmp0 = new QTableWidgetItem(QString::fromStdString(uid.GetUID()));
-    uidList->setItem(row, 1, tmp0);
+    uid_list_->setItem(row, 1, tmp0);
 
     auto* tmp1 = new QTableWidgetItem(QString::fromStdString(uid.GetUID()));
-    uidList->setItem(row, 2, tmp1);
+    uid_list_->setItem(row, 2, tmp1);
 
     auto* tmp2 = new QTableWidgetItem(QString::fromStdString(uid.GetUID()));
-    uidList->setItem(row, 3, tmp2);
+    uid_list_->setItem(row, 3, tmp2);
 
     auto* tmp3 = new QTableWidgetItem(QString::number(row));
     tmp3->setFlags(Qt::ItemIsUserCheckable | Qt::ItemIsEnabled |
                    Qt::ItemIsSelectable);
     tmp3->setTextAlignment(Qt::AlignCenter);
     tmp3->setCheckState(Qt::Unchecked);
-    uidList->setItem(row, 0, tmp3);
+    uid_list_->setItem(row, 0, tmp3);
 
     if (!row) {
-      for (auto i = 0; i < uidList->columnCount(); i++) {
-        uidList->item(row, i)->setForeground(QColor(65, 105, 255));
+      for (auto i = 0; i < uid_list_->columnCount(); i++) {
+        uid_list_->item(row, i)->setForeground(QColor(65, 105, 255));
       }
     }
 
     row++;
   }
 
-  if (uidList->rowCount() > 0) {
-    uidList->selectRow(0);
+  if (uid_list_->rowCount() > 0) {
+    uid_list_->selectRow(0);
   }
 
-  slotRefreshSigList();
-  slotRefreshTOFUInfo();
+  slot_refresh_sig_list();
+  slot_refresh_tofu_info();
 }
 
-void KeyPairUIDTab::slotRefreshTOFUInfo() {
-  if (this->tofuTabs == nullptr) return;
+void KeyPairUIDTab::slot_refresh_tofu_info() {
+  if (this->tofu_tabs_ == nullptr) return;
 
   int uidRow = 0;
-  tofuTabs->clear();
-  for (const auto& uid : buffered_uids) {
+  tofu_tabs_->clear();
+  for (const auto& uid : buffered_uids_) {
     // Only Show Selected UID Signatures
-    if (!uidList->item(uidRow++, 0)->isSelected()) {
+    if (!uid_list_->item(uidRow++, 0)->isSelected()) {
       continue;
     }
     auto tofu_infos = uid.GetTofuInfos();
     LOG(INFO) << "tofu info size" << tofu_infos->size();
     if (tofu_infos->empty()) {
-      tofuTabs->hide();
+      tofu_tabs_->hide();
     } else {
-      tofuTabs->show();
+      tofu_tabs_->show();
     }
     int index = 1;
     for (const auto& tofu_info : *tofu_infos) {
-      tofuTabs->addTab(new TOFUInfoPage(tofu_info, this),
-                       QString(_("TOFU %1")).arg(index++));
+      tofu_tabs_->addTab(new TOFUInfoPage(tofu_info, this),
+                         QString(_("TOFU %1")).arg(index++));
     }
   }
 }
 
-void KeyPairUIDTab::slotRefreshSigList() {
+void KeyPairUIDTab::slot_refresh_sig_list() {
   int uidRow = 0, sigRow = 0;
-  for (const auto& uid : buffered_uids) {
+  for (const auto& uid : buffered_uids_) {
     // Only Show Selected UID Signatures
-    if (!uidList->item(uidRow++, 0)->isSelected()) {
+    if (!uid_list_->item(uidRow++, 0)->isSelected()) {
       continue;
     }
 
-    buffered_signatures.clear();
+    buffered_signatures_.clear();
     auto signatures = uid.GetSignatures();
     for (auto& sig : *signatures) {
       if (sig.IsInvalid() || sig.IsRevoked()) {
         continue;
       }
-      buffered_signatures.push_back(std::move(sig));
+      buffered_signatures_.push_back(std::move(sig));
     }
 
-    sigList->setRowCount(buffered_signatures.size());
+    sig_list_->setRowCount(buffered_signatures_.size());
 
-    for (const auto& sig : buffered_signatures) {
+    for (const auto& sig : buffered_signatures_) {
       auto* tmp0 = new QTableWidgetItem(QString::fromStdString(sig.GetKeyID()));
-      sigList->setItem(sigRow, 0, tmp0);
+      sig_list_->setItem(sigRow, 0, tmp0);
 
       if (gpgme_err_code(sig.GetStatus()) == GPG_ERR_NO_PUBKEY) {
         auto* tmp2 = new QTableWidgetItem("<Unknown>");
-        sigList->setItem(sigRow, 1, tmp2);
+        sig_list_->setItem(sigRow, 1, tmp2);
 
         auto* tmp3 = new QTableWidgetItem("<Unknown>");
-        sigList->setItem(sigRow, 2, tmp3);
+        sig_list_->setItem(sigRow, 2, tmp3);
       } else {
         auto* tmp2 =
             new QTableWidgetItem(QString::fromStdString(sig.GetName()));
-        sigList->setItem(sigRow, 1, tmp2);
+        sig_list_->setItem(sigRow, 1, tmp2);
 
         auto* tmp3 =
             new QTableWidgetItem(QString::fromStdString(sig.GetEmail()));
-        sigList->setItem(sigRow, 2, tmp3);
+        sig_list_->setItem(sigRow, 2, tmp3);
       }
 
       auto* tmp4 = new QTableWidgetItem(QLocale::system().toString(
           QDateTime::fromTime_t(to_time_t(sig.GetCreateTime()))));
-      sigList->setItem(sigRow, 3, tmp4);
+      sig_list_->setItem(sigRow, 3, tmp4);
 
       auto* tmp5 = new QTableWidgetItem(
           boost::posix_time::to_time_t(
@@ -284,7 +284,7 @@ void KeyPairUIDTab::slotRefreshSigList() {
               : QLocale::system().toString(
                     QDateTime::fromTime_t(to_time_t(sig.GetExpireTime()))));
       tmp5->setTextAlignment(Qt::AlignCenter);
-      sigList->setItem(sigRow, 4, tmp5);
+      sig_list_->setItem(sigRow, 4, tmp5);
 
       sigRow++;
     }
@@ -293,8 +293,8 @@ void KeyPairUIDTab::slotRefreshSigList() {
   }
 }
 
-void KeyPairUIDTab::slotAddSign() {
-  auto selected_uids = getUIDChecked();
+void KeyPairUIDTab::slot_add_sign() {
+  auto selected_uids = get_uid_checked();
 
   if (selected_uids->empty()) {
     QMessageBox::information(
@@ -304,43 +304,43 @@ void KeyPairUIDTab::slotAddSign() {
   }
 
   auto keySignDialog =
-      new KeyUIDSignDialog(mKey, std::move(selected_uids), this);
+      new KeyUIDSignDialog(m_key_, std::move(selected_uids), this);
   keySignDialog->show();
 }
 
-UIDArgsListPtr KeyPairUIDTab::getUIDChecked() {
+UIDArgsListPtr KeyPairUIDTab::get_uid_checked() {
   auto selected_uids = std::make_unique<UIDArgsList>();
-  for (int i = 0; i < uidList->rowCount(); i++) {
-    if (uidList->item(i, 0)->checkState() == Qt::Checked)
-      selected_uids->push_back(buffered_uids[i].GetUID());
+  for (int i = 0; i < uid_list_->rowCount(); i++) {
+    if (uid_list_->item(i, 0)->checkState() == Qt::Checked)
+      selected_uids->push_back(buffered_uids_[i].GetUID());
   }
   return selected_uids;
 }
 
-void KeyPairUIDTab::createManageUIDMenu() {
-  manageSelectedUIDMenu = new QMenu(this);
+void KeyPairUIDTab::create_manage_uid_menu() {
+  manage_selected_uid_menu_ = new QMenu(this);
 
   auto* signUIDAct = new QAction(_("Sign Selected UID(s)"), this);
-  connect(signUIDAct, SIGNAL(triggered()), this, SLOT(slotAddSign()));
+  connect(signUIDAct, SIGNAL(triggered()), this, SLOT(slot_add_sign()));
   auto* delUIDAct = new QAction(_("Delete Selected UID(s)"), this);
-  connect(delUIDAct, SIGNAL(triggered()), this, SLOT(slotDelUID()));
+  connect(delUIDAct, SIGNAL(triggered()), this, SLOT(slot_del_uid()));
 
-  if (mKey.IsHasMasterKey()) {
-    manageSelectedUIDMenu->addAction(signUIDAct);
-    manageSelectedUIDMenu->addAction(delUIDAct);
+  if (m_key_.IsHasMasterKey()) {
+    manage_selected_uid_menu_->addAction(signUIDAct);
+    manage_selected_uid_menu_->addAction(delUIDAct);
   }
 }
 
-void KeyPairUIDTab::slotAddUID() {
-  auto keyNewUIDDialog = new KeyNewUIDDialog(mKey.GetId(), this);
+void KeyPairUIDTab::slot_add_uid() {
+  auto keyNewUIDDialog = new KeyNewUIDDialog(m_key_.GetId(), this);
   connect(keyNewUIDDialog, SIGNAL(finished(int)), this,
-          SLOT(slotAddUIDResult(int)));
+          SLOT(slot_add_uid_result(int)));
   connect(keyNewUIDDialog, SIGNAL(finished(int)), keyNewUIDDialog,
           SLOT(deleteLater()));
   keyNewUIDDialog->show();
 }
 
-void KeyPairUIDTab::slotAddUIDResult(int result) {
+void KeyPairUIDTab::slot_add_uid_result(int result) {
   if (result == 1) {
     QMessageBox::information(nullptr, _("Successful Operation"),
                              _("Successfully added a new UID."));
@@ -350,8 +350,8 @@ void KeyPairUIDTab::slotAddUIDResult(int result) {
   }
 }
 
-void KeyPairUIDTab::slotDelUID() {
-  auto selected_uids = getUIDChecked();
+void KeyPairUIDTab::slot_del_uid() {
+  auto selected_uids = get_uid_checked();
 
   if (selected_uids->empty()) {
     QMessageBox::information(
@@ -377,20 +377,20 @@ void KeyPairUIDTab::slotDelUID() {
 
   if (ret == QMessageBox::Yes) {
     for (const auto& uid : *selected_uids) {
-      LOG(INFO) << "KeyPairUIDTab::slotDelUID UID" << uid;
-      if (!UIDOperator::GetInstance().RevUID(mKey, uid)) {
+      LOG(INFO) << "KeyPairUIDTab::slot_del_uid UID" << uid;
+      if (!UIDOperator::GetInstance().RevUID(m_key_, uid)) {
         QMessageBox::critical(
             nullptr, _("Operation Failed"),
             QString(_("An error occurred during the delete %1 operation."))
                 .arg(uid.c_str()));
       }
     }
-    emit signalUpdateUIDInfo();
+    emit SignalUpdateUIDInfo();
   }
 }
 
-void KeyPairUIDTab::slotSetPrimaryUID() {
-  auto selected_uids = getUIDSelected();
+void KeyPairUIDTab::slot_set_primary_uid() {
+  auto selected_uids = get_uid_selected();
 
   if (selected_uids->empty()) {
     auto emptyUIDMsg = new QMessageBox();
@@ -413,59 +413,59 @@ void KeyPairUIDTab::slotSetPrimaryUID() {
       QMessageBox::No | QMessageBox::Yes);
 
   if (ret == QMessageBox::Yes) {
-    if (!UIDOperator::GetInstance().SetPrimaryUID(mKey,
+    if (!UIDOperator::GetInstance().SetPrimaryUID(m_key_,
                                                   selected_uids->front())) {
       QMessageBox::critical(nullptr, _("Operation Failed"),
                             _("An error occurred during the operation."));
     } else {
-      emit signalUpdateUIDInfo();
+      emit SignalUpdateUIDInfo();
     }
   }
 }
 
-UIDArgsListPtr KeyPairUIDTab::getUIDSelected() {
+UIDArgsListPtr KeyPairUIDTab::get_uid_selected() {
   auto uids = std::make_unique<UIDArgsList>();
-  for (int i = 0; i < uidList->rowCount(); i++) {
-    if (uidList->item(i, 0)->isSelected()) {
-      uids->push_back(buffered_uids[i].GetUID());
+  for (int i = 0; i < uid_list_->rowCount(); i++) {
+    if (uid_list_->item(i, 0)->isSelected()) {
+      uids->push_back(buffered_uids_[i].GetUID());
     }
   }
   return uids;
 }
 
-SignIdArgsListPtr KeyPairUIDTab::getSignSelected() {
+SignIdArgsListPtr KeyPairUIDTab::get_sign_selected() {
   auto signatures = std::make_unique<SignIdArgsList>();
-  for (int i = 0; i < sigList->rowCount(); i++) {
-    if (sigList->item(i, 0)->isSelected()) {
-      auto& sign = buffered_signatures[i];
+  for (int i = 0; i < sig_list_->rowCount(); i++) {
+    if (sig_list_->item(i, 0)->isSelected()) {
+      auto& sign = buffered_signatures_[i];
       signatures->push_back({sign.GetKeyID(), sign.GetUID()});
     }
   }
   return signatures;
 }
 
-void KeyPairUIDTab::createUIDPopupMenu() {
-  uidPopupMenu = new QMenu(this);
+void KeyPairUIDTab::create_uid_popup_menu() {
+  uid_popup_menu_ = new QMenu(this);
 
   auto* serPrimaryUIDAct = new QAction(_("Set As Primary"), this);
   connect(serPrimaryUIDAct, SIGNAL(triggered()), this,
-          SLOT(slotSetPrimaryUID()));
+          SLOT(slot_set_primary_uid()));
   auto* signUIDAct = new QAction(_("Sign UID"), this);
-  connect(signUIDAct, SIGNAL(triggered()), this, SLOT(slotAddSignSingle()));
+  connect(signUIDAct, SIGNAL(triggered()), this, SLOT(slot_add_sign_single()));
   auto* delUIDAct = new QAction(_("Delete UID"), this);
-  connect(delUIDAct, SIGNAL(triggered()), this, SLOT(slotDelUIDSingle()));
+  connect(delUIDAct, SIGNAL(triggered()), this, SLOT(slot_del_uid_single()));
 
-  if (mKey.IsHasMasterKey()) {
-    uidPopupMenu->addAction(serPrimaryUIDAct);
-    uidPopupMenu->addAction(signUIDAct);
-    uidPopupMenu->addAction(delUIDAct);
+  if (m_key_.IsHasMasterKey()) {
+    uid_popup_menu_->addAction(serPrimaryUIDAct);
+    uid_popup_menu_->addAction(signUIDAct);
+    uid_popup_menu_->addAction(delUIDAct);
   }
 }
 
 void KeyPairUIDTab::contextMenuEvent(QContextMenuEvent* event) {
-  if (uidList->selectedItems().length() > 0 &&
-      sigList->selectedItems().isEmpty()) {
-    uidPopupMenu->exec(event->globalPos());
+  if (uid_list_->selectedItems().length() > 0 &&
+      sig_list_->selectedItems().isEmpty()) {
+    uid_popup_menu_->exec(event->globalPos());
   }
 
   //  if (!sigList->selectedItems().isEmpty()) {
@@ -473,8 +473,8 @@ void KeyPairUIDTab::contextMenuEvent(QContextMenuEvent* event) {
   //  }
 }
 
-void KeyPairUIDTab::slotAddSignSingle() {
-  auto selected_uids = getUIDSelected();
+void KeyPairUIDTab::slot_add_sign_single() {
+  auto selected_uids = get_uid_selected();
 
   if (selected_uids->empty()) {
     QMessageBox::information(
@@ -484,12 +484,12 @@ void KeyPairUIDTab::slotAddSignSingle() {
   }
 
   auto keySignDialog =
-      new KeyUIDSignDialog(mKey, std::move(selected_uids), this);
+      new KeyUIDSignDialog(m_key_, std::move(selected_uids), this);
   keySignDialog->show();
 }
 
-void KeyPairUIDTab::slotDelUIDSingle() {
-  auto selected_uids = getUIDSelected();
+void KeyPairUIDTab::slot_del_uid_single() {
+  auto selected_uids = get_uid_selected();
   if (selected_uids->empty()) {
     QMessageBox::information(
         nullptr, _("Invalid Operation"),
@@ -512,26 +512,26 @@ void KeyPairUIDTab::slotDelUIDSingle() {
       QMessageBox::No | QMessageBox::Yes);
 
   if (ret == QMessageBox::Yes) {
-    if (!UIDOperator::GetInstance().RevUID(mKey, selected_uids->front())) {
+    if (!UIDOperator::GetInstance().RevUID(m_key_, selected_uids->front())) {
       QMessageBox::critical(nullptr, _("Operation Failed"),
                             _("An error occurred during the operation."));
     } else {
-      emit signalUpdateUIDInfo();
+      emit SignalUpdateUIDInfo();
     }
   }
 }
 
-void KeyPairUIDTab::createSignPopupMenu() {
-  signPopupMenu = new QMenu(this);
+void KeyPairUIDTab::create_sign_popup_menu() {
+  sign_popup_menu_ = new QMenu(this);
 
   auto* delSignAct = new QAction(_("Delete(Revoke) Key Signature"), this);
-  connect(delSignAct, SIGNAL(triggered()), this, SLOT(slotDelSign()));
+  connect(delSignAct, SIGNAL(triggered()), this, SLOT(slot_del_sign()));
 
-  signPopupMenu->addAction(delSignAct);
+  sign_popup_menu_->addAction(delSignAct);
 }
 
-void KeyPairUIDTab::slotDelSign() {
-  auto selected_signs = getSignSelected();
+void KeyPairUIDTab::slot_del_sign() {
+  auto selected_signs = get_sign_selected();
   if (selected_signs->empty()) {
     QMessageBox::information(
         nullptr, _("Invalid Operation"),
@@ -564,17 +564,17 @@ void KeyPairUIDTab::slotDelSign() {
                            QMessageBox::No | QMessageBox::Yes);
 
   if (ret == QMessageBox::Yes) {
-    if (!GpgKeyManager::GetInstance().RevSign(mKey, selected_signs)) {
+    if (!GpgKeyManager::GetInstance().RevSign(m_key_, selected_signs)) {
       QMessageBox::critical(nullptr, _("Operation Failed"),
                             _("An error occurred during the operation."));
     }
   }
 }
-void KeyPairUIDTab::slotRefreshKey() {
-  this->mKey = GpgKeyGetter::GetInstance().GetKey(this->mKey.GetId());
-  this->slotRefreshUIDList();
-  this->slotRefreshTOFUInfo();
-  this->slotRefreshSigList();
+void KeyPairUIDTab::slot_refresh_key() {
+  this->m_key_ = GpgKeyGetter::GetInstance().GetKey(this->m_key_.GetId());
+  this->slot_refresh_uid_list();
+  this->slot_refresh_tofu_info();
+  this->slot_refresh_sig_list();
 }
 
 }  // namespace GpgFrontend::UI