fs_ofddoc.h

#ifndef FS_OFD_DOC_H_
#define FS_OFD_DOC_H_

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

namespace foxit {
namespace fld {
class FLDDoc;
}
namespace ofd {
class OFDPage;
class OFDTemplatePage;
class Catalog;
class Bookmarks;
class CustomTags;
class TagTreeNode;
class Outline;
class Attachments;
class Attachment;
class OFDPermission;
class Annots;
namespace ofdseal {
class Signature;
}

class PageNumberParameter FS_FINAL : public Object {
 public:
  typedef enum _PageNumberLocationType {
    e_PageNumberLocationTypeLeftTop   =  0,
    e_PageNumberLocationTypeTopMiddle  =  1,
    e_PageNumberLocationTypeRightTop  =  2,
    e_PageNumberLocationTypeLeftBottom  =  3,
    e_PageNumberLocationTypeBottomMiddle  =  4,
    e_PageNumberLocationTypeRightBottom  =  5
  } PageNumberLocationType;
  
  typedef enum _PageNumberMarginType {
    e_PageNumberMarginTypeSmall   =  0,
    e_PageNumberMarginTypeNormal  =  1,
    e_PageNumberMarginTypeLarge  =  2
  } PageNumberMarginType;
  

  PageNumberParameter() :
    location(PageNumberParameter::e_PageNumberLocationTypeLeftTop),
    font_name(L"宋体"),
    font_size(12),
    text_color(0),
    start_page(0),
    end_page(0),
    is_first_page_cover(false),
    first_page_number(1),
    is_folio(false),
    margin(PageNumberParameter::e_PageNumberMarginTypeNormal),
    skip_blank_page(false) {}

  explicit PageNumberParameter(PageNumberLocationType location, const WString& font_name, float font_size, foxit::RGB text_color, int start_page,
    int end_page, bool is_first_page_cover, int first_page_number, bool is_folio, PageNumberMarginType margin, bool skip_blank_page) :
    location(location),
    font_name(font_name),
    font_size(font_size),
    text_color(text_color),
    start_page(start_page),
    end_page(end_page),
    is_first_page_cover(is_first_page_cover),
    first_page_number(first_page_number),
    is_folio(is_folio),
    margin(margin),
    skip_blank_page(skip_blank_page) {}

  PageNumberParameter(const PageNumberParameter& other) {
    this->location = other.location;
    this->font_name = other.font_name;
    this->font_size = other.font_size;
    this->text_color = other.text_color;
    this->start_page = other.start_page;
    this->end_page = other.end_page;
    this->is_first_page_cover = other.is_first_page_cover;
    this->first_page_number = other.first_page_number;
    this->is_folio = other.is_folio;
    this->margin = other.margin;
    this->skip_blank_page = other.skip_blank_page;
  }

  PageNumberParameter& operator = (const PageNumberParameter& other) {
    this->location = other.location;
    this->font_name = other.font_name;
    this->font_size = other.font_size;
    this->text_color = other.text_color;
    this->start_page = other.start_page;
    this->end_page = other.end_page;
    this->is_first_page_cover = other.is_first_page_cover;
    this->first_page_number = other.first_page_number;
    this->is_folio = other.is_folio;
    this->margin = other.margin;
    this->skip_blank_page = other.skip_blank_page;
    return *this;
  }

  void Set(PageNumberLocationType location, const WString& font_name, float font_size, foxit::RGB text_color, int start_page,
           int end_page, bool is_first_page_cover, int first_page_number, bool is_folio, PageNumberMarginType margin, bool skip_blank_page) {
    this->location = location;
    this->font_name = font_name;
    this->font_size = font_size;
    this->text_color = text_color;
    this->start_page = start_page;
    this->end_page = end_page;
    this->is_first_page_cover = is_first_page_cover;
    this->first_page_number = first_page_number;
    this->is_folio = is_folio;
    this->margin = margin;
    this->skip_blank_page = skip_blank_page;
  }

  PageNumberLocationType location;

  WString font_name;

  float font_size;

  foxit::RGB text_color;

  int start_page;

  int end_page;

  bool is_first_page_cover;

  int first_page_number;

  bool is_folio;

  PageNumberMarginType margin;

  bool skip_blank_page;
};

class OFDDoc FS_FINAL : public Base {
 public:
  typedef enum _EncryptMethod {
    e_OFDEncryptMethodNone   =  0,
    e_OFDEncryptMethodPwd  =  1,
    e_OFDEncryptMethodCert  =  2
  } EncryptMethod;
  
  typedef enum _EncryptType {
    e_OFDEncryptTypeNone   =  0,
    e_OFDEncryptTypeRC4  =  1,
    e_OFDEncryptTypeAES128  =  2,
    e_OFDEncryptTypeAES256  =  3,
    e_OFDEncryptTypeSM4  =  4
  } EncryptType;
  
  typedef enum _ResourceType {
    e_OFDResourceTypeUnknown   =  0,
    e_OFDResourceTypeColorSpace  =  1,
    e_OFDResourceTypeDrawParam  =  2,
    e_OFDResourceTypeFont  =  3,
    e_OFDResourceTypeMultimedia  =  4,
    e_OFDResourceTypeCompositeGraphicUnit  =  5
  } ResourceType;
  

  explicit OFDDoc(const foxit::fld::FLDDoc& doc);

  ~OFDDoc();

  OFDDoc(const OFDDoc& other);

  OFDDoc& operator = (const OFDDoc& other);

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

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

