KeyList.h

 
#pragma once
 
#include "core/model/GpgKey.h"
 
class Ui_KeyList;
 
namespace GpgFrontend::UI {
 
struct KeyListRow {
  using KeyType = unsigned int;
 
  static const KeyType SECRET_OR_PUBLIC_KEY = 0;  
  static const KeyType ONLY_SECRET_KEY = 1;       
};
 
struct KeyListColumn {
  using InfoType = unsigned int;
 
  static constexpr InfoType ALL = ~0;               
  static constexpr InfoType TYPE = 1 << 0;          
  static constexpr InfoType NAME = 1 << 1;          
  static constexpr InfoType EmailAddress = 1 << 2;  
  static constexpr InfoType Usage = 1 << 3;         
  static constexpr InfoType Validity = 1 << 4;      
  static constexpr InfoType FingerPrint = 1 << 5;   
  static constexpr InfoType KeyID = 1 << 6;         
};
 
struct KeyMenuAbility {
  using AbilityType = unsigned int;
 
  static constexpr AbilityType ALL = ~0;                  
  static constexpr AbilityType NONE = 0;                  
  static constexpr AbilityType REFRESH = 1 << 0;          
  static constexpr AbilityType SYNC_PUBLIC_KEY = 1 << 1;  
  static constexpr AbilityType UNCHECK_ALL = 1 << 3;      
  static constexpr AbilityType CHECK_ALL = 1 << 5;        
  static constexpr AbilityType SEARCH_BAR = 1 << 6;       
};
 
struct KeyTable {
  using KeyTableFilter = std::function<bool(const GpgKey&, const KeyTable&)>;
 
  QTableWidget* key_list_;               
  KeyListRow::KeyType select_type_;      
  KeyListColumn::InfoType info_type_;    
  std::vector<GpgKey> buffered_keys_;    
  KeyTableFilter filter_;                
  KeyIdArgsListPtr checked_key_ids_;     
  KeyMenuAbility::AbilityType ability_;  
  QString keyword_;                      
 
  KeyTable(
      QTableWidget* _key_list, KeyListRow::KeyType _select_type,
      KeyListColumn::InfoType _info_type,
      KeyTableFilter _filter = [](const GpgKey&, const KeyTable&) -> bool {
        return true;
      })
      : key_list_(_key_list),
        select_type_(_select_type),
        info_type_(_info_type),
        filter_(std::move(_filter)) {}
 
  void Refresh(KeyLinkListPtr m_keys = nullptr);
 
  KeyIdArgsListPtr& GetChecked();
 
  void UncheckALL() const;
 
  void CheckALL() const;
 
  void SetChecked(KeyIdArgsListPtr key_ids);
 
  void SetMenuAbility(KeyMenuAbility::AbilityType ability);
 
  void SetFilterKeyword(QString keyword);
};
 
class KeyList : public QWidget {
  Q_OBJECT
 
 public:
  explicit KeyList(KeyMenuAbility::AbilityType menu_ability,
                   QWidget* parent = nullptr);
 
  void AddListGroupTab(
      const QString& name, const QString& id,
      KeyListRow::KeyType selectType = KeyListRow::SECRET_OR_PUBLIC_KEY,
      KeyListColumn::InfoType infoType = KeyListColumn::ALL,
      KeyTable::KeyTableFilter filter =
          [](const GpgKey&, const KeyTable&) -> bool { return true; });
 
  void SetDoubleClickedAction(
      std::function<void(const GpgKey&, QWidget*)> action);
 
  void SetColumnWidth(int row, int size);
 
  void AddMenuAction(QAction* act);
 
  void AddSeparator();
 
  auto GetChecked() -> KeyIdArgsListPtr;
 
  static auto GetChecked(const KeyTable& key_table) -> KeyIdArgsListPtr;
 
  auto GetCheckedPrivateKey() -> KeyIdArgsListPtr;
 
  auto GetCheckedPublicKey() -> KeyIdArgsListPtr;
 
  auto GetAllPrivateKeys() -> KeyIdArgsListPtr;
 
  void SetChecked(KeyIdArgsListPtr key_ids);
 
  static void SetChecked(const KeyIdArgsListPtr& keyIds,
                         const KeyTable& key_table);
 
  auto GetSelected() -> KeyIdArgsListPtr;
 
  auto GetSelectedKey() -> QString;
 
  [[maybe_unused]] auto ContainsPrivateKeys() -> bool;
 
 signals:
  void SignalRefreshStatusBar(const QString& message, int timeout);
 
  void SignalRefreshDatabase();
 
 public slots:
 
  void SlotRefresh();
 
  void SlotRefreshUI();
 
 private:
  void init();
 
  void import_keys(const QByteArray& inBuffer);
 
  void uncheck_all();
 
  void check_all();
 
  void filter_by_keyword();
 
  std::mutex buffered_key_list_mutex_;  
 
  std::shared_ptr<Ui_KeyList> ui_;                                   
  QTableWidget* m_key_list_{};                                       
  std::vector<KeyTable> m_key_tables_;                               
  QMenu* popup_menu_{};                                              
  GpgFrontend::KeyLinkListPtr buffered_keys_list_;                   
  std::function<void(const GpgKey&, QWidget*)> m_action_ = nullptr;  
  KeyMenuAbility::AbilityType menu_ability_ = KeyMenuAbility::ALL;   
 
 private slots:
 
  void slot_double_clicked(const QModelIndex& index);
 
  void slot_refresh_ui();
 
  void slot_sync_with_key_server();
 
 protected:
  void contextMenuEvent(QContextMenuEvent* event) override;
 
  void dragEnterEvent(QDragEnterEvent* event) override;
 
  void dropEvent(QDropEvent* event) override;
};
 
}  // namespace GpgFrontend::UI