refactor: make some function names shorter

21 files changed, 284 insertions, 312 deletions

diff --git a/src/core/function/gpg/GpgBasicOperator.cpp b/src/core/function/gpg/GpgBasicOperator.cpp
index fe84336d..7f36e60a 100644
--- a/src/core/function/gpg/GpgBasicOperator.cpp
+++ b/src/core/function/gpg/GpgBasicOperator.cpp
@@ -50,7 +50,7 @@ void SetSignersImpl(GpgContext& ctx_, const KeyArgsList& signers, bool ascii) {
 
   for (const GpgKey& key : signers) {
     LOG_D() << "signer's key fpr: " << key.GetFingerprint();
-    if (key.IsHasActualSigningCapability()) {
+    if (key.IsHasActualSignCap()) {
       auto error = gpgme_signers_add(ctx, gpgme_key_t(key));
       CheckGpgError(error);
     }
diff --git a/src/core/function/gpg/GpgKeyOpera.cpp b/src/core/function/gpg/GpgKeyOpera.cpp
index 82001337..23a848ee 100644
--- a/src/core/function/gpg/GpgKeyOpera.cpp
+++ b/src/core/function/gpg/GpgKeyOpera.cpp
@@ -179,15 +179,15 @@ auto GenerateKeyImpl(GpgContext& ctx,
   unsigned int flags = 0;
 
   if (!params->IsSubKey()) flags |= GPGME_CREATE_CERT;
-  if (params->IsAllowEncryption()) flags |= GPGME_CREATE_ENCR;
-  if (params->IsAllowSigning()) flags |= GPGME_CREATE_SIGN;
-  if (params->IsAllowAuthentication()) flags |= GPGME_CREATE_AUTH;
+  if (params->IsAllowEncr()) flags |= GPGME_CREATE_ENCR;
+  if (params->IsAllowSign()) flags |= GPGME_CREATE_SIGN;
+  if (params->IsAllowAuth()) flags |= GPGME_CREATE_AUTH;
   if (params->IsNonExpired()) flags |= GPGME_CREATE_NOEXPIRE;
   if (params->IsNoPassPhrase()) flags |= GPGME_CREATE_NOPASSWD;
 
   LOG_D() << "key generation args: " << userid << algo << expires << flags;
-  LOG_D() << "key generation flags" << params->IsAllowEncryption()
-          << params->IsAllowSigning() << params->IsAllowAuthentication()
+  LOG_D() << "key generation flags" << params->IsAllowEncr()
+          << params->IsAllowSign() << params->IsAllowAuth()
           << !params->IsSubKey();
 
   err = gpgme_op_createkey(ctx.DefaultContext(), userid.toUtf8(), algo.toUtf8(),
@@ -240,9 +240,9 @@ auto GenerateSubKeyImpl(GpgContext& ctx, const GpgKey& key,
   unsigned int flags = 0;
 
   if (!params->IsSubKey()) flags |= GPGME_CREATE_CERT;
-  if (params->IsAllowEncryption()) flags |= GPGME_CREATE_ENCR;
-  if (params->IsAllowSigning()) flags |= GPGME_CREATE_SIGN;
-  if (params->IsAllowAuthentication()) flags |= GPGME_CREATE_AUTH;
+  if (params->IsAllowEncr()) flags |= GPGME_CREATE_ENCR;
+  if (params->IsAllowSign()) flags |= GPGME_CREATE_SIGN;
+  if (params->IsAllowAuth()) flags |= GPGME_CREATE_AUTH;
   if (params->IsNonExpired()) flags |= GPGME_CREATE_NOEXPIRE;
   if (params->IsNoPassPhrase()) flags |= GPGME_CREATE_NOPASSWD;
 
diff --git a/src/core/model/GpgKey.cpp b/src/core/model/GpgKey.cpp
index 9b0ce1a5..2bf15f3a 100644
--- a/src/core/model/GpgKey.cpp
+++ b/src/core/model/GpgKey.cpp
@@ -28,8 +28,6 @@
 
 #include "core/model/GpgKey.h"
 
-#include <mutex>
-
 namespace GpgFrontend {
 
 GpgKey::GpgKey(gpgme_key_t &&key) : key_ref_(key) {}
@@ -149,21 +147,13 @@ auto GpgKey::GetPrimaryKeyLength() const -> unsigned int {
   return key_ref_->subkeys->length;
 }
 
-auto GpgKey::IsHasEncryptionCapability() const -> bool {
-  return key_ref_->can_encrypt;
-}
+auto GpgKey::IsHasEncrCap() const -> bool { return key_ref_->can_encrypt; }
 
-auto GpgKey::IsHasSigningCapability() const -> bool {
-  return key_ref_->can_sign;
-}
+auto GpgKey::IsHasSignCap() const -> bool { return key_ref_->can_sign; }
 
-auto GpgKey::IsHasCertificationCapability() const -> bool {
-  return key_ref_->can_certify;
-}
+auto GpgKey::IsHasCertCap() const -> bool { return key_ref_->can_certify; }
 
-auto GpgKey::IsHasAuthenticationCapability() const -> bool {
-  return key_ref_->can_authenticate;
-}
+auto GpgKey::IsHasAuthCap() const -> bool { return key_ref_->can_authenticate; }
 
 auto GpgKey::IsHasCardKey() const -> bool {
   auto subkeys = GetSubKeys();
@@ -204,24 +194,24 @@ auto GpgKey::GetUIDs() const -> std::unique_ptr<QContainer<GpgUID>> {
   return p_uids;
 }
 
-auto GpgKey::IsHasActualSigningCapability() const -> bool {
+auto GpgKey::IsHasActualSignCap() const -> bool {
   auto subkeys = GetSubKeys();
-  return std::any_of(
-      subkeys->begin(), subkeys->end(), [](const GpgSubKey &subkey) -> bool {
-        return subkey.IsSecretKey() && subkey.IsHasSigningCapability() &&
-               !subkey.IsDisabled() && !subkey.IsRevoked() &&
-               !subkey.IsExpired();
-      });
+  return std::any_of(subkeys->begin(), subkeys->end(),
+                     [](const GpgSubKey &subkey) -> bool {
+                       return subkey.IsSecretKey() && subkey.IsHasSignCap() &&
+                              !subkey.IsDisabled() && !subkey.IsRevoked() &&
+                              !subkey.IsExpired();
+                     });
 }
 
-auto GpgKey::IsHasActualAuthenticationCapability() const -> bool {
+auto GpgKey::IsHasActualAuthCap() const -> bool {
   auto subkeys = GetSubKeys();
-  return std::any_of(
-      subkeys->begin(), subkeys->end(), [](const GpgSubKey &subkey) -> bool {
-        return subkey.IsSecretKey() && subkey.IsHasAuthenticationCapability() &&
-               !subkey.IsDisabled() && !subkey.IsRevoked() &&
-               !subkey.IsExpired();
-      });
+  return std::any_of(subkeys->begin(), subkeys->end(),
+                     [](const GpgSubKey &subkey) -> bool {
+                       return subkey.IsSecretKey() && subkey.IsHasAuthCap() &&
+                              !subkey.IsDisabled() && !subkey.IsRevoked() &&
+                              !subkey.IsExpired();
+                     });
 }
 
 /**
@@ -229,7 +219,7 @@ auto GpgKey::IsHasActualAuthenticationCapability() const -> bool {
  * @param key target key
  * @return if key certify
  */
-auto GpgKey::IsHasActualCertificationCapability() const -> bool {
+auto GpgKey::IsHasActualCertCap() const -> bool {
   return IsHasMasterKey() && !IsExpired() && !IsRevoked() && !IsDisabled();
 }
 
@@ -238,13 +228,13 @@ auto GpgKey::IsHasActualCertificationCapability() const -> bool {
  * @param key target key
  * @return if key encrypt
  */
-auto GpgKey::IsHasActualEncryptionCapability() const -> bool {
+auto GpgKey::IsHasActualEncrCap() const -> bool {
   auto subkeys = GetSubKeys();
-  return std::any_of(
-      subkeys->begin(), subkeys->end(), [](const GpgSubKey &subkey) -> bool {
-        return subkey.IsHasEncryptionCapability() && !subkey.IsDisabled() &&
-               !subkey.IsRevoked() && !subkey.IsExpired();
-      });
+  return std::any_of(subkeys->begin(), subkeys->end(),
+                     [](const GpgSubKey &subkey) -> bool {
+                       return subkey.IsHasEncrCap() && !subkey.IsDisabled() &&
+                              !subkey.IsRevoked() && !subkey.IsExpired();
+                     });
 }
 
 void GpgKey::KeyRefDeleter::operator()(gpgme_key_t _key) {
diff --git a/src/core/model/GpgKey.h b/src/core/model/GpgKey.h
index adc2ffa9..1f902ca5 100644
--- a/src/core/model/GpgKey.h
+++ b/src/core/model/GpgKey.h
@@ -152,7 +152,7 @@ class GPGFRONTEND_CORE_EXPORT GpgKey {
    * @return true
    * @return false
    */
-  [[nodiscard]] auto IsHasEncryptionCapability() const -> bool;
+  [[nodiscard]] auto IsHasEncrCap() const -> bool;
 
   /**
    * @brief
@@ -161,7 +161,7 @@ class GPGFRONTEND_CORE_EXPORT GpgKey {
    * @return true
    * @return false
    */
-  [[nodiscard]] auto IsHasActualEncryptionCapability() const -> bool;
+  [[nodiscard]] auto IsHasActualEncrCap() const -> bool;
 
   /**
    * @brief
@@ -169,7 +169,7 @@ class GPGFRONTEND_CORE_EXPORT GpgKey {
    * @return true
    * @return false
    */
-  [[nodiscard]] auto IsHasSigningCapability() const -> bool;
+  [[nodiscard]] auto IsHasSignCap() const -> bool;
 
   /**
    * @brief
@@ -177,7 +177,7 @@ class GPGFRONTEND_CORE_EXPORT GpgKey {
    * @return true
    * @return false
    */
-  [[nodiscard]] auto IsHasActualSigningCapability() const -> bool;
+  [[nodiscard]] auto IsHasActualSignCap() const -> bool;
 
   /**
    * @brief
@@ -185,7 +185,7 @@ class GPGFRONTEND_CORE_EXPORT GpgKey {
    * @return true
    * @return false
    */
-  [[nodiscard]] auto IsHasCertificationCapability() const -> bool;
+  [[nodiscard]] auto IsHasCertCap() const -> bool;
 
   /**
    * @brief
@@ -193,7 +193,7 @@ class GPGFRONTEND_CORE_EXPORT GpgKey {
    * @return true
    * @return false
    */
-  [[nodiscard]] auto IsHasActualCertificationCapability() const -> bool;
+  [[nodiscard]] auto IsHasActualCertCap() const -> bool;
 
   /**
    * @brief
@@ -201,7 +201,7 @@ class GPGFRONTEND_CORE_EXPORT GpgKey {
    * @return true
    * @return false
    */
-  [[nodiscard]] auto IsHasAuthenticationCapability() const -> bool;
+  [[nodiscard]] auto IsHasAuthCap() const -> bool;
 
   /**
    * @brief
@@ -209,7 +209,7 @@ class GPGFRONTEND_CORE_EXPORT GpgKey {
    * @return true
    * @return false
    */
-  [[nodiscard]] auto IsHasActualAuthenticationCapability() const -> bool;
+  [[nodiscard]] auto IsHasActualAuthCap() const -> bool;
 
   /**
    * @brief
diff --git a/src/core/model/GpgKeyGenerateInfo.cpp b/src/core/model/GpgKeyGenerateInfo.cpp
index 1493c3af..a8dcbd19 100644
--- a/src/core/model/GpgKeyGenerateInfo.cpp
+++ b/src/core/model/GpgKeyGenerateInfo.cpp
@@ -169,16 +169,16 @@ void KeyGenerateInfo::SetAlgo(const KeyAlgo &algo) {
   // reset all options
   reset_options();
 
-  this->SetAllowCertification(algo.CanCert());
+  this->SetAllowCert(algo.CanCert());
   this->allow_change_certification_ = false;
 
-  SetAllowEncryption(algo.CanEncrypt());
+  SetAllowEncr(algo.CanEncrypt());
   allow_change_encryption_ = algo.CanEncrypt();
 
-  SetAllowSigning(algo.CanSign());
+  SetAllowSign(algo.CanSign());
   allow_change_signing_ = algo.CanSign();
 
-  SetAllowAuthentication(algo.CanAuth());
+  SetAllowAuth(algo.CanAuth());
   allow_change_authentication_ = algo.CanAuth();
 
   this->algo_ = algo;
@@ -186,16 +186,16 @@ void KeyGenerateInfo::SetAlgo(const KeyAlgo &algo) {
 
 void KeyGenerateInfo::reset_options() {
   allow_change_encryption_ = true;
-  SetAllowEncryption(true);
+  SetAllowEncr(true);
 
   allow_change_certification_ = true;
-  SetAllowCertification(true);
+  SetAllowCert(true);
 
   allow_change_signing_ = true;
-  SetAllowSigning(true);
+  SetAllowSign(true);
 
   allow_change_authentication_ = true;
-  SetAllowAuthentication(true);
+  SetAllowAuth(true);
 }
 
 void KeyGenerateInfo::SetExpireTime(const QDateTime &m_expired) {
@@ -207,13 +207,13 @@ void KeyGenerateInfo::SetNonExpired(bool m_non_expired) {
   KeyGenerateInfo::non_expired_ = m_non_expired;
 }
 
-void KeyGenerateInfo::SetAllowEncryption(bool m_allow_encryption) {
+void KeyGenerateInfo::SetAllowEncr(bool m_allow_encryption) {
   if (allow_change_encryption_) {
     KeyGenerateInfo::allow_encryption_ = m_allow_encryption;
   }
 }
 
-void KeyGenerateInfo::SetAllowCertification(bool m_allow_certification) {
+void KeyGenerateInfo::SetAllowCert(bool m_allow_certification) {
   if (allow_change_certification_) {
     KeyGenerateInfo::allow_certification_ = m_allow_certification;
   }
@@ -357,7 +357,7 @@ void KeyGenerateInfo::SetNonPassPhrase(bool m_non_pass_phrase) {
  * @return true
  * @return false
  */
-[[nodiscard]] auto KeyGenerateInfo::IsAllowSigning() const -> bool {
+[[nodiscard]] auto KeyGenerateInfo::IsAllowSign() const -> bool {
   return allow_signing_;
 }
 
@@ -376,7 +376,7 @@ void KeyGenerateInfo::SetNonPassPhrase(bool m_non_pass_phrase) {
  *
  * @param m_allow_signing
  */
-void KeyGenerateInfo::SetAllowSigning(bool m_allow_signing) {
+void KeyGenerateInfo::SetAllowSign(bool m_allow_signing) {
   if (allow_change_signing_) KeyGenerateInfo::allow_signing_ = m_allow_signing;
 }
 
@@ -386,7 +386,7 @@ void KeyGenerateInfo::SetAllowSigning(bool m_allow_signing) {
  * @return true
  * @return false
  */
-[[nodiscard]] auto KeyGenerateInfo::IsAllowEncryption() const -> bool {
+[[nodiscard]] auto KeyGenerateInfo::IsAllowEncr() const -> bool {
   return allow_encryption_;
 }
 
@@ -396,7 +396,7 @@ void KeyGenerateInfo::SetAllowSigning(bool m_allow_signing) {
  * @return true
  * @return false
  */
-[[nodiscard]] auto KeyGenerateInfo::IsAllowCertification() const -> bool {
+[[nodiscard]] auto KeyGenerateInfo::IsAllowCert() const -> bool {
   return allow_certification_;
 }
 
@@ -406,7 +406,7 @@ void KeyGenerateInfo::SetAllowSigning(bool m_allow_signing) {
  * @return true
  * @return false
  */
-[[nodiscard]] auto KeyGenerateInfo::IsAllowAuthentication() const -> bool {
+[[nodiscard]] auto KeyGenerateInfo::IsAllowAuth() const -> bool {
   return allow_authentication_;
 }
 
@@ -415,7 +415,7 @@ void KeyGenerateInfo::SetAllowSigning(bool m_allow_signing) {
  *
  * @param m_allow_authentication
  */
-void KeyGenerateInfo::SetAllowAuthentication(bool m_allow_authentication) {
+void KeyGenerateInfo::SetAllowAuth(bool m_allow_authentication) {
   if (allow_change_authentication_) {
     KeyGenerateInfo::allow_authentication_ = m_allow_authentication;
   }
@@ -427,7 +427,7 @@ void KeyGenerateInfo::SetAllowAuthentication(bool m_allow_authentication) {
  * @return true
  * @return false
  */
-[[nodiscard]] auto KeyGenerateInfo::IsAllowChangeSigning() const -> bool {
+[[nodiscard]] auto KeyGenerateInfo::IsAllowModifySign() const -> bool {
   return allow_change_signing_;
 }
 
@@ -437,7 +437,7 @@ void KeyGenerateInfo::SetAllowAuthentication(bool m_allow_authentication) {
  * @return true
  * @return false
  */
-[[nodiscard]] auto KeyGenerateInfo::IsAllowChangeEncryption() const -> bool {
+[[nodiscard]] auto KeyGenerateInfo::IsAllowModifyEncr() const -> bool {
   return allow_change_encryption_;
 }
 
@@ -447,7 +447,7 @@ void KeyGenerateInfo::SetAllowAuthentication(bool m_allow_authentication) {
  * @return true
  * @return false
  */
-[[nodiscard]] auto KeyGenerateInfo::IsAllowChangeCertification() const -> bool {
+[[nodiscard]] auto KeyGenerateInfo::IsAllowModifyCert() const -> bool {
   return allow_change_certification_;
 }
 
@@ -457,8 +457,7 @@ void KeyGenerateInfo::SetAllowAuthentication(bool m_allow_authentication) {
  * @return true
  * @return false
  */
-[[nodiscard]] auto KeyGenerateInfo::IsAllowChangeAuthentication() const
-    -> bool {
+[[nodiscard]] auto KeyGenerateInfo::IsAllowModifyAuth() const -> bool {
   return allow_change_authentication_;
 }
 
diff --git a/src/core/model/GpgKeyGenerateInfo.h b/src/core/model/GpgKeyGenerateInfo.h
index 54ec5a29..98902418 100644
--- a/src/core/model/GpgKeyGenerateInfo.h
+++ b/src/core/model/GpgKeyGenerateInfo.h
@@ -257,7 +257,7 @@ class GPGFRONTEND_CORE_EXPORT KeyGenerateInfo {
    * @return true
    * @return false
    */
-  [[nodiscard]] auto IsAllowSigning() const -> bool;
+  [[nodiscard]] auto IsAllowSign() const -> bool;
 
   /**
    * @brief
@@ -272,7 +272,7 @@ class GPGFRONTEND_CORE_EXPORT KeyGenerateInfo {
    *
    * @param m_allow_signing
    */
-  void SetAllowSigning(bool m_allow_signing);
+  void SetAllowSign(bool m_allow_signing);
 
   /**
    * @brief
@@ -280,14 +280,14 @@ class GPGFRONTEND_CORE_EXPORT KeyGenerateInfo {
    * @return true
    * @return false
    */
-  [[nodiscard]] auto IsAllowEncryption() const -> bool;
+  [[nodiscard]] auto IsAllowEncr() const -> bool;
 
   /**
    * @brief Set the Allow Encryption object
    *
    * @param m_allow_encryption
    */
-  void SetAllowEncryption(bool m_allow_encryption);
+  void SetAllowEncr(bool m_allow_encryption);
 
   /**
    * @brief
@@ -295,14 +295,14 @@ class GPGFRONTEND_CORE_EXPORT KeyGenerateInfo {
    * @return true
    * @return false
    */
-  [[nodiscard]] auto IsAllowCertification() const -> bool;
+  [[nodiscard]] auto IsAllowCert() const -> bool;
 
   /**
    * @brief Set the Allow Certification object
    *
    * @param m_allow_certification
    */
-  void SetAllowCertification(bool m_allow_certification);
+  void SetAllowCert(bool m_allow_certification);
 
   /**
    * @brief
@@ -310,14 +310,14 @@ class GPGFRONTEND_CORE_EXPORT KeyGenerateInfo {
    * @return true
    * @return false
    */
-  [[nodiscard]] auto IsAllowAuthentication() const -> bool;
+  [[nodiscard]] auto IsAllowAuth() const -> bool;
 
   /**
    * @brief Set the Allow Authentication object
    *
    * @param m_allow_authentication
    */
-  void SetAllowAuthentication(bool m_allow_authentication);
+  void SetAllowAuth(bool m_allow_authentication);
 
   /**
    * @brief
@@ -325,7 +325,7 @@ class GPGFRONTEND_CORE_EXPORT KeyGenerateInfo {
    * @return true
    * @return false
    */
-  [[nodiscard]] auto IsAllowChangeSigning() const -> bool;
+  [[nodiscard]] auto IsAllowModifySign() const -> bool;
 
   /**
    * @brief
@@ -333,7 +333,7 @@ class GPGFRONTEND_CORE_EXPORT KeyGenerateInfo {
    * @return true
    * @return false
    */
-  [[nodiscard]] auto IsAllowChangeEncryption() const -> bool;
+  [[nodiscard]] auto IsAllowModifyEncr() const -> bool;
 
   /**
    * @brief
@@ -341,7 +341,7 @@ class GPGFRONTEND_CORE_EXPORT KeyGenerateInfo {
    * @return true
    * @return false
    */
-  [[nodiscard]] auto IsAllowChangeCertification() const -> bool;
+  [[nodiscard]] auto IsAllowModifyCert() const -> bool;
 
   /**
    * @brief
@@ -349,7 +349,7 @@ class GPGFRONTEND_CORE_EXPORT KeyGenerateInfo {
    * @return true
    * @return false
    */
-  [[nodiscard]] auto IsAllowChangeAuthentication() const -> bool;
+  [[nodiscard]] auto IsAllowModifyAuth() const -> bool;
 
  private:
   bool subkey_ = false;  ///<
diff --git a/src/core/model/GpgKeyTableModel.cpp b/src/core/model/GpgKeyTableModel.cpp
index 17a59a3a..b9d03bb6 100644
--- a/src/core/model/GpgKeyTableModel.cpp
+++ b/src/core/model/GpgKeyTableModel.cpp
@@ -88,10 +88,10 @@ auto GpgKeyTableModel::data(const QModelIndex &index,
       }
       case 4: {
         QString usage_sym;
-        if (key.IsHasActualCertificationCapability()) usage_sym += "C";
-        if (key.IsHasActualEncryptionCapability()) usage_sym += "E";
-        if (key.IsHasActualSigningCapability()) usage_sym += "S";
-        if (key.IsHasActualAuthenticationCapability()) usage_sym += "A";
+        if (key.IsHasActualCertCap()) usage_sym += "C";
+        if (key.IsHasActualEncrCap()) usage_sym += "E";
+        if (key.IsHasActualSignCap()) usage_sym += "S";
+        if (key.IsHasActualAuthCap()) usage_sym += "A";
         return usage_sym;
       }
       case 5: {
diff --git a/src/core/model/GpgSubKey.cpp b/src/core/model/GpgSubKey.cpp
index eba4167e..98b87706 100644
--- a/src/core/model/GpgSubKey.cpp
+++ b/src/core/model/GpgSubKey.cpp
@@ -60,19 +60,17 @@ auto GpgSubKey::GetKeyLength() const -> unsigned int {
   return subkey_ref_->length;
 }
 
-auto GpgSubKey::IsHasEncryptionCapability() const -> bool {
+auto GpgSubKey::IsHasEncrCap() const -> bool {
   return subkey_ref_->can_encrypt;
 }
 
-auto GpgSubKey::IsHasSigningCapability() const -> bool {
-  return subkey_ref_->can_sign;
-}
+auto GpgSubKey::IsHasSignCap() const -> bool { return subkey_ref_->can_sign; }
 
-auto GpgSubKey::IsHasCertificationCapability() const -> bool {
+auto GpgSubKey::IsHasCertCap() const -> bool {
   return subkey_ref_->can_certify;
 }
 
-auto GpgSubKey::IsHasAuthenticationCapability() const -> bool {
+auto GpgSubKey::IsHasAuthCap() const -> bool {
   return subkey_ref_->can_authenticate;
 }
 
diff --git a/src/core/model/GpgSubKey.h b/src/core/model/GpgSubKey.h
index 58c6298a..f7d6afd9 100644
--- a/src/core/model/GpgSubKey.h
+++ b/src/core/model/GpgSubKey.h
@@ -81,7 +81,7 @@ class GPGFRONTEND_CORE_EXPORT GpgSubKey {
    * @return true
    * @return false
    */
-  [[nodiscard]] auto IsHasEncryptionCapability() const -> bool;
+  [[nodiscard]] auto IsHasEncrCap() const -> bool;
 
   /**
    * @brief
@@ -89,7 +89,7 @@ class GPGFRONTEND_CORE_EXPORT GpgSubKey {
    * @return true
    * @return false
    */
-  [[nodiscard]] auto IsHasSigningCapability() const -> bool;
+  [[nodiscard]] auto IsHasSignCap() const -> bool;
 
   /**
    * @brief
@@ -97,7 +97,7 @@ class GPGFRONTEND_CORE_EXPORT GpgSubKey {
    * @return true
    * @return false
    */
-  [[nodiscard]] auto IsHasCertificationCapability() const -> bool;
+  [[nodiscard]] auto IsHasCertCap() const -> bool;
 
   /**
    * @brief
@@ -105,7 +105,7 @@ class GPGFRONTEND_CORE_EXPORT GpgSubKey {
    * @return true
    * @return false
    */
-  [[nodiscard]] auto IsHasAuthenticationCapability() const -> bool;
+  [[nodiscard]] auto IsHasAuthCap() const -> bool;
 
   /**
    * @brief
diff --git a/src/test/core/GpgCoreTestBasicOpera.cpp b/src/test/core/GpgCoreTestBasicOpera.cpp
index 4a593532..a7bdfead 100644
--- a/src/test/core/GpgCoreTestBasicOpera.cpp
+++ b/src/test/core/GpgCoreTestBasicOpera.cpp
@@ -241,7 +241,7 @@ TEST_F(GpgCoreTest, CoreEncryptSignDecrVerifyTest) {
   auto encrypt_text = GFBuffer(QString("Hello GpgFrontend!"));
 
   ASSERT_TRUE(sign_key.IsPrivateKey());
-  ASSERT_TRUE(sign_key.IsHasActualSigningCapability());
+  ASSERT_TRUE(sign_key.IsHasActualSignCap());
 
   auto [err, data_object] = GpgBasicOperator::GetInstance().EncryptSignSync(
       {encrypt_key}, {sign_key}, encrypt_text, true);
diff --git a/src/test/core/GpgCoreTestFileBasicOpera.cpp b/src/test/core/GpgCoreTestFileBasicOpera.cpp
index 9a0c6a34..bb108499 100644
--- a/src/test/core/GpgCoreTestFileBasicOpera.cpp
+++ b/src/test/core/GpgCoreTestFileBasicOpera.cpp
@@ -232,7 +232,7 @@ TEST_F(GpgCoreTest, CoreFileEncryptSignDecrVerifyTest) {
   auto output_file = GetTempFilePath();
 
   ASSERT_TRUE(sign_key.IsPrivateKey());
-  ASSERT_TRUE(sign_key.IsHasActualSigningCapability());
+  ASSERT_TRUE(sign_key.IsHasActualSignCap());
 
   auto [err, data_object] = GpgFileOpera::GetInstance().EncryptSignFileSync(
       {encrypt_key}, {sign_key}, input_file, true, output_file);
@@ -279,7 +279,7 @@ TEST_F(GpgCoreTest, CoreFileEncryptSignDecrVerifyBinaryTest) {
   auto output_file = GetTempFilePath();
 
   ASSERT_TRUE(sign_key.IsPrivateKey());
-  ASSERT_TRUE(sign_key.IsHasActualSigningCapability());
+  ASSERT_TRUE(sign_key.IsHasActualSignCap());
 
   auto [err, data_object] = GpgFileOpera::GetInstance().EncryptSignFileSync(
       {encrypt_key}, {sign_key}, input_file, false, output_file);
diff --git a/src/test/core/GpgCoreTestKeyModel.cpp b/src/test/core/GpgCoreTestKeyModel.cpp
index f5078845..622d7009 100644
--- a/src/test/core/GpgCoreTestKeyModel.cpp
+++ b/src/test/core/GpgCoreTestKeyModel.cpp
@@ -69,14 +69,14 @@ TEST_F(GpgCoreTest, GpgKeyTest) {
   ASSERT_EQ(key.GetSubKeys()->size(), 2);
   ASSERT_EQ(key.GetUIDs()->size(), 1);
 
-  ASSERT_TRUE(key.IsHasCertificationCapability());
-  ASSERT_FALSE(key.IsHasEncryptionCapability());
-  ASSERT_TRUE(key.IsHasSigningCapability());
-  ASSERT_FALSE(key.IsHasAuthenticationCapability());
-  ASSERT_FALSE(key.IsHasActualCertificationCapability());
-  ASSERT_FALSE(key.IsHasActualEncryptionCapability());
-  ASSERT_FALSE(key.IsHasActualSigningCapability());
-  ASSERT_FALSE(key.IsHasActualAuthenticationCapability());
+  ASSERT_TRUE(key.IsHasCertCap());
+  ASSERT_FALSE(key.IsHasEncrCap());
+  ASSERT_TRUE(key.IsHasSignCap());
+  ASSERT_FALSE(key.IsHasAuthCap());
+  ASSERT_FALSE(key.IsHasActualCertCap());
+  ASSERT_FALSE(key.IsHasActualEncrCap());
+  ASSERT_FALSE(key.IsHasActualSignCap());
+  ASSERT_FALSE(key.IsHasActualAuthCap());
 
   ASSERT_EQ(key.GetName(), "GpgFrontendTest");
   ASSERT_TRUE(key.GetComment().isEmpty());
@@ -133,10 +133,10 @@ TEST_F(GpgCoreTest, GpgSubKeyTest) {
   ASSERT_EQ(sub_key.GetKeyLength(), 3072);
   ASSERT_EQ(sub_key.GetKeyAlgo(), "RSA3072");
   ASSERT_EQ(sub_key.GetPubkeyAlgo(), "RSA");
-  ASSERT_FALSE(sub_key.IsHasCertificationCapability());
-  ASSERT_FALSE(sub_key.IsHasAuthenticationCapability());
-  ASSERT_FALSE(sub_key.IsHasSigningCapability());
-  ASSERT_TRUE(sub_key.IsHasEncryptionCapability());
+  ASSERT_FALSE(sub_key.IsHasCertCap());
+  ASSERT_FALSE(sub_key.IsHasAuthCap());
+  ASSERT_FALSE(sub_key.IsHasSignCap());
+  ASSERT_TRUE(sub_key.IsHasEncrCap());
   ASSERT_EQ(sub_key.GetExpireTime(),
             QDateTime::fromString("2023-09-05T04:00:00Z", Qt::ISODate));
 
diff --git a/src/test/core/GpgCoreTestKeygen.cpp b/src/test/core/GpgCoreTestKeygen.cpp
index 63b6ad17..a6c28219 100644
--- a/src/test/core/GpgCoreTestKeygen.cpp
+++ b/src/test/core/GpgCoreTestKeygen.cpp
@@ -92,15 +92,15 @@ TEST_F(GpgCoreTest, GenerateKeyRSA2048Test) {
   ASSERT_EQ(key.GetPrimaryKeyLength(), 2048);
   ASSERT_EQ(key.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_TRUE(key.IsHasCertificationCapability());
-  ASSERT_TRUE(key.IsHasAuthenticationCapability());
-  ASSERT_TRUE(key.IsHasEncryptionCapability());
-  ASSERT_TRUE(key.IsHasSigningCapability());
+  ASSERT_TRUE(key.IsHasCertCap());
+  ASSERT_TRUE(key.IsHasAuthCap());
+  ASSERT_TRUE(key.IsHasEncrCap());
+  ASSERT_TRUE(key.IsHasSignCap());
 
-  ASSERT_TRUE(key.IsHasActualCertificationCapability());
-  ASSERT_TRUE(key.IsHasActualAuthenticationCapability());
-  ASSERT_TRUE(key.IsHasActualEncryptionCapability());
-  ASSERT_TRUE(key.IsHasActualSigningCapability());
+  ASSERT_TRUE(key.IsHasActualCertCap());
+  ASSERT_TRUE(key.IsHasActualAuthCap());
+  ASSERT_TRUE(key.IsHasActualEncrCap());
+  ASSERT_TRUE(key.IsHasActualSignCap());
 
   GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
       .DeleteKey(result.GetFingerprint());
@@ -185,15 +185,15 @@ TEST_F(GpgCoreTest, GenerateKeyDSA2048Test) {
   ASSERT_EQ(key.GetPrimaryKeyLength(), 2048);
   ASSERT_GT(key.GetExpireTime(), QDateTime::currentDateTime());
 
-  ASSERT_TRUE(key.IsHasCertificationCapability());
-  ASSERT_TRUE(key.IsHasAuthenticationCapability());
-  ASSERT_FALSE(key.IsHasEncryptionCapability());
-  ASSERT_TRUE(key.IsHasSigningCapability());
+  ASSERT_TRUE(key.IsHasCertCap());
+  ASSERT_TRUE(key.IsHasAuthCap());
+  ASSERT_FALSE(key.IsHasEncrCap());
+  ASSERT_TRUE(key.IsHasSignCap());
 
-  ASSERT_TRUE(key.IsHasActualCertificationCapability());
-  ASSERT_TRUE(key.IsHasActualAuthenticationCapability());
-  ASSERT_FALSE(key.IsHasActualEncryptionCapability());
-  ASSERT_TRUE(key.IsHasActualSigningCapability());
+  ASSERT_TRUE(key.IsHasActualCertCap());
+  ASSERT_TRUE(key.IsHasActualAuthCap());
+  ASSERT_FALSE(key.IsHasActualEncrCap());
+  ASSERT_TRUE(key.IsHasActualSignCap());
 
   GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
       .DeleteKey(result.GetFingerprint());
@@ -239,15 +239,15 @@ TEST_F(GpgCoreTest, GenerateKeyED25519Test) {
   ASSERT_EQ(key.GetPrimaryKeyLength(), 255);
   ASSERT_GT(key.GetExpireTime(), QDateTime::currentDateTime());
 
-  ASSERT_TRUE(key.IsHasCertificationCapability());
-  ASSERT_TRUE(key.IsHasAuthenticationCapability());
-  ASSERT_FALSE(key.IsHasEncryptionCapability());
-  ASSERT_TRUE(key.IsHasSigningCapability());
+  ASSERT_TRUE(key.IsHasCertCap());
+  ASSERT_TRUE(key.IsHasAuthCap());
+  ASSERT_FALSE(key.IsHasEncrCap());
+  ASSERT_TRUE(key.IsHasSignCap());
 
-  ASSERT_TRUE(key.IsHasActualCertificationCapability());
-  ASSERT_TRUE(key.IsHasActualAuthenticationCapability());
-  ASSERT_FALSE(key.IsHasActualEncryptionCapability());
-  ASSERT_TRUE(key.IsHasActualSigningCapability());
+  ASSERT_TRUE(key.IsHasActualCertCap());
+  ASSERT_TRUE(key.IsHasActualAuthCap());
+  ASSERT_FALSE(key.IsHasActualEncrCap());
+  ASSERT_TRUE(key.IsHasActualSignCap());
 
   GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
       .DeleteKey(result.GetFingerprint());
@@ -300,10 +300,10 @@ TEST_F(GpgCoreTest, GenerateKeyED25519CV25519Test) {
   ASSERT_EQ(key.GetPrimaryKeyLength(), 255);
   ASSERT_EQ(key.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_TRUE(key.IsHasCertificationCapability());
-  ASSERT_TRUE(key.IsHasAuthenticationCapability());
-  ASSERT_TRUE(key.IsHasEncryptionCapability());
-  ASSERT_TRUE(key.IsHasSigningCapability());
+  ASSERT_TRUE(key.IsHasCertCap());
+  ASSERT_TRUE(key.IsHasAuthCap());
+  ASSERT_TRUE(key.IsHasEncrCap());
+  ASSERT_TRUE(key.IsHasSignCap());
 
   ASSERT_FALSE(key.GetSubKeys()->empty());
   ASSERT_EQ(key.GetSubKeys()->size(), 2);
@@ -315,15 +315,15 @@ TEST_F(GpgCoreTest, GenerateKeyED25519CV25519Test) {
   ASSERT_EQ(subkey.GetKeyLength(), 255);
   ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertificationCapability());
-  ASSERT_FALSE(subkey.IsHasAuthenticationCapability());
-  ASSERT_TRUE(subkey.IsHasEncryptionCapability());
-  ASSERT_FALSE(subkey.IsHasSigningCapability());
+  ASSERT_FALSE(subkey.IsHasCertCap());
+  ASSERT_FALSE(subkey.IsHasAuthCap());
+  ASSERT_TRUE(subkey.IsHasEncrCap());
+  ASSERT_FALSE(subkey.IsHasSignCap());
 
-  ASSERT_TRUE(key.IsHasActualCertificationCapability());
-  ASSERT_TRUE(key.IsHasActualAuthenticationCapability());
-  ASSERT_TRUE(key.IsHasActualEncryptionCapability());
-  ASSERT_TRUE(key.IsHasActualSigningCapability());
+  ASSERT_TRUE(key.IsHasActualCertCap());
+  ASSERT_TRUE(key.IsHasActualAuthCap());
+  ASSERT_TRUE(key.IsHasActualEncrCap());
+  ASSERT_TRUE(key.IsHasActualSignCap());
 
   GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel).DeleteKey(fpr);
 }
@@ -375,10 +375,10 @@ TEST_F(GpgCoreTest, GenerateKeyED25519NISTP256Test) {
   ASSERT_EQ(key.GetPrimaryKeyLength(), 255);
   ASSERT_EQ(key.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_TRUE(key.IsHasCertificationCapability());
-  ASSERT_TRUE(key.IsHasAuthenticationCapability());
-  ASSERT_TRUE(key.IsHasEncryptionCapability());
-  ASSERT_TRUE(key.IsHasSigningCapability());
+  ASSERT_TRUE(key.IsHasCertCap());
+  ASSERT_TRUE(key.IsHasAuthCap());
+  ASSERT_TRUE(key.IsHasEncrCap());
+  ASSERT_TRUE(key.IsHasSignCap());
 
   ASSERT_FALSE(key.GetSubKeys()->empty());
   ASSERT_EQ(key.GetSubKeys()->size(), 2);
@@ -390,15 +390,15 @@ TEST_F(GpgCoreTest, GenerateKeyED25519NISTP256Test) {
   ASSERT_EQ(subkey.GetKeyLength(), 256);
   ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertificationCapability());
-  ASSERT_FALSE(subkey.IsHasAuthenticationCapability());
-  ASSERT_TRUE(subkey.IsHasEncryptionCapability());
-  ASSERT_FALSE(subkey.IsHasSigningCapability());
+  ASSERT_FALSE(subkey.IsHasCertCap());
+  ASSERT_FALSE(subkey.IsHasAuthCap());
+  ASSERT_TRUE(subkey.IsHasEncrCap());
+  ASSERT_FALSE(subkey.IsHasSignCap());
 
-  ASSERT_TRUE(key.IsHasActualCertificationCapability());
-  ASSERT_TRUE(key.IsHasActualAuthenticationCapability());
-  ASSERT_TRUE(key.IsHasActualEncryptionCapability());
-  ASSERT_TRUE(key.IsHasActualSigningCapability());
+  ASSERT_TRUE(key.IsHasActualCertCap());
+  ASSERT_TRUE(key.IsHasActualAuthCap());
+  ASSERT_TRUE(key.IsHasActualEncrCap());
+  ASSERT_TRUE(key.IsHasActualSignCap());
 
   GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel).DeleteKey(fpr);
 }
@@ -450,10 +450,10 @@ TEST_F(GpgCoreTest, GenerateKeyED25519BRAINPOOLP256R1Test) {
   ASSERT_EQ(key.GetPrimaryKeyLength(), 255);
   ASSERT_EQ(key.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_TRUE(key.IsHasCertificationCapability());
-  ASSERT_TRUE(key.IsHasAuthenticationCapability());
-  ASSERT_TRUE(key.IsHasEncryptionCapability());
-  ASSERT_TRUE(key.IsHasSigningCapability());
+  ASSERT_TRUE(key.IsHasCertCap());
+  ASSERT_TRUE(key.IsHasAuthCap());
+  ASSERT_TRUE(key.IsHasEncrCap());
+  ASSERT_TRUE(key.IsHasSignCap());
 
   ASSERT_FALSE(key.GetSubKeys()->empty());
   ASSERT_EQ(key.GetSubKeys()->size(), 2);
@@ -465,15 +465,15 @@ TEST_F(GpgCoreTest, GenerateKeyED25519BRAINPOOLP256R1Test) {
   ASSERT_EQ(subkey.GetKeyLength(), 256);
   ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertificationCapability());
-  ASSERT_FALSE(subkey.IsHasAuthenticationCapability());
-  ASSERT_TRUE(subkey.IsHasEncryptionCapability());
-  ASSERT_FALSE(subkey.IsHasSigningCapability());
+  ASSERT_FALSE(subkey.IsHasCertCap());
+  ASSERT_FALSE(subkey.IsHasAuthCap());
+  ASSERT_TRUE(subkey.IsHasEncrCap());
+  ASSERT_FALSE(subkey.IsHasSignCap());
 
-  ASSERT_TRUE(key.IsHasActualCertificationCapability());
-  ASSERT_TRUE(key.IsHasActualAuthenticationCapability());
-  ASSERT_TRUE(key.IsHasActualEncryptionCapability());
-  ASSERT_TRUE(key.IsHasActualSigningCapability());
+  ASSERT_TRUE(key.IsHasActualCertCap());
+  ASSERT_TRUE(key.IsHasActualAuthCap());
+  ASSERT_TRUE(key.IsHasActualEncrCap());
+  ASSERT_TRUE(key.IsHasActualSignCap());
 
   GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel).DeleteKey(fpr);
 }
@@ -519,15 +519,15 @@ TEST_F(GpgCoreTest, GenerateKeyNISTP256Test) {
   ASSERT_EQ(key.GetPrimaryKeyLength(), 256);
   ASSERT_GT(key.GetExpireTime(), QDateTime::currentDateTime());
 
-  ASSERT_TRUE(key.IsHasCertificationCapability());
-  ASSERT_TRUE(key.IsHasAuthenticationCapability());
-  ASSERT_FALSE(key.IsHasEncryptionCapability());
-  ASSERT_TRUE(key.IsHasSigningCapability());
+  ASSERT_TRUE(key.IsHasCertCap());
+  ASSERT_TRUE(key.IsHasAuthCap());
+  ASSERT_FALSE(key.IsHasEncrCap());
+  ASSERT_TRUE(key.IsHasSignCap());
 
-  ASSERT_TRUE(key.IsHasActualCertificationCapability());
-  ASSERT_TRUE(key.IsHasActualAuthenticationCapability());
-  ASSERT_FALSE(key.IsHasActualEncryptionCapability());
-  ASSERT_TRUE(key.IsHasActualSigningCapability());
+  ASSERT_TRUE(key.IsHasActualCertCap());
+  ASSERT_TRUE(key.IsHasActualAuthCap());
+  ASSERT_FALSE(key.IsHasActualEncrCap());
+  ASSERT_TRUE(key.IsHasActualSignCap());
 
   GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
       .DeleteKey(result.GetFingerprint());
@@ -574,15 +574,15 @@ TEST_F(GpgCoreTest, GenerateKeyED448Test) {
   ASSERT_EQ(key.GetPrimaryKeyLength(), 448);
   ASSERT_GT(key.GetExpireTime(), QDateTime::currentDateTime());
 
-  ASSERT_TRUE(key.IsHasCertificationCapability());
-  ASSERT_TRUE(key.IsHasAuthenticationCapability());
-  ASSERT_FALSE(key.IsHasEncryptionCapability());
-  ASSERT_TRUE(key.IsHasSigningCapability());
+  ASSERT_TRUE(key.IsHasCertCap());
+  ASSERT_TRUE(key.IsHasAuthCap());
+  ASSERT_FALSE(key.IsHasEncrCap());
+  ASSERT_TRUE(key.IsHasSignCap());
 
-  ASSERT_TRUE(key.IsHasActualCertificationCapability());
-  ASSERT_TRUE(key.IsHasActualAuthenticationCapability());
-  ASSERT_FALSE(key.IsHasActualEncryptionCapability());
-  ASSERT_TRUE(key.IsHasActualSigningCapability());
+  ASSERT_TRUE(key.IsHasActualCertCap());
+  ASSERT_TRUE(key.IsHasActualAuthCap());
+  ASSERT_FALSE(key.IsHasActualEncrCap());
+  ASSERT_TRUE(key.IsHasActualSignCap());
 
   GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
       .DeleteKey(result.GetFingerprint());
@@ -629,15 +629,15 @@ TEST_F(GpgCoreTest, GenerateKeySECP256K1Test) {
   ASSERT_EQ(key.GetPrimaryKeyLength(), 256);
   ASSERT_GT(key.GetExpireTime(), QDateTime::currentDateTime());
 
-  ASSERT_TRUE(key.IsHasCertificationCapability());
-  ASSERT_TRUE(key.IsHasAuthenticationCapability());
-  ASSERT_FALSE(key.IsHasEncryptionCapability());
-  ASSERT_TRUE(key.IsHasSigningCapability());
+  ASSERT_TRUE(key.IsHasCertCap());
+  ASSERT_TRUE(key.IsHasAuthCap());
+  ASSERT_FALSE(key.IsHasEncrCap());
+  ASSERT_TRUE(key.IsHasSignCap());
 
-  ASSERT_TRUE(key.IsHasActualCertificationCapability());
-  ASSERT_TRUE(key.IsHasActualAuthenticationCapability());
-  ASSERT_FALSE(key.IsHasActualEncryptionCapability());
-  ASSERT_TRUE(key.IsHasActualSigningCapability());
+  ASSERT_TRUE(key.IsHasActualCertCap());
+  ASSERT_TRUE(key.IsHasActualAuthCap());
+  ASSERT_FALSE(key.IsHasActualEncrCap());
+  ASSERT_TRUE(key.IsHasActualSignCap());
 
   GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
       .DeleteKey(result.GetFingerprint());
diff --git a/src/test/core/GpgCoreTestSubkeygen.cpp b/src/test/core/GpgCoreTestSubkeygen.cpp
index af78a953..bbaa2be0 100644
--- a/src/test/core/GpgCoreTestSubkeygen.cpp
+++ b/src/test/core/GpgCoreTestSubkeygen.cpp
@@ -74,10 +74,10 @@ TEST_F(GpgCoreTest, GenerateSubkeyRSA2048Test) {
   ASSERT_EQ(subkey.GetKeyLength(), 2048);
   ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertificationCapability());
-  ASSERT_TRUE(subkey.IsHasAuthenticationCapability());
-  ASSERT_TRUE(subkey.IsHasEncryptionCapability());
-  ASSERT_TRUE(subkey.IsHasSigningCapability());
+  ASSERT_FALSE(subkey.IsHasCertCap());
+  ASSERT_TRUE(subkey.IsHasAuthCap());
+  ASSERT_TRUE(subkey.IsHasEncrCap());
+  ASSERT_TRUE(subkey.IsHasSignCap());
 }
 
 TEST_F(GpgCoreTest, GenerateSubkeyDSA2048Test) {
@@ -117,10 +117,10 @@ TEST_F(GpgCoreTest, GenerateSubkeyDSA2048Test) {
   ASSERT_EQ(subkey.GetKeyLength(), 2048);
   ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertificationCapability());
-  ASSERT_TRUE(subkey.IsHasAuthenticationCapability());
-  ASSERT_FALSE(subkey.IsHasEncryptionCapability());
-  ASSERT_TRUE(subkey.IsHasSigningCapability());
+  ASSERT_FALSE(subkey.IsHasCertCap());
+  ASSERT_TRUE(subkey.IsHasAuthCap());
+  ASSERT_FALSE(subkey.IsHasEncrCap());
+  ASSERT_TRUE(subkey.IsHasSignCap());
 }
 
 TEST_F(GpgCoreTest, GenerateSubkeyELG2048Test) {
@@ -160,10 +160,10 @@ TEST_F(GpgCoreTest, GenerateSubkeyELG2048Test) {
   ASSERT_EQ(subkey.GetKeyLength(), 2048);
   ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertificationCapability());
-  ASSERT_FALSE(subkey.IsHasAuthenticationCapability());
-  ASSERT_TRUE(subkey.IsHasEncryptionCapability());
-  ASSERT_FALSE(subkey.IsHasSigningCapability());
+  ASSERT_FALSE(subkey.IsHasCertCap());
+  ASSERT_FALSE(subkey.IsHasAuthCap());
+  ASSERT_TRUE(subkey.IsHasEncrCap());
+  ASSERT_FALSE(subkey.IsHasSignCap());
 }
 
 TEST_F(GpgCoreTest, GenerateSubkeyED25519Test) {
@@ -203,10 +203,10 @@ TEST_F(GpgCoreTest, GenerateSubkeyED25519Test) {
   ASSERT_EQ(subkey.GetKeyLength(), 255);
   ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertificationCapability());
-  ASSERT_TRUE(subkey.IsHasAuthenticationCapability());
-  ASSERT_FALSE(subkey.IsHasEncryptionCapability());
-  ASSERT_TRUE(subkey.IsHasSigningCapability());
+  ASSERT_FALSE(subkey.IsHasCertCap());
+  ASSERT_TRUE(subkey.IsHasAuthCap());
+  ASSERT_FALSE(subkey.IsHasEncrCap());
+  ASSERT_TRUE(subkey.IsHasSignCap());
 }
 
 TEST_F(GpgCoreTest, GenerateSubkeyCV25519Test) {
@@ -246,10 +246,10 @@ TEST_F(GpgCoreTest, GenerateSubkeyCV25519Test) {
   ASSERT_EQ(subkey.GetKeyLength(), 255);
   ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertificationCapability());
-  ASSERT_FALSE(subkey.IsHasAuthenticationCapability());
-  ASSERT_TRUE(subkey.IsHasEncryptionCapability());
-  ASSERT_FALSE(subkey.IsHasSigningCapability());
+  ASSERT_FALSE(subkey.IsHasCertCap());
+  ASSERT_FALSE(subkey.IsHasAuthCap());
+  ASSERT_TRUE(subkey.IsHasEncrCap());
+  ASSERT_FALSE(subkey.IsHasSignCap());
 }
 
 TEST_F(GpgCoreTest, GenerateSubkeyNISTP256Test) {
@@ -288,10 +288,10 @@ TEST_F(GpgCoreTest, GenerateSubkeyNISTP256Test) {
   ASSERT_EQ(subkey.GetKeyLength(), 256);
   ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertificationCapability());
-  ASSERT_FALSE(subkey.IsHasAuthenticationCapability());
-  ASSERT_TRUE(subkey.IsHasEncryptionCapability());
-  ASSERT_FALSE(subkey.IsHasSigningCapability());
+  ASSERT_FALSE(subkey.IsHasCertCap());
+  ASSERT_FALSE(subkey.IsHasAuthCap());
+  ASSERT_TRUE(subkey.IsHasEncrCap());
+  ASSERT_FALSE(subkey.IsHasSignCap());
 }
 
 TEST_F(GpgCoreTest, GenerateSubkeyBRAINPOOLP256R1Test) {
@@ -330,10 +330,10 @@ TEST_F(GpgCoreTest, GenerateSubkeyBRAINPOOLP256R1Test) {
   ASSERT_EQ(subkey.GetKeyLength(), 256);
   ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertificationCapability());
-  ASSERT_FALSE(subkey.IsHasAuthenticationCapability());
-  ASSERT_TRUE(subkey.IsHasEncryptionCapability());
-  ASSERT_FALSE(subkey.IsHasSigningCapability());
+  ASSERT_FALSE(subkey.IsHasCertCap());
+  ASSERT_FALSE(subkey.IsHasAuthCap());
+  ASSERT_TRUE(subkey.IsHasEncrCap());
+  ASSERT_FALSE(subkey.IsHasSignCap());
 }
 
 TEST_F(GpgCoreTest, GenerateSubkeyX448Test) {
@@ -372,10 +372,10 @@ TEST_F(GpgCoreTest, GenerateSubkeyX448Test) {
   ASSERT_EQ(subkey.GetKeyLength(), 448);
   ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertificationCapability());
-  ASSERT_FALSE(subkey.IsHasAuthenticationCapability());
-  ASSERT_TRUE(subkey.IsHasEncryptionCapability());
-  ASSERT_FALSE(subkey.IsHasSigningCapability());
+  ASSERT_FALSE(subkey.IsHasCertCap());
+  ASSERT_FALSE(subkey.IsHasAuthCap());
+  ASSERT_TRUE(subkey.IsHasEncrCap());
+  ASSERT_FALSE(subkey.IsHasSignCap());
 }
 
 TEST_F(GpgCoreTest, GenerateSubkeySECP256K1Test) {
@@ -414,10 +414,10 @@ TEST_F(GpgCoreTest, GenerateSubkeySECP256K1Test) {
   ASSERT_EQ(subkey.GetKeyLength(), 256);
   ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertificationCapability());
-  ASSERT_FALSE(subkey.IsHasAuthenticationCapability());
-  ASSERT_TRUE(subkey.IsHasEncryptionCapability());
-  ASSERT_FALSE(subkey.IsHasSigningCapability());
+  ASSERT_FALSE(subkey.IsHasCertCap());
+  ASSERT_FALSE(subkey.IsHasAuthCap());
+  ASSERT_TRUE(subkey.IsHasEncrCap());
+  ASSERT_FALSE(subkey.IsHasSignCap());
 }
 
 }  // namespace GpgFrontend::Test
\ No newline at end of file
diff --git a/src/ui/dialog/SignersPicker.cpp b/src/ui/dialog/SignersPicker.cpp
index 21996f5b..61a31606 100644
--- a/src/ui/dialog/SignersPicker.cpp
+++ b/src/ui/dialog/SignersPicker.cpp
@@ -49,11 +49,9 @@ SignersPicker::SignersPicker(int channel, QWidget* parent)
       GpgKeyTableColumn::kNAME | GpgKeyTableColumn::kEMAIL_ADDRESS |
           GpgKeyTableColumn::kKEY_ID | GpgKeyTableColumn::kUSAGE,
       this);
-  key_list_->AddListGroupTab(tr("Signers"), "signers",
-                             GpgKeyTableDisplayMode::kPRIVATE_KEY,
-                             [](const GpgKey& key) -> bool {
-                               return key.IsHasActualSigningCapability();
-                             });
+  key_list_->AddListGroupTab(
+      tr("Signers"), "signers", GpgKeyTableDisplayMode::kPRIVATE_KEY,
+      [](const GpgKey& key) -> bool { return key.IsHasActualSignCap(); });
   key_list_->SlotRefresh();
 
   auto* vbox2 = new QVBoxLayout();
diff --git a/src/ui/dialog/key_generate/KeyGenerateDialog.cpp b/src/ui/dialog/key_generate/KeyGenerateDialog.cpp
index 0251df8b..5a84700c 100644
--- a/src/ui/dialog/key_generate/KeyGenerateDialog.cpp
+++ b/src/ui/dialog/key_generate/KeyGenerateDialog.cpp
@@ -221,20 +221,20 @@ void KeyGenerateDialog::refresh_widgets_state() {
 
   ui_->pEncrCheckBox->blockSignals(true);
   ui_->pEncrCheckBox->setCheckState(
-      gen_key_info_->IsAllowEncryption() ? Qt::Checked : Qt::Unchecked);
-  ui_->pEncrCheckBox->setEnabled(gen_key_info_->IsAllowChangeEncryption());
+      gen_key_info_->IsAllowEncr() ? Qt::Checked : Qt::Unchecked);
+  ui_->pEncrCheckBox->setEnabled(gen_key_info_->IsAllowModifyEncr());
   ui_->pEncrCheckBox->blockSignals(false);
 
   ui_->pSignCheckBox->blockSignals(true);
   ui_->pSignCheckBox->setCheckState(
-      gen_key_info_->IsAllowSigning() ? Qt::Checked : Qt::Unchecked);
-  ui_->pSignCheckBox->setEnabled(gen_key_info_->IsAllowChangeSigning());
+      gen_key_info_->IsAllowSign() ? Qt::Checked : Qt::Unchecked);
+  ui_->pSignCheckBox->setEnabled(gen_key_info_->IsAllowModifySign());
   ui_->pSignCheckBox->blockSignals(false);
 
   ui_->pAuthCheckBox->blockSignals(true);
   ui_->pAuthCheckBox->setCheckState(
-      gen_key_info_->IsAllowAuthentication() ? Qt::Checked : Qt::Unchecked);
-  ui_->pAuthCheckBox->setEnabled(gen_key_info_->IsAllowChangeAuthentication());
+      gen_key_info_->IsAllowAuth() ? Qt::Checked : Qt::Unchecked);
+  ui_->pAuthCheckBox->setEnabled(gen_key_info_->IsAllowModifyAuth());
   ui_->pAuthCheckBox->blockSignals(false);
 
   ui_->noPassphraseCheckBox->setEnabled(gen_key_info_->IsAllowNoPassPhrase());
@@ -303,21 +303,20 @@ void KeyGenerateDialog::refresh_widgets_state() {
 
   ui_->sEncrCheckBox->blockSignals(true);
   ui_->sEncrCheckBox->setCheckState(
-      gen_subkey_info_->IsAllowEncryption() ? Qt::Checked : Qt::Unchecked);
-  ui_->sEncrCheckBox->setEnabled(gen_subkey_info_->IsAllowChangeEncryption());
+      gen_subkey_info_->IsAllowEncr() ? Qt::Checked : Qt::Unchecked);
+  ui_->sEncrCheckBox->setEnabled(gen_subkey_info_->IsAllowModifyEncr());
   ui_->sEncrCheckBox->blockSignals(false);
 
   ui_->sSignCheckBox->blockSignals(true);
   ui_->sSignCheckBox->setCheckState(
-      gen_subkey_info_->IsAllowSigning() ? Qt::Checked : Qt::Unchecked);
-  ui_->sSignCheckBox->setEnabled(gen_subkey_info_->IsAllowChangeSigning());
+      gen_subkey_info_->IsAllowSign() ? Qt::Checked : Qt::Unchecked);
+  ui_->sSignCheckBox->setEnabled(gen_subkey_info_->IsAllowModifySign());
   ui_->sSignCheckBox->blockSignals(false);
 
   ui_->sAuthCheckBox->blockSignals(true);
   ui_->sAuthCheckBox->setCheckState(
-      gen_subkey_info_->IsAllowAuthentication() ? Qt::Checked : Qt::Unchecked);
-  ui_->sAuthCheckBox->setEnabled(
-      gen_subkey_info_->IsAllowChangeAuthentication());
+      gen_subkey_info_->IsAllowAuth() ? Qt::Checked : Qt::Unchecked);
+  ui_->sAuthCheckBox->setEnabled(gen_subkey_info_->IsAllowModifyAuth());
   ui_->sAuthCheckBox->blockSignals(false);
 
   ui_->sExpireDateTimeEdit->blockSignals(true);
@@ -354,30 +353,27 @@ void KeyGenerateDialog::set_signal_slot_config() {
             refresh_widgets_state();
           });
 
-  connect(ui_->pEncrCheckBox, &QCheckBox::stateChanged, this,
-          [this](int state) {
-            gen_key_info_->SetAllowEncryption(state == Qt::Checked);
-          });
-  connect(ui_->pSignCheckBox, &QCheckBox::stateChanged, this,
-          [this](int state) {
-            gen_key_info_->SetAllowSigning(state == Qt::Checked);
-          });
-  connect(ui_->pAuthCheckBox, &QCheckBox::stateChanged, this,
-          [this](int state) {
-            gen_key_info_->SetAllowAuthentication(state == Qt::Checked);
-          });
+  connect(
+      ui_->pEncrCheckBox, &QCheckBox::stateChanged, this,
+      [this](int state) { gen_key_info_->SetAllowEncr(state == Qt::Checked); });
+  connect(
+      ui_->pSignCheckBox, &QCheckBox::stateChanged, this,
+      [this](int state) { gen_key_info_->SetAllowSign(state == Qt::Checked); });
+  connect(
+      ui_->pAuthCheckBox, &QCheckBox::stateChanged, this,
+      [this](int state) { gen_key_info_->SetAllowAuth(state == Qt::Checked); });
 
   connect(ui_->sEncrCheckBox, &QCheckBox::stateChanged, this,
           [this](int state) {
-            gen_subkey_info_->SetAllowEncryption(state == Qt::Checked);
+            gen_subkey_info_->SetAllowEncr(state == Qt::Checked);
           });
   connect(ui_->sSignCheckBox, &QCheckBox::stateChanged, this,
           [this](int state) {
-            gen_subkey_info_->SetAllowSigning(state == Qt::Checked);
+            gen_subkey_info_->SetAllowSign(state == Qt::Checked);
           });
   connect(ui_->sAuthCheckBox, &QCheckBox::stateChanged, this,
           [this](int state) {
-            gen_subkey_info_->SetAllowAuthentication(state == Qt::Checked);
+            gen_subkey_info_->SetAllowAuth(state == Qt::Checked);
           });
 
   connect(ui_->noPassphraseCheckBox, &QCheckBox::stateChanged, this,
diff --git a/src/ui/dialog/key_generate/SubkeyGenerateDialog.cpp b/src/ui/dialog/key_generate/SubkeyGenerateDialog.cpp
index 0c4d30c4..c284290f 100644
--- a/src/ui/dialog/key_generate/SubkeyGenerateDialog.cpp
+++ b/src/ui/dialog/key_generate/SubkeyGenerateDialog.cpp
@@ -98,13 +98,13 @@ void SubkeyGenerateDialog::set_signal_slot_config() {
           });
 
   connect(ui_->encrCheckBox, &QCheckBox::stateChanged, this, [this](int state) {
-    gen_subkey_info_->SetAllowEncryption(state == Qt::Checked);
+    gen_subkey_info_->SetAllowEncr(state == Qt::Checked);
   });
   connect(ui_->signCheckBox, &QCheckBox::stateChanged, this, [this](int state) {
-    gen_subkey_info_->SetAllowSigning(state == Qt::Checked);
+    gen_subkey_info_->SetAllowSign(state == Qt::Checked);
   });
   connect(ui_->authCheckBox, &QCheckBox::stateChanged, this, [this](int state) {
-    gen_subkey_info_->SetAllowAuthentication(state == Qt::Checked);
+    gen_subkey_info_->SetAllowAuth(state == Qt::Checked);
   });
 
   connect(ui_->algoComboBox, &QComboBox::currentTextChanged, this,
@@ -145,19 +145,18 @@ void SubkeyGenerateDialog::refresh_widgets_state() {
   ui_->keyLengthComboBox->blockSignals(false);
 
   ui_->encrCheckBox->blockSignals(true);
-  ui_->encrCheckBox->setChecked(gen_subkey_info_->IsAllowEncryption());
-  ui_->encrCheckBox->setEnabled(gen_subkey_info_->IsAllowChangeEncryption());
+  ui_->encrCheckBox->setChecked(gen_subkey_info_->IsAllowEncr());
+  ui_->encrCheckBox->setEnabled(gen_subkey_info_->IsAllowModifyEncr());
   ui_->encrCheckBox->blockSignals(false);
 
   ui_->signCheckBox->blockSignals(true);
-  ui_->signCheckBox->setChecked(gen_subkey_info_->IsAllowSigning());
-  ui_->signCheckBox->setEnabled(gen_subkey_info_->IsAllowChangeSigning());
+  ui_->signCheckBox->setChecked(gen_subkey_info_->IsAllowSign());
+  ui_->signCheckBox->setEnabled(gen_subkey_info_->IsAllowModifySign());
   ui_->signCheckBox->blockSignals(false);
 
   ui_->authCheckBox->blockSignals(true);
-  ui_->authCheckBox->setChecked(gen_subkey_info_->IsAllowAuthentication());
-  ui_->authCheckBox->setEnabled(
-      gen_subkey_info_->IsAllowChangeAuthentication());
+  ui_->authCheckBox->setChecked(gen_subkey_info_->IsAllowAuth());
+  ui_->authCheckBox->setEnabled(gen_subkey_info_->IsAllowModifyAuth());
   ui_->authCheckBox->blockSignals(false);
 
   ui_->nonPassphraseCheckBox->setEnabled(
diff --git a/src/ui/dialog/keypair_details/KeyPairDetailTab.cpp b/src/ui/dialog/keypair_details/KeyPairDetailTab.cpp
index 8450083f..88c7fbf5 100644
--- a/src/ui/dialog/keypair_details/KeyPairDetailTab.cpp
+++ b/src/ui/dialog/keypair_details/KeyPairDetailTab.cpp
@@ -215,28 +215,28 @@ void KeyPairDetailTab::slot_refresh_key_info() {
   QString buffer;
   QTextStream usage_steam(&buffer);
 
-  if (key_.IsHasCertificationCapability()) {
+  if (key_.IsHasCertCap()) {
     usage_steam << tr("Certificate") << " ";
   }
-  if (key_.IsHasEncryptionCapability()) usage_steam << tr("Encrypt") << " ";
-  if (key_.IsHasSigningCapability()) usage_steam << tr("Sign") << " ";
-  if (key_.IsHasAuthenticationCapability()) usage_steam << tr("Auth") << " ";
+  if (key_.IsHasEncrCap()) usage_steam << tr("Encrypt") << " ";
+  if (key_.IsHasSignCap()) usage_steam << tr("Sign") << " ";
+  if (key_.IsHasAuthCap()) usage_steam << tr("Auth") << " ";
 
   usage_var_label_->setText(usage_steam.readAll());
 
   QString buffer_2;
   QTextStream actual_usage_steam(&buffer_2);
 
-  if (key_.IsHasActualCertificationCapability()) {
+  if (key_.IsHasActualCertCap()) {
     actual_usage_steam << tr("Certificate") << " ";
   }
-  if (key_.IsHasActualEncryptionCapability()) {
+  if (key_.IsHasActualEncrCap()) {
     actual_usage_steam << tr("Encrypt") << " ";
   }
-  if (key_.IsHasActualSigningCapability()) {
+  if (key_.IsHasActualSignCap()) {
     actual_usage_steam << tr("Sign") << " ";
   }
-  if (key_.IsHasActualAuthenticationCapability()) {
+  if (key_.IsHasActualAuthCap()) {
     actual_usage_steam << tr("Auth") << " ";
   }
 
diff --git a/src/ui/dialog/keypair_details/KeyPairSubkeyTab.cpp b/src/ui/dialog/keypair_details/KeyPairSubkeyTab.cpp
index b37f610f..548b3473 100644
--- a/src/ui/dialog/keypair_details/KeyPairSubkeyTab.cpp
+++ b/src/ui/dialog/keypair_details/KeyPairSubkeyTab.cpp
@@ -205,9 +205,8 @@ void KeyPairSubkeyTab::slot_refresh_subkey_list() {
     tmp0->setTextAlignment(Qt::AlignCenter);
     subkey_list_->setItem(row, 0, tmp0);
 
-    auto* tmp1 = new QTableWidgetItem(subkey.IsHasCertificationCapability()
-                                          ? tr("Primary Key")
-                                          : tr("Subkey"));
+    auto* tmp1 = new QTableWidgetItem(subkey.IsHasCertCap() ? tr("Primary Key")
+                                                            : tr("Subkey"));
     tmp1->setTextAlignment(Qt::AlignCenter);
     subkey_list_->setItem(row, 1, tmp1);
 
@@ -307,12 +306,12 @@ void KeyPairSubkeyTab::slot_refresh_subkey_detail() {
   QString buffer;
   QTextStream usage_steam(&buffer);
 
-  if (subkey.IsHasCertificationCapability()) {
+  if (subkey.IsHasCertCap()) {
     usage_steam << tr("Certificate") << " ";
   }
-  if (subkey.IsHasEncryptionCapability()) usage_steam << tr("Encrypt") << " ";
-  if (subkey.IsHasSigningCapability()) usage_steam << tr("Sign") << " ";
-  if (subkey.IsHasAuthenticationCapability()) usage_steam << tr("Auth") << " ";
+  if (subkey.IsHasEncrCap()) usage_steam << tr("Encrypt") << " ";
+  if (subkey.IsHasSignCap()) usage_steam << tr("Sign") << " ";
+  if (subkey.IsHasAuthCap()) usage_steam << tr("Auth") << " ";
 
   usage_var_label_->setText(usage_steam.readAll());
 
@@ -348,15 +347,13 @@ void KeyPairSubkeyTab::slot_refresh_subkey_detail() {
   fingerprint_var_label_->setText(BeautifyFingerprint(subkey.GetFingerprint()));
   fingerprint_var_label_->setWordWrap(true);  // for x448 and ed448
 
-  export_subkey_button_->setText(subkey.IsHasCertificationCapability()
-                                     ? tr("Export Primary Key")
-                                     : tr("Export Subkey"));
-  export_subkey_button_->setDisabled(!key_.IsPrivateKey() ||
-                                     subkey.IsHasCertificationCapability() ||
-                                     !subkey.IsSecretKey());
+  export_subkey_button_->setText(
+      subkey.IsHasCertCap() ? tr("Export Primary Key") : tr("Export Subkey"));
+  export_subkey_button_->setDisabled(
+      !key_.IsPrivateKey() || subkey.IsHasCertCap() || !subkey.IsSecretKey());
 
-  key_type_var_label_->setText(
-      subkey.IsHasCertificationCapability() ? tr("Primary Key") : tr("Subkey"));
+  key_type_var_label_->setText(subkey.IsHasCertCap() ? tr("Primary Key")
+                                                     : tr("Subkey"));
 
   revoke_var_label_->setText(subkey.IsRevoked() ? tr("Yes") : tr("No"));
   if (!subkey.IsRevoked()) {
@@ -406,7 +403,7 @@ void KeyPairSubkeyTab::contextMenuEvent(QContextMenuEvent* event) {
   if (key_.IsHasMasterKey() && !subkey_list_->selectedItems().isEmpty()) {
     const auto& subkey = get_selected_subkey();
 
-    if (subkey.IsHasCertificationCapability()) return;
+    if (subkey.IsHasCertCap()) return;
 
     export_subkey_act_->setDisabled(!subkey.IsSecretKey());
     edit_subkey_act_->setDisabled(!subkey.IsSecretKey());
diff --git a/src/ui/dialog/keypair_details/KeyUIDSignDialog.cpp b/src/ui/dialog/keypair_details/KeyUIDSignDialog.cpp
index 35f4e57f..4b9d4726 100644
--- a/src/ui/dialog/keypair_details/KeyUIDSignDialog.cpp
+++ b/src/ui/dialog/keypair_details/KeyUIDSignDialog.cpp
@@ -52,7 +52,7 @@ KeyUIDSignDialog::KeyUIDSignDialog(int channel, const GpgKey& key,
   m_key_list_->AddListGroupTab(
       tr("Signers"), "signers", GpgKeyTableDisplayMode::kPRIVATE_KEY,
       [key_id](const GpgKey& key) -> bool {
-        return !(key.IsDisabled() || !key.IsHasCertificationCapability() ||
+        return !(key.IsDisabled() || !key.IsHasCertCap() ||
                  !key.IsHasMasterKey() || key.IsExpired() || key.IsRevoked() ||
                  key_id == key.GetId());
       });
diff --git a/src/ui/main_window/MainWindowGpgOperaFunction.cpp b/src/ui/main_window/MainWindowGpgOperaFunction.cpp
index 8395c8f8..984acb2f 100644
--- a/src/ui/main_window/MainWindowGpgOperaFunction.cpp
+++ b/src/ui/main_window/MainWindowGpgOperaFunction.cpp
@@ -56,8 +56,7 @@ auto MainWindow::encrypt_operation_key_validate(
     contexts->keys = {};
   } else {
     contexts->keys = check_keys_helper(
-        key_ids,
-        [](const GpgKey& key) { return key.IsHasActualEncryptionCapability(); },
+        key_ids, [](const GpgKey& key) { return key.IsHasActualEncrCap(); },
         tr("The selected keypair cannot be used for encryption."));
     if (contexts->keys.empty()) return false;
   }
@@ -205,8 +204,7 @@ void MainWindow::SlotSign() {
 
   auto key_ids = m_key_list_->GetChecked();
   contexts->keys = check_keys_helper(
-      key_ids,
-      [](const GpgKey& key) { return key.IsHasActualSigningCapability(); },
+      key_ids, [](const GpgKey& key) { return key.IsHasActualSignCap(); },
       tr("The selected key contains a key that does not actually have a "
          "sign usage."));
   if (contexts->keys.empty()) return;
@@ -259,8 +257,7 @@ void MainWindow::SlotEncryptSign() {
 
   auto key_ids = m_key_list_->GetChecked();
   contexts->keys = check_keys_helper(
-      key_ids,
-      [](const GpgKey& key) { return key.IsHasActualEncryptionCapability(); },
+      key_ids, [](const GpgKey& key) { return key.IsHasActualEncrCap(); },
       tr("The selected keypair cannot be used for encryption."));
   if (contexts->keys.empty()) return;
 
@@ -375,8 +372,7 @@ void MainWindow::SlotFileSign(const QStringList& paths) {
 
   auto key_ids = m_key_list_->GetChecked();
   contexts->keys = check_keys_helper(
-      key_ids,
-      [](const GpgKey& key) { return key.IsHasActualSigningCapability(); },
+      key_ids, [](const GpgKey& key) { return key.IsHasActualSignCap(); },
       tr("The selected key contains a key that does not actually have a "
          "sign usage."));
   if (contexts->keys.empty()) return;
@@ -459,8 +455,7 @@ void MainWindow::SlotFileEncryptSign(const QStringList& paths) {
 
   auto key_ids = m_key_list_->GetChecked();
   contexts->keys = check_keys_helper(
-      key_ids,
-      [](const GpgKey& key) { return key.IsHasActualEncryptionCapability(); },
+      key_ids, [](const GpgKey& key) { return key.IsHasActualEncrCap(); },
       tr("The selected keypair cannot be used for encryption."));
   if (contexts->keys.empty()) return;