UserInterfaceUtils.h

 
#pragma once
 
#include "core/function/result_analyse/GpgVerifyResultAnalyse.h"
#include "core/model/GpgKey.h"
#include "core/thread/Task.h"
#include "core/typedef/GpgTypedef.h"
 
namespace GpgFrontend {
class GpgResultAnalyse;
class GpgImportInformation;
}  // namespace GpgFrontend
 
namespace GpgFrontend::UI {
 
class InfoBoardWidget;
class TextEdit;
 
using OperaWaitingHd = std::function<void()>;
using OperaWaitingCb = const std::function<void(OperaWaitingHd)>;
 
void show_verify_details(QWidget* parent, InfoBoardWidget* info_board,
                         GpgError error, const GpgVerifyResult& verify_result);
 
void ImportUnknownKeyFromKeyserver(
    QWidget* parent, const GpgVerifyResultAnalyse& verify_res);
 
void refresh_info_board(InfoBoardWidget* info_board, int status,
                        const QString& 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 QString& waiting_title,
                       Thread::Task::TaskRunnable func,
                       Thread::Task::TaskCallback callback = nullptr,
                       DataObjectPtr data_object = nullptr);
 
class CommonUtils : public QWidget {
  Q_OBJECT
 public:
  using ImportCallbackFunctiopn =
      std::function<void(const QString&, const QString&, size_t, size_t)>;
 
  CommonUtils();
 
  static CommonUtils* GetInstance();
 
  static void WaitForOpera(QWidget* parent, const QString&,
                           const OperaWaitingCb&);
 
  static void RaiseMessageBox(QWidget* parent, GpgError err);
 
  static void RaiseFailureMessageBox(QWidget* parent, GpgError err);
 
  bool isApplicationNeedRestart();
 
  bool KeyExistsinFavouriteList(const GpgKey& key);
 
  void AddKey2Favourtie(const GpgKey& key);
 
  void RemoveKeyFromFavourite(const GpgKey& key);
 
  void ImportKeyFromKeyServer(const KeyIdArgsList&);
 
 signals:
  void SignalKeyStatusUpdated();
 
  void SignalBadGnupgEnv(QString);
 
  void SignalKeyDatabaseRefreshDone();
 
  void SignalRestartApplication(int);
 
 public slots:
  void SlotImportKeys(QWidget* parent, const QString& 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 QString& cmd, const QStringList& arguments,
                          const std::function<void(QProcess*)>& interact_func);
 
  void SlotRestartApplication(int);
 
 private slots:
 
  void slot_update_key_status();
 
  void slot_update_key_from_server_finished(
      bool, QString, QByteArray, std::shared_ptr<GpgImportInformation>);
 
 private:
  static std::unique_ptr<CommonUtils> instance_;  
  bool application_need_to_restart_at_once_ = false;
};
 
}  // namespace GpgFrontend::UI