fs_pdfdoc.h

Go to the documentation of this file.

#ifndef FS_PDFDOC_H_
#define FS_PDFDOC_H_

#include "common/fs_common.h"
#include "common/file/fs_file.h"
#ifndef __EMSCRIPTEN_RENDER__
#include "pdf/fs_bookmark.h"
#include "pdf/fs_headerfooter.h"
#endif
#include "pdf/fs_pdfpage.h"
#ifndef __EMSCRIPTEN_RENDER__
#include "pdf/fs_readingbookmark.h"
#endif
#include "pdf/objects/fs_pdfobject.h"

namespace foxit {
namespace fdf {
#ifndef __EMSCRIPTEN_RENDER__
class FDFDoc;
#endif
}  // namespace fdf
namespace pdf {
// forward declaration
namespace actions {
class Action;
}  // namespace actions
namespace interform {
class Form;
}  // namespace interform;
class ReadingBookmark;
class SecurityHandler;
class StdEncryptData;
class CertificateEncryptData;
class DRMEncryptData;
class CustomEncryptData;
class RMSEncryptData;
class PagingSealSignature;
class WatermarkTextProperties;
class TiledWatermarkSettings FS_FINAL : public Object{
 public:
  typedef enum _Flags {
    e_FlagAsPageContents = 0x0000,
    e_FlagAsAnnot = 0x0001,
    e_FlagOnTop = 0x0002,
    e_FlagNoPrint = 0x0004,
    e_FlagInvisible = 0x0008
  } Flags;
  
  explicit TiledWatermarkSettings(float row_space, float col_space, float rotation,  int opacity ,int scale, uint32 flags)
    : row_space(row_space)
    , col_space(col_space)
    , rotation(rotation)
    , opacity(opacity)
    , scale(scale)
    , flags(flags){}

  TiledWatermarkSettings()
    : row_space(2.0)
    , col_space(2.0)
    , rotation(0)
    , opacity(100)
    , scale(100)
    , flags(0){}

  TiledWatermarkSettings(const TiledWatermarkSettings& settings)
      : row_space(settings.row_space)
      , col_space(settings.col_space)
      , rotation(settings.rotation)
      , opacity(settings.opacity)
      , scale(settings.scale)
      , flags(settings.flags){}

  TiledWatermarkSettings& operator = (const TiledWatermarkSettings& settings) {
    row_space = settings.row_space;
    col_space = settings.col_space;
    rotation = settings.rotation;
    opacity = settings.opacity;
    scale = settings.scale;
    flags = settings.flags;
    return *this;
  }

   void Set(float row_space, float col_space, float rotation,  int opacity, int scale, uint32 flags) {
     this->row_space = row_space;
     this->col_space = col_space;
     this->rotation = rotation;
     this->opacity = opacity;
     this->scale = scale;
     this->flags = flags;
   }

  float row_space;
  
  float col_space;
  
  float rotation;
  
  int opacity;

  int scale;

  uint32 flags;
};

class WrapperData FS_FINAL : public Object {
 public:
  WrapperData()
      : version(0) {}

  WrapperData(int version, const wchar_t* type, const wchar_t* app_id, const wchar_t* uri, const wchar_t* description)
      : version(version)
      , type(type)
      , app_id(app_id)
      , uri(uri)
      , description(description) {}

  WrapperData(const WrapperData& wrapper_data)
      : version(wrapper_data.version)
      , type(wrapper_data.type)
      , app_id(wrapper_data.app_id)
      , uri(wrapper_data.uri)
      , description(wrapper_data.description) {}

  WrapperData& operator = (const WrapperData& wrapper_data) {
    version = wrapper_data.version;
    type = wrapper_data.type;
    app_id = wrapper_data.app_id;
    uri = wrapper_data.uri;
    description = wrapper_data.description;
    return *this;
  }

  void Set(int version, const wchar_t* type, const wchar_t* app_id, const wchar_t* uri, const wchar_t* description) {
    this->version = version;
    this->type = type;
    this->app_id = app_id;
    this->uri = uri;
    this->description = description;
  }

  int version;
  WString type;
  WString app_id;
  WString uri;
  WString description;
};

class PayLoadData FS_FINAL {
 public:
  PayLoadData()
      : version(0.0f)
      , file_size (0){}

