UserInterfaceUtils.h

 
#ifndef GPGFRONTEND_USER_INTERFACE_UTILS_H
#define GPGFRONTEND_USER_INTERFACE_UTILS_H
 
#include "core/GpgModel.h"
#include "core/function/result_analyse/GpgVerifyResultAnalyse.h"
#include "core/model/GpgKey.h"
#include "ui/GpgFrontendUI.h"
 
namespace GpgFrontend {
class GpgResultAnalyse;
}
 
namespace GpgFrontend::UI {
 
class InfoBoardWidget;
class TextEdit;
 
void show_verify_details(QWidget* parent, InfoBoardWidget* info_board,
                         GpgError error, const GpgVerifyResult& verify_result);
 
void import_unknown_key_from_keyserver(
    QWidget* parent, const GpgVerifyResultAnalyse& verify_res);
 
void refresh_info_board(InfoBoardWidget* info_board, int status,
                        const std::string& report_text);
 
void process_result_analyse(TextEdit* edit, InfoBoardWidget* info_board,
                            const GpgResultAnalyse& result_analyse);
 
void process_result_analyse(TextEdit* edit, InfoBoardWidget* info_board,
                            const GpgResultAnalyse& result_analyse_a,
                            const GpgResultAnalyse& result_analyse_b);
 
void process_operation(
    QWidget* parent, const std::string& waiting_title,
    GpgFrontend::Thread::Task::TaskRunnable func,
    GpgFrontend::Thread::Task::TaskCallback callback = nullptr,
    Thread::Task::DataObjectPtr data_object = nullptr);
 
void import_key_from_keyserver(QWidget* parent, const std::string& key_id,
                               const std::string& key_server);
 
class CommonUtils : public QWidget {
  Q_OBJECT
 public:
  using ImportCallbackFunctiopn = std::function<void(
      const std::string&, const std::string&, size_t, size_t)>;
 
  CommonUtils();
 
  static CommonUtils* GetInstance();
 
  bool isApplicationNeedRestart();
 
  bool KeyExistsinFavouriteList(const GpgKey& key);
 
  void AddKey2Favourtie(const GpgKey& key);
 
  void RemoveKeyFromFavourite(const GpgKey& key);
 
 signals:
  void SignalKeyStatusUpdated();
 
  void SignalGnupgNotInstall();
 
  void SignalKeyDatabaseRefreshDone();
 
  void SignalNeedUserInputPassphrase();
 
  void SignalUserInputPassphraseDone(QString passphrase);
 
  void SignalRestartApplication(int);
 
 public slots:
  void SlotImportKeys(QWidget* parent, const std::string& in_buffer);
 
  void SlotImportKeyFromFile(QWidget* parent);
 
  void SlotImportKeyFromKeyServer(QWidget* parent);
 
  void SlotImportKeyFromClipboard(QWidget* parent);
 
  static void SlotImportKeyFromKeyServer(
      const GpgFrontend::KeyIdArgsList& key_ids,
      const GpgFrontend::UI::CommonUtils::ImportCallbackFunctiopn& callback);
 
  void SlotExecuteGpgCommand(
      const QStringList& arguments,
      const std::function<void(QProcess*)>& interact_func);
 
  void SlotExecuteCommand(const std::string& cmd, const QStringList& arguments,
                          const std::function<void(QProcess*)>& interact_func);
 
  void SlotRestartApplication(int);
 
 private slots:
 
  void slot_update_key_status();
 
  void slot_popup_passphrase_input_dialog();
 
 private:
  static std::unique_ptr<CommonUtils> instance_;  
  bool application_need_to_restart_at_once_ = false;
};
 
}  // namespace GpgFrontend::UI
 
#endif  // GPGFRONTEND_USER_INTERFACE_UTILS_H