fs_ofdsignature.h

#ifndef FS_OFD_SIGNATUE_H_
#define FS_OFD_SIGNATUE_H_

#include "common/fs_common.h"
#include "common/fs_image.h"

namespace foxit {
namespace ofd {
namespace ofdseal {
class Oes;

class OperateSignatureInfo FS_FINAL : public Object {
 public:
  typedef enum _SignatureOperationType {
    e_RemoveInfoOnly  =  0,
    e_ConvertToBlackImage  =  1,
    e_AtomizeImage  =  2,
    e_MosaicImage  =  3,
    e_RemoveAll  =  4
  } SignatureOperationType;
  

  explicit OperateSignatureInfo(SignatureOperationType operation_type = e_RemoveInfoOnly, int atomize_horz_blur = 5, int atomize_vert_blur = 5, int mosaic_vector_length = 5) :
    operation_type(operation_type),
    atomize_horz_blur(atomize_horz_blur),
    atomize_vert_blur(atomize_vert_blur),
    mosaic_vector_length(mosaic_vector_length) {
  }

  OperateSignatureInfo(const OperateSignatureInfo& other) {
    this->operation_type = other.operation_type;
    this->atomize_horz_blur = other.atomize_horz_blur;
    this->atomize_vert_blur = other.atomize_vert_blur;
    this->mosaic_vector_length = other.mosaic_vector_length;
  }

  OperateSignatureInfo& operator=(const OperateSignatureInfo& other) {
    this->operation_type = other.operation_type;
    this->atomize_horz_blur = other.atomize_horz_blur;
    this->atomize_vert_blur = other.atomize_vert_blur;
    this->mosaic_vector_length = other.mosaic_vector_length;
    return *this;
  }

  void Set(SignatureOperationType operation_type, int atomize_horz_blur, int atomize_vert_blur, int mosaic_vector_length) {
    this->operation_type = operation_type;
    this->atomize_horz_blur = atomize_horz_blur;
    this->atomize_vert_blur = atomize_vert_blur;
    this->mosaic_vector_length = mosaic_vector_length;
  }

  SignatureOperationType operation_type;

  int atomize_horz_blur;

  int atomize_vert_blur;

  int mosaic_vector_length;
};

class VerifyExtendInfo FS_FINAL : public Object
{
 public:
  explicit VerifyExtendInfo(const String& application_name = "", const String& user_login = "", const String& file_name = "") :
    application_name(application_name),
    user_login(user_login),
    file_name(file_name) {
  }

  VerifyExtendInfo(const VerifyExtendInfo& other) :
    application_name(other.application_name),
    user_login(other.user_login),
    file_name(other.file_name) {
  }

  VerifyExtendInfo& operator=(const VerifyExtendInfo& other) {
    this->application_name = other.application_name;
    this->user_login = other.user_login;
    this->file_name = other.file_name;
    return *this;
  }

  void Set(const String& application_name, const String& user_login, const String& file_name) {
    this->application_name = application_name;
    this->user_login = user_login;
    this->file_name = file_name;
  }

  String application_name;

  String user_login;

  String file_name;
};

class Signature : public Base {
 public:
  typedef enum _SignatureType {
    e_SignatureTypeDefault = 0,
    e_SignatureTypeSeal = 1,
    e_SignatureTypeSign = 2,
    e_SignatureTypeTimeStamp = 3
  } SignatureType;
  
  ~Signature();

  Signature(const Signature& other);

  Signature& operator = (const Signature& other);

  bool operator == (const Signature& other) const;

  bool operator != (const Signature& other) const;

  bool IsEmpty() const;

  SignatureType GetType();

  WString GetProviderName();

  WString GetCompany();

  WString GetVersion();

  WString GetDigestMethod();

  WString GetSignMethod();

  WString GetVerifyMessage();

  bool Operate(const foxit::ofd::ofdseal::OperateSignatureInfo& info);

  explicit Signature(FS_HANDLE handle);
};

class SealSignature FS_FINAL : public Signature {
 public:
  explicit SealSignature(Signature object);

  ~SealSignature();

  SealSignature(const SealSignature& other);

  SealSignature& operator = (const SealSignature& other);

  bool operator == (const SealSignature& other) const;

  bool operator != (const SealSignature& other) const;

  bool IsEmpty() const;

  WString GetSealId();

  WString GetSealVersion();

  WString GetSealVenderId();

  WString GetSealType();

  WString GetSealName();

  String GetSealSignerCertInfo();

  WString GetSealValidStartTime();

  WString GetSealValidEndTime();
  WString GetSealSignedDate();

  WString GetSealSignMethod();

  foxit::common::Bitmap GetImage();

  bool Verify(bool online = false);

  bool VerifyWithOes(const Oes& oes, bool online = false);

  bool VerifyWithoutOes(bool online = false);

  bool VerifyEx(const foxit::ofd::ofdseal::VerifyExtendInfo& extend_info, bool online = false);

  bool ExportPublicCertificateFile(const String& file_path);

  bool ExportPublicCertificateFile(const WString& file_path);

  bool ExportPublicCertificateFile(foxit::common::file::WriterCallback* writer_callback);

  explicit SealSignature(FS_HANDLE handle);
};

class SignSignature FS_FINAL : public Signature {
 public:
  explicit SignSignature(Signature object);

  ~SignSignature();

  SignSignature(const SignSignature& other);

  SignSignature& operator = (const SignSignature& other);

  bool operator == (const SignSignature& other) const;

  bool operator != (const SignSignature& other) const;

  bool IsEmpty() const;

  foxit::common::Bitmap GetImage();

  bool Verify();

  bool ExportPublicCertificateFile(const String& file_path);

  explicit SignSignature(FS_HANDLE handle);
};

}  // namespace ofdseal
}  // namespace ofd
}  // namespace foxit

#endif  // _BUILD_OFDSDK_