  PayLoadData(float version, const wchar_t* crypto_filter, const wchar_t* file_name,
        foxit::int64 file_size,
        const wchar_t* description)
      : version(version)
      , crypto_filter(crypto_filter)
      , file_name(file_name)
      , file_size(file_size)
      , description(description) 
  {}

  PayLoadData(const PayLoadData& payload_data)
    : version(payload_data.version)
    , crypto_filter(payload_data.crypto_filter)
    , file_name(payload_data.file_name)
    , file_size(payload_data.file_size)
    , description(payload_data.description)
    {}

  PayLoadData& operator=(const PayLoadData& payload_data) {
    version = payload_data.version;
    crypto_filter = payload_data.crypto_filter;
    description = payload_data.description;
    file_name = payload_data.file_name;
    file_size = payload_data.file_size;
    return *this;
  }

  void Set(float version, const wchar_t* crypto_filter, const wchar_t* file_name,
       int64 file_size,
       const wchar_t* description) {
    this->version = version;
    this->crypto_filter = crypto_filter;
    this->file_name = file_name;
    this->file_size = file_size;
    this->description = description;
  }

  float version;
  WString crypto_filter;
  WString file_name;
  int64 file_size;
  WString description;
};

class HiddenInfoSettingData FS_FINAL: public Object{
 public:
  HiddenInfoSettingData()
    : enable_remove_metadata(true)
    , enable_remove_fileattachment(true)
    , enable_remove_bookmark(true)
    , enable_remove_searchIndex(true)
    , enable_remove_comment(true)
    , enable_remove_form_fields(true)
    , enable_remove_hidden_text(true)
    , enable_remove_hidden_layer(true)
    , enable_remove_content(true)
    , enable_remove_link(true)
    , enable_remove_overlaping(true) { }

  HiddenInfoSettingData & operator = (const HiddenInfoSettingData & data) {
    enable_remove_metadata = data.enable_remove_metadata;
    enable_remove_fileattachment = data.enable_remove_fileattachment;
    enable_remove_bookmark = data.enable_remove_bookmark;
    enable_remove_searchIndex = data.enable_remove_searchIndex;
    enable_remove_comment = data.enable_remove_comment;
    enable_remove_form_fields = data.enable_remove_form_fields;
    enable_remove_hidden_text = data.enable_remove_hidden_text;
    enable_remove_hidden_layer = data.enable_remove_hidden_layer;
    enable_remove_content = data.enable_remove_content;
    enable_remove_link = data.enable_remove_link;
    enable_remove_overlaping = data.enable_remove_overlaping;
    return *this;
  }

  bool enable_remove_metadata;

  bool enable_remove_fileattachment;

  bool enable_remove_bookmark;

  bool enable_remove_searchIndex;

  bool enable_remove_comment;

  bool enable_remove_form_fields;

  bool enable_remove_hidden_text;

  bool enable_remove_hidden_layer;

  bool enable_remove_content;

  bool enable_remove_link;

  bool enable_remove_overlaping;
};

class PageBasicInfo FS_FINAL : public Object {
 public:
  PageBasicInfo(float width, float height, common::Rotation rotation)
      : width(width)
      , height(height)
      , rotation(rotation) {}

  PageBasicInfo()
      : width(0)
      , height(0)
      , rotation(CommonDefines::e_RotationUnknown) {}
  PageBasicInfo(const PageBasicInfo& page_info)
      : width(page_info.width)
      , height(page_info.height)
      , rotation(page_info.rotation) {}
  PageBasicInfo& operator = (const PageBasicInfo& page_info) {
    width = page_info.width;
    height = page_info.height;
    rotation = page_info.rotation;
    return *this;
  }
  void Set(float width, float height, common::Rotation rotation) {
    this->width = width;
    this->height = height;
    this->rotation = rotation;
  }

  float width;

  float height;
  common::Rotation rotation;
};

FSDK_DEFINE_ARRAY(PageBasicInfoArray, PageBasicInfo)


class EmbeddedFontData FS_FINAL : public Object {
 public:
  EmbeddedFontData() {}

  EmbeddedFontData(const EmbeddedFontData& other)
      : nonstandard_font_name_array(other.nonstandard_font_name_array)
      , standard_font_name_array(other.standard_font_name_array) {}