  bool IsEmpty() const;

  int GetPageCount();

  OFDPage GetPage(int index);

  OFDPage GetPageByID(foxit::uint32 id);

  OFDPage AddPage();

  OFDPage InsertPage(int index);

  void RemovePage(int index);

  void ReservedPage(int index);

  bool MovePage(int index, int dest_index);

  int GetTemplatePageCount();

  OFDTemplatePage GetTemplatePage(int index);

  OFDTemplatePage GetTemplatePageByID(int id);

  OFDTemplatePage GetTemplatePageByName(const String& name);

  OFDTemplatePage InsertTemplatePage(int index);

  void RemoveTemplatePage(int index);

  void RemoveAllTemplatePages();

  OFDTemplatePage AddTemplatePage();

  OFDTemplatePage AddTemplatePageFromPage(OFDPage page);

  OFDPage AddPageFromTemplatePage(int index, int dest_index = -1);

  Attachments CreateAttachments();

  Attachments GetAttachments();

  int GetAttachmentCount();

  Attachment GetAttachment(int index);

  Attachment GetAttachmentByName(const String& name);

  String GetAttachmentBuffer(int index);

  foxit::common::file::ReaderCallback* GetAttachmentFile(int index);

  void ExportAttachment(int index, const String& file_path);

  void ExportAttachment(int index, const WString& file_path);

  void ExportAttachment(int index, foxit::common::file::WriterCallback* file_writer);

  Attachment AddAttachment(const String& file_name, const String& name = NULL, const String& usage = NULL);

  Attachment AddAttachment(const WString& file_name, const String& name = NULL, const String& usage = NULL);

  int GetXmlFileAttachmentCount();

  bool SaveXmlFileAttachment(int index, const String& file_path);

  bool SaveXmlFileAttachment(int index, const WString& file_path);

  WString GetMetadata(const WString& key);

  void SetMetadata(const WString& key, const WString& value);

  int GetKeywordCount();

  void InsertKeyword(const WString& keyword, int index = -1);

  void RemoveKeyword(int index);

  int GetCustomDataCount();

  WString GetCustomDataName(int index);

  WString GetCustomDataValue(int index);

  void AddCustomData(const String& key, const String& value);

  void InsertCustomData(const String& key, const String& value, int index);

  void RemoveCustomData(int index);

  foxit::uint32 AddResourceFromFile(const String& file_path, const String& format);

  foxit::uint32 AddResourceFromFile(const WString& file_path, const String& format);

  foxit::uint32 AddImageResourceFromFile(const String& file_path);

  foxit::uint32 AddImageResourceFromFile(const WString& file_path);

  foxit::uint32 AddImageResourceFromBuffer(const String& buffer, foxit::common::Image::Type format);

  foxit::uint32 AddFontResourceFromName(const String& font_family, const String& font_name);

  ResourceType GetResourceTypeByID(foxit::uint32 res_id);

  foxit::common::file::ReaderCallback* GetMultiMediaFileByID(int res_id);

  void ExportMultiMediaByID(foxit::uint32 res_id, const String& file_path);

  void ExportMultiMediaByID(foxit::uint32 res_id, const WString& file_path);

  void ExportMultiMediaByID(foxit::uint32 res_id, foxit::common::file::WriterCallback* file_writer);

  String GetMultiMediaBufferByID(foxit::uint32 res_id);

  WString GetMultiMediaFileNameByID(foxit::uint32 res_id);

  WString GetMultiMediaTypeByID(foxit::uint32 res_id);

  WString GetMultiMediaFormatByID(foxit::uint32 res_id);

  void ExportAnnots(const String& file_path);

  void ExportAnnots(int start_index, int end_index, const String& file_path);

  void ImportAnnots(const String& file_path);

  void AddPageNumber(const PageNumberParameter& param);

  bool InsertDocument(const OFDDoc& other, int dest_index = -1);

  Outline CreateOutline();

  Outline GetOutline();

  bool RemoveOutline();

  bool AddCatalog(const Catalog& catalog);

  int GetSignatureCount();

  ofdseal::Signature GetSignature(int index);

  Bookmarks CreateBookmarks();

  Bookmarks GetBookmarks();

  CustomTags CreateCustomTags();

  CustomTags GetCustomTags();

  TagTreeNode GetTagTreeRoot(const String& type);

  void InitializeTagTreeNode(const String& type, const String& name_space, const String& name, const String& file_extension, bool key_unique);

  void InitializeCertTagTreeNode(bool key_unique);

  void BeginTagTreeNode(const String& key_path);

  void AddTagTreeNodeMetaData(const String& key, const String& value);

  void EndTagTreeNode(const String& key_path);

  void ClearTagTreeNode();

  bool ExportOfficeDoc(const String& file_path);

  bool ExportOfficeDoc(const WString& file_path);

  bool RestoreOriginalDocument();

  bool RefreshObjectsPermission(bool authenticated);

  bool CustomEncrypt(const String& security_type, const String& crypto_type, int key_length, const String& user_password, const String& owner_password);

  bool RemoveEncryption(const String& owner_password);

  OFDPermission GetPermissions();

  OFDPermission CreatePermissions();

  void EmbedFont(const String& font_name);

  int GetVersionCount();

  void SetCurrentVersion(int index);

  void CreateVersion();

  explicit OFDDoc(FS_HANDLE handle = NULL);
};

}  // namespace ofd
}  // namespace foxit

#endif  // FS_OFD_DOC_H_