  EmbeddedFontData& operator=(const EmbeddedFontData& other) {
    nonstandard_font_name_array = other.nonstandard_font_name_array;
    standard_font_name_array = other.standard_font_name_array;
    return *this;
  }

  WStringArray nonstandard_font_name_array;
  WStringArray standard_font_name_array;
};

class TableOfContentsConfig FS_FINAL : public Object{
 public:
  TableOfContentsConfig(const wchar_t* title, Int32Array bookmark_level_array, bool is_show_serial_number, bool include_toc_pages) 
    : title(title)
    , bookmark_level_array(bookmark_level_array)
    , is_show_serial_number(is_show_serial_number)
    , include_toc_pages(include_toc_pages){}

  TableOfContentsConfig() 
    : title(L"")
    , bookmark_level_array(NULL)
    , is_show_serial_number(false)
    , include_toc_pages(false){}

  TableOfContentsConfig& operator = (const TableOfContentsConfig& other) {
    this->title = other.title;
    this->bookmark_level_array = other.bookmark_level_array;
    this->is_show_serial_number = other.is_show_serial_number;
    this->include_toc_pages = other.include_toc_pages;
    return *this;
  }

  bool operator == (const TableOfContentsConfig& other) const {
    if (this->title == other.title && this->is_show_serial_number == other.is_show_serial_number && this->include_toc_pages == other.include_toc_pages) {
      if (this->bookmark_level_array.GetSize() != other.bookmark_level_array.GetSize())
        return false;
      for (int i = 0; i < this->bookmark_level_array.GetSize(); i++) {
        if (this->bookmark_level_array.GetAt(i) != other.bookmark_level_array.GetAt(i))
          return false;
      }
      return true;
    }
    return false;
  }

  bool operator != (const TableOfContentsConfig& other) const {
    if (this->title != other.title || this->is_show_serial_number != other.is_show_serial_number || this->include_toc_pages != other.include_toc_pages)
      return true;
    if (this->bookmark_level_array.GetSize() != other.bookmark_level_array.GetSize())
      return true;
    for (int i = 0; i < this->bookmark_level_array.GetSize(); i++) {
      if (this->bookmark_level_array.GetAt(i) != other.bookmark_level_array.GetAt(i))
        return true;
    }
    return false;
  }

  void Set(const wchar_t* title, Int32Array bookmark_level_array, bool is_show_serial_number, bool include_toc_pages) {
    this->title = title;
    this->bookmark_level_array = bookmark_level_array;
    this->is_show_serial_number = is_show_serial_number;
    this->include_toc_pages = include_toc_pages;
  }

  WString title;
  
  Int32Array bookmark_level_array;

  bool is_show_serial_number;
  bool include_toc_pages;
};

class PDFDoc FS_FINAL : public Base {
 public:
  typedef enum _PasswordType {
    e_PwdInvalid   =  0,
    e_PwdNoPassword  =  1,
    e_PwdUser  =  2,
    e_PwdOwner  =  3
  } PasswordType;
  
  typedef enum _EncryptType {
    e_EncryptUnknown   =  -1,
    e_EncryptNone   =  0,
    e_EncryptPassword  =  1,
    e_EncryptCertificate  =  2,
    e_EncryptFoxitDRM  =  3,
    e_EncryptCustom  =  4,
    e_EncryptRMS  =  5,
    e_EncryptCDRM  =  6
  } EncryptType;
  
  typedef enum _UserPermissions {
    e_PermPrint = 0x0004,
    e_PermModify  = 0x0008,
    e_PermExtract = 0x0010,
    e_PermAnnotForm = 0x0020,
    e_PermFillForm = 0x0100,
    e_PermExtractAccess = 0x0200,
    e_PermAssemble = 0x0400,
    e_PermPrintHigh = 0x0800
  } UserPermissions;
  
  typedef enum _SaveFlags {
    e_SaveFlagNormal      =  0,
    e_SaveFlagIncremental    =  0x0001,
    e_SaveFlagNoOriginal    =  0x0002,
    e_SaveFlagXRefStream    =  0x0008,
    e_SaveFlagLinearized    =  0x1000,
    e_SaveFlagRemoveRedundantObjects = 0x0010,
    e_SaveFlagNoUpdatingMetadataDateTime = 0x0020
  } SaveFlags;
  
  typedef enum _ImportPageFlags {
    e_ImportFlagNormal      =  0,
    e_ImportFlagWithLayers    =  0x0001,
    e_ImportFlagShareStream    =  0x0002
  } ImportPageFlags;
  
  typedef enum _ExtractPagesOptions {
    e_ExtractPagesOptionAnnotation =  0x0001,
    e_ExtractPagesOptionStructureTree =  0x0002,
    e_ExtractPagesOptionJavascript = 0x0004,
    e_ExtractPagesOptionOCProperties = 0x0008,
    e_ExtractPagesOptionObjectStream = 0x0010,
    e_ExtractPagesOptionAttachFiles = 0x0020,
    e_ExtractPagesOptionBookmark = 0x0040,
    e_ExtractPagesOptionSignature = 0x0080
  } ExtractPagesOptions;
  
  typedef enum _InsertDocOptions {
    e_InsertDocOptionAttachments =  0x0001,
    e_InsertDocOptionBookmark =  0x0002
  } InsertDocOptions;
  
  typedef enum _DisplayMode {
    e_DisplayUseNone = 0,
    e_DisplayUseOutlines = 1,
    e_DisplayUseThumbs = 2,
    e_DisplayFullScreen = 3,
    e_DisplayUseOC = 4,
    e_DisplayUseAttachment = 5
  } DisplayMode;
  
  typedef enum _DataType {
    e_Forms      =  0x0001,
    e_Annots   =  0x0002,
    e_Links     =  0x0004
  } DataType;
  
  typedef enum _WrapperType {
    e_WrapperNone =  0,
    e_WrapperFoxit =  1,
    e_WrapperPDFV2 =  2
  } WrapperType;
  

  PDFDoc();

  explicit PDFDoc(const char* path);

  explicit PDFDoc(const wchar_t* path);

  explicit PDFDoc(const void* buffer, size_t size);

  explicit PDFDoc(common::file::ReaderCallback* file_read, bool is_async = false);
  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit PDFDoc(FS_HANDLE handle);
  ~PDFDoc();

  PDFDoc(const PDFDoc& other);

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

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

  bool IsEmpty() const;

  uint64 GetFileSize();

  bool IsLinearized() const;
  
  bool IsTaggedPDF() const;

  ErrorCode Load(const String& password = "");

  ErrorCode LoadW(const WString& password = WString());

  common::Progressive StartLoad(const String& password = "", bool is_cache_stream = true,
                                common::PauseCallback* pause = NULL);
  common::Progressive StartLoadW(const WString& password = WString(), bool is_cache_stream = true,
                                common::PauseCallback* pause = NULL);

  int GetFirstAvailPageIndex() const;

  bool IsXFA() const;

  bool IsEncrypted() const;

  void ClearRenderCache();

  PasswordType GetPasswordType() const;

  EncryptType GetEncryptionType() const;

  PasswordType CheckPassword(const String& password);

  PasswordType CheckPassword(const foxit::WString& password);

  bool IsUserPassword(const String& password);

  bool IsUserPassword(const foxit::WString& password);

  bool IsOwnerPassword(const String& password);

  bool IsOwnerPassword(const foxit::WString& password);

  String GetUserPassword(const String& owner_password);
#ifndef __EMSCRIPTEN_RENDER__

  StdEncryptData GetStdEncryptData() const;

  CertificateEncryptData GetCertificateEncryptData() const;

  DRMEncryptData GetDRMEncryptData() const;

  CustomEncryptData GetCustomEncryptData() const;

  RMSEncryptData GetRMSEncryptData() const;
#endif

  bool SaveAs(const char* file_path, uint32 save_flags = PDFDoc::e_SaveFlagNormal);

  bool SaveAs(const wchar_t* file_path, uint32 save_flags = PDFDoc::e_SaveFlagNormal);

  common::Progressive StartSaveAs(const char* file_path,
                                  uint32 save_flags = PDFDoc::e_SaveFlagNormal,
                                  common::PauseCallback* pause = NULL);

  common::Progressive StartSaveAs(const wchar_t* file_path,
                                  uint32 save_flags = PDFDoc::e_SaveFlagNormal,
                                  common::PauseCallback* pause = NULL);

  common::Progressive StartSaveAs(foxit::common::file::WriterCallback* file,
                                  foxit::uint32 save_flags = PDFDoc::e_SaveFlagNormal,
                                  foxit::common::PauseCallback* pause = NULL);
  
#ifndef __EMSCRIPTEN_RENDER__

  Bookmark GetRootBookmark();

  Bookmark CreateRootBookmark();

  int GetBookmarkLevelDepth();
  
  bool RemoveBookmark(const Bookmark& bookmark);

  bool HasLayer() const;

  bool HasHeaderFooter();

  HeaderFooter GetEditableHeaderFooter();

  void AddHeaderFooter(const HeaderFooter& headerfooter);

  void UpdateHeaderFooter(const HeaderFooter& headerfooter);

  bool RemoveAllHeaderFooters();
#endif

  int GetPageCount() const;

  PDFPage GetPage(int index);

  DisplayMode GetDisplayMode() const;

  void SetDisplayMode(DisplayMode display_mode);

  objects::PDFDictionary* GetCatalog() const;

  objects::PDFDictionary* GetTrailer() const;

  objects::PDFDictionary* GetInfo() const;

  objects::PDFDictionary* GetEncryptDict() const;

  objects::PDFDictionary* GetPagesDict() const;

  objects::PDFObject* GetIndirectObject(uint32 object_number);

  uint32 AddIndirectObject(objects::PDFObject* pdf_object);

  void DeleteIndirectObject(uint32 object_number);

  uint32 GetUserPermissions() const;

  bool IsWrapper() const;

  WrapperType GetWrapperType() const;

  WrapperData GetWrapperData() const;

  int64 GetWrapperOffset() const;

  PayLoadData GetPayLoadData();

  common::Progressive StartGetPayloadFile(foxit::common::file::WriterCallback* payload_file, common::PauseCallback* pause = NULL);

  bool SaveAsWrapperFile(const wchar_t* file_path, const WrapperData* wrapper_data = NULL,
                         uint32 user_permissions = 0xFFFFFFFC, const char* owner_password = "");

  common::Progressive StartSaveAsPayloadFile(const wchar_t* file_path, const wchar_t* payload_file_path,
      const wchar_t* crypto_filter, const wchar_t* description, float version,
                                             uint32 save_flags = PDFDoc::e_SaveFlagNormal,
                                             common::PauseCallback* pause = NULL);
  bool HasForm() const;

  int GetReadingBookmarkCount();
#ifndef __EMSCRIPTEN_RENDER__

  ReadingBookmark GetReadingBookmark(int index);

  ReadingBookmark InsertReadingBookmark(int reading_bookmark_index, const WString& title, int dest_page_index);

  bool RemoveReadingBookmark(const ReadingBookmark& reading_bookmark);

  int GetSignatureCount();

  foxit::pdf::Signature GetSignature(int index);

  void RemoveSignature(const foxit::pdf::Signature& signature);
#endif

  PDFPage InsertPage(int index, float width, float height);
  PDFPage InsertPage(int index, foxit::pdf::PDFPage::Size size = PDFPage::e_SizeLetter);

  PDFPage AddPageFromTemplate(const wchar_t* template_name);

  bool HidePageTemplate(const wchar_t* template_name);

  bool RemovePage(int index);

  bool RemovePage(const foxit::pdf::PDFPage& page);

  bool MovePageTo(const PDFPage& page, int dest_index);

  bool MovePagesTo(const common::Range& page_range, int dest_index);

  common::Progressive StartImportPagesFromFilePath(int dest_index,
                                                   const wchar_t* src_file_path, const String& password,
                                                   uint32 flags = PDFDoc::e_ImportFlagNormal, const char* layer_name = "",
                                                   const common::Range& page_range = common::Range(),
                                                   common::PauseCallback* pause = NULL);
  common::Progressive StartImportPagesFromFilePath(int dest_index,
                                                   const wchar_t* src_file_path, const WString& password,
                                                   uint32 flags = PDFDoc::e_ImportFlagNormal, const char* layer_name = "",
                                                   const common::Range& page_range = common::Range(),
                                                   common::PauseCallback* pause = NULL);
  common::Progressive StartImportPages(int dest_index, const PDFDoc& src_doc,
                                       uint32 flags = PDFDoc::e_ImportFlagNormal, const char* layer_name = "",
                                       const common::Range& page_range = common::Range(),
                                       common::PauseCallback* pause = NULL);

  common::Progressive StartExtractPages(const char* file_path, uint32 options, const common::Range& page_range = common::Range(),
      common::PauseCallback* pause = NULL);

  common::Progressive StartExtractPages(const wchar_t* file_path, uint32 options, const common::Range& page_range = common::Range(),
      common::PauseCallback* pause = NULL);

  common::Progressive StartExtractPages(foxit::common::file::WriterCallback* file, uint32 options, const foxit::common::Range& page_range = common::Range(),
                                        foxit::common::PauseCallback* pause = NULL);

  void InsertDocument(int dest_index, const PDFDoc& src_doc, uint32 options);

  void InsertDocument(int dest_index, const PDFDoc& src_doc, uint32 options, const wchar_t* bookmark_title);
 
  void Sanitize();

  void RemoveHiddenInfo(const HiddenInfoSettingData& hidden_data_setting);

#ifndef __EMSCRIPTEN_RENDER__

  bool ImportFromFDF(const fdf::FDFDoc& fdf_doc, int types = pdf::PDFDoc::e_Forms | pdf::PDFDoc::e_Annots, const common::Range& page_range = common::Range());

  bool ExportToFDF(const fdf::FDFDoc& fdf_doc, int types = pdf::PDFDoc::e_Forms | pdf::PDFDoc::e_Annots, const common::Range& page_range = common::Range());

  bool ExportAnnotToFDF(const annots::Annot& pdf_annot,const fdf::FDFDoc& fdf_doc);

  bool ExportFormFieldsToFDF(const pdf::interform::FieldArray& field_array, bool is_include, const fdf::FDFDoc& fdf_doc);
#endif

  String GetHeader() const;

  int GetFileVersion();

  void SetFileVersion(int version);

  bool SetSecurityHandler(const SecurityHandler& handler);

  SecurityHandler GetSecurityHandler();

  bool RemoveSecurity();

  int GetFontCount();

  common::Font GetFont(int index);

  actions::Action GetOpenAction();

  bool SetOpenAction(actions::Action& action);

  bool RemoveOpenAction();

  bool DoJSOpenAction();

  bool IsPortfolio();

  PageBasicInfo GetPageBasicInfo(int index);

  PageBasicInfoArray GetAllPageBasicInfo();

  EmbeddedFontData GetEmbeddedFontData();
#ifdef _SUPPORTWEBSDK_
  objects::PDFStream* CreateIcon(String imgStream,int width, int height);
#endif

  void CreateDSS();

  void AddTableOfContents(const wchar_t* title, Int32Array bookmark_level_array);

  void AddTableOfContents(const TableOfContentsConfig& table_of_contents_config);

  void SetCacheFile(foxit::common::file::StreamCallback* file_stream, bool is_own_file_stream);

  common::Progressive StartRecognizeForm(common::PauseCallback* pause = NULL);

  common::Progressive StartRecognizeForm(bool is_set_tool_tips, common::PauseCallback* pause = NULL);

  WString GetPageText(int page_index) const;

  PagingSealSignature AddPagingSealSignature(const common::Range& page_range, float width, float height, bool to_check_permission = true);

  common::Progressive StartEmbedAllFonts(common::PauseCallback* pause = NULL);
  common::Progressive StartAddTiledWatermark(const wchar_t* text, const TiledWatermarkSettings& settings, const WatermarkTextProperties& properties, const common::Range& page_range, common::PauseCallback* pause = NULL);
  common::Progressive StartAddTiledWatermark(const wchar_t* src_img_file_path, const TiledWatermarkSettings& settings, const common::Range& page_range, common::PauseCallback* pause = NULL);

  common::Progressive StartAddTiledWatermark(foxit::common::file::ReaderCallback* src_img_stream, const TiledWatermarkSettings& settings, const common::Range& page_range, common::PauseCallback* pause = NULL);
  common::Progressive StartAddTiledWatermark(const foxit::pdf::PDFPage& page, const TiledWatermarkSettings& settings, const common::Range& page_range, common::PauseCallback* pause = NULL);

  annots::AnnotArray GetAnnotsByIdArray(const WStringArray& unique_id_arr);

  void RemoveStructTree();

};
}  // namespace pdf
}  // namespace foxit
#endif  // FS_PDFDOC_H_