PDFDoc.h

Go to the documentation of this file.

//---------------------------------------------------------------------------------------
// Copyright (c) 2001-2025 by Apryse Software Inc. All Rights Reserved.
// Consult legal.txt regarding legal and license information.
//---------------------------------------------------------------------------------------
#ifndef PDFTRON_H_CPPPDFPDFDoc
#define PDFTRON_H_CPPPDFPDFDoc
 
#include <Common/BasicTypes.h>
#include <FDF/FDFDoc.h>
#include <PDF/PDFDocInfo.h>
#include <PDF/PageLabel.h>
//#include <PDF/OCG/Config.h>
#include <C/PDF/TRN_PDFDoc.h>
#include <PDF/PDFDocViewPrefs.h>
#include <SDF/SDFDoc.h>
#include <PDF/Page.h>
#include <PDF/PageSet.h>
#include <PDF/DiffOptions.h>
#include <PDF/TextDiffOptions.h>
#include <PDF/Annot.h>
#include <Common/Iterator.h>
#include <SDF/SignatureHandler.h>
#include <SDF/UndoManager.h>
#include <PDF/DigitalSignatureField.h>
#include <PDF/ViewerOptimizedOptions.h>
#include <PDF/RefreshOptions.h>
#include <PDF/MergeXFDFOptions.h>
 
namespace pdftron {
    namespace PDF {
        class Bookmark;
        namespace OCG{
            class Config;
        }
        namespace Struct{class STree;};
 
typedef Common::Iterator<Page> PageIterator;
 
typedef Common::Iterator<Field> FieldIterator;
 
typedef Common::Iterator<DigitalSignatureField> DigitalSignatureFieldIterator;

class PDFDoc
{
public:

     PDFDoc ();

     PDFDoc (SDF::SDFDoc& sdfdoc);

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

     PDFDoc (const UString& filepath);
     PDFDoc (const char* filepath);

     PDFDoc (Filters::Filter stream);

     PDFDoc (const UChar* buf, size_t buf_size);

     ~PDFDoc ();

     void Close();
 
     bool IsEncrypted();

    bool InitSecurityHandler (
#ifndef SWIG
        void* custom_data = 0
#endif
        );

     bool InitStdSecurityHandler(const char* password, int password_sz);

    bool InitStdSecurityHandler(const pdftron::UString& password);
    
    bool InitStdSecurityHandler(const std::vector<UInt8>& password_buf);

     SDF::SecurityHandler GetSecurityHandler ();

     void SetSecurityHandler(const SDF::SecurityHandler & handler);

     void RemoveSecurity();
 
 
     /* {{codegen: PDFDoc}} */
     /* {{codegen: PDFDoc}} */

    bool HasSignatures();

    SDF::SignatureHandlerId AddSignatureHandler(const SDF::SignatureHandler& signature_handler);

    SDF::SignatureHandlerId AddStdSignatureHandler(const UString& pkcs12_keyfile, const UString& pkcs12_keypass);

    SDF::SignatureHandlerId AddStdSignatureHandler(const std::vector<unsigned char>& pkcs12_keybuffer, const UString& pkcs12_keypass);

    void RemoveSignatureHandler(const SDF::SignatureHandlerId signature_handler_id);

    SDF::SignatureHandler* GetSignatureHandler(const SDF::SignatureHandlerId signature_handler_id);

    SDF::UndoManager GetUndoManager();

    PDF::DigitalSignatureField CreateDigitalSignatureField(const UString& in_sig_field_name = "");
    
    PDF::DigitalSignatureFieldIterator GetDigitalSignatureFieldIterator();
    
    PDF::DigitalSignatureField::DocumentPermissions GetDigitalSignaturePermissions() const;
    
    PDFDocInfo GetDocInfo();

     PDFDocViewPrefs GetViewPrefs();
 
     enum ActionTriggerEvent
     {
         e_action_trigger_doc_will_close = 17, //Triggered before closing a document
         e_action_trigger_doc_will_save = 18, //Triggered before saving a document
         e_action_trigger_doc_did_save = 19, //Triggered after saving a document
         e_action_trigger_doc_will_print = 20, //Triggered before printing a document
         e_action_trigger_doc_did_print = 21 //Triggered after printing a document
     };

     SDF::Obj GetTriggerAction(PDFDoc::ActionTriggerEvent trigger);

     bool IsModified () const; 

     bool HasRepairedXRef() const;

     bool IsLinearized() const;
    
    bool HasDownloader();
    
    UInt64 GetDownloadedByteCount ();
    
    UInt64 GetTotalRemoteByteCount ();

     void Save(const UString& path, UInt32 flags);
 
#ifndef SWIG
     void Save(const UString& path, UInt32 flags, Common::ProgressMonitor* progress);
#endif
     
     std::vector<unsigned char> Save(UInt32 flags);
 
#ifndef SWIG
     void Save(const char* &out_buf, size_t& out_buf_size, UInt32 flags, Common::ProgressMonitor* progress);  
#endif

     void Save(Filters::Filter& stream, UInt32 flags); 
 
#ifdef SWIG
    void SaveCustomSignature(const std::vector<UChar>& in_signature, const DigitalSignatureField& in_field, const UString& in_path);
    void SaveCustomSignature(const std::vector<UChar>& in_signature, const DigitalSignatureField& in_field, Filters::Filter& out_stream);
#else
     void SaveCustomSignature(const UChar* in_signature, const size_t in_signature_size, const DigitalSignatureField& in_field, const UString& in_path);
     void SaveCustomSignature(const UChar* in_signature, const size_t in_signature_size, const DigitalSignatureField& in_field, Filters::Filter& out_stream);

    void SaveCustomSignature(const UChar* in_signature, const size_t in_signature_size, const DigitalSignatureField& in_field, const UChar* &out_buf, size_t& out_buf_size);
#endif
 

     PageIterator GetPageIterator(UInt32 page_number=1);

     Page GetPage(UInt32 page_number);

     void PageRemove(const PageIterator& page_itr);
 
     enum InsertFlag {
        e_none,               //default, do not insert bookmarks
        e_insert_bookmark, //insert bookmarks (use this option when inserting many pages in a single call)
        e_insert_goto_bookmark // same as e_insert_bookmark, but ignore GoToR and URI links, while still retaining bookmark hierarchy (use this option when inserting one page at a time)
    };

     void PageInsert(PageIterator& where, Page page);

    void InsertPages(int insert_before_page_number
        , PDFDoc& src_doc
        , int start_page
        , int end_page 
        , enum InsertFlag flag 
#ifndef SWIG        
        , Common::ProgressMonitor * monitor = 0
#endif
        );

    void InsertPages(int insert_before_page_number
        , PDFDoc& src_doc
        , const PageSet& source_page_set
        , enum InsertFlag flag
#ifndef SWIG
        , Common::ProgressMonitor * monitor = 0
#endif
        );
 
    
    void MovePages(int move_before_page_number
        , PDFDoc& src_doc
        , int start_page
        , int end_page
        , enum InsertFlag flag
#ifndef SWIG
        , Common::ProgressMonitor * monitor = 0
#endif
        );
 
    
    void MovePages(int move_before_page_number
        , PDFDoc& src_doc
        , const PageSet& source_page_set
        , enum InsertFlag flag
#ifndef SWIG
        , Common::ProgressMonitor * monitor = 0
#endif
        );

     void PagePushFront(Page page);

     void PagePushBack(Page page);

     std::vector<Page> ImportPages(const std::vector<Page>& pages, bool import_bookmarks = false);

     Page PageCreate(const Rect& media_box = Rect(0, 0, 612, 792));

     int AppendTextDiff(Page page1, Page page2);

     int AppendTextDiff(PDFDoc& doc1, PDFDoc& doc2);

     int AppendTextDiff(PDFDoc& doc1, PDFDoc& doc2, TextDiffOptions* options);

     static int HighlightTextDiff(PDFDoc& doc1, PDFDoc& doc2, TextDiffOptions* options);

     class Bookmark GetFirstBookmark();

     void AddRootBookmark(class Bookmark root_bookmark);

     SDF::Obj GetTrailer ();

     SDF::Obj GetRoot();

     SDF::Obj GetPages();

     int GetPageCount ();
    

     FieldIterator GetFieldIterator();

     FieldIterator GetFieldIterator(const UString& field_name);

     Field GetField(const UString& field_name);
 
     Field FieldCreate(const UString& field_name, 
        Field::Type type, 
        SDF::Obj field_value = 0, 
        SDF::Obj def_field_value = 0);

     Field FieldCreate(const UString& field_name,
         Field::Type type,
         const UString& field_value,
         const UString& def_field_value = "");

     void RefreshFieldAppearances();

    void RefreshAnnotAppearances(const RefreshOptions* options = 0);
    
     void FlattenAnnotations(bool forms_only = false);

     SDF::Obj GetAcroForm();
 
     enum ExtractFlag {
         e_forms_only,              // default, only extract form fields to FDF
         e_annots_only,                // only extract annots
         e_both,                      // extract both form fields and annots
         e_annots_only_no_links = 5 // same as e_annots_only but no url links get converted
     };

     FDF::FDFDoc FDFExtract(enum ExtractFlag flag = e_forms_only);

     FDF::FDFDoc FDFExtract(PageSet& pages_to_extract, enum ExtractFlag flag = e_forms_only);

     FDF::FDFDoc FDFExtract(const std::vector<Annot>& annotations);

     FDF::FDFDoc FDFExtract(const std::vector<Annot>& annot_added, const std::vector<Annot>& annot_modified, const std::vector<Annot>& annot_deleted);

     void FDFMerge(FDF::FDFDoc& fdf_doc);

     void FDFUpdate(FDF::FDFDoc& fdf_doc);

     Action GetOpenAction();

     void SetOpenAction(const Action& action);

     void AddFileAttachment(const UString& file_key, FileSpec embedded_file);

     PageLabel GetPageLabel(int page_num);

     void SetPageLabel(int page_num, PageLabel& label);

     void RemovePageLabel(int page_num);

    bool IsTagged();

     Struct::STree GetStructTree();

     bool HasOC() const;

     SDF::Obj GetOCGs() const;

     OCG::Config GetOCGConfig() const;

     void AddHighlights(const UString& hilite);

     SDF::Obj CreateIndirectName(const char* name);
     SDF::Obj CreateIndirectArray();
     SDF::Obj CreateIndirectBool(bool value);
     SDF::Obj CreateIndirectDict();
     SDF::Obj CreateIndirectNull();
     SDF::Obj CreateIndirectNumber(double value);
     SDF::Obj CreateIndirectString(const UChar* value, UInt32 size);
     SDF::Obj CreateIndirectString(const UString& str);
     SDF::Obj CreateIndirectStream(Filters::FilterReader& data, Filters::Filter filter_chain=Filters::Filter(0,false));
     SDF::Obj CreateIndirectStream(const char* data, const size_t data_size, Filters::Filter filter_chain = Filters::Filter (0,false));

     SDF::SDFDoc& GetSDFDoc ();

     operator SDF::SDFDoc& () { return GetSDFDoc(); }
 

     void Lock();

     void Unlock();

     bool TryLock( int milliseconds = 0 );

     void LockRead();

     void UnlockRead();

     bool TryLockRead( int milliseconds = 0 );

     UString GetFileName() const;

    void GenerateThumbnails(UInt32 size);
    
    void AppendVisualDiff(Page p1, Page p2, DiffOptions* opts);
    
    void SaveViewerOptimized(const UString& path, const ViewerOptimizedOptions& opts);
 
#ifndef SWIG
    void SaveViewerOptimized(const char* &out_buf, size_t& out_buf_size, const ViewerOptimizedOptions& opts);
#endif
    std::vector<unsigned char> SaveViewerOptimized(const ViewerOptimizedOptions& opts);
 
     enum SignaturesVerificationStatus
     {
         e_unsigned,
         // e_failure == bad doc, digest, or MDP (i.e. does not include trust issues, because those are flaky due to being network/config-related)
         e_failure,
         e_untrusted,
         e_unsupported,
         // unsigned sigs skipped; parts of document may be unsigned (check GetByteRanges on signed sigs to find out)
         e_verified
     };

    SignaturesVerificationStatus VerifySignedDigitalSignatures(const VerificationOptions& in_opts) const;

    void MergeXFDF(Filters::Filter stream, const MergeXFDFOptions* opts = 0);
    void MergeXFDF(const UString& xfdf, const MergeXFDFOptions* opts = 0);
 
    //for xamarin use only
    static PDFDoc* CreateInternal(ptrdiff_t impl);
    ptrdiff_t GetHandleInternal();
 
// @cond PRIVATE_DOC
#ifndef SWIGHIDDEN
 
    TRN_PDFDoc mp_doc;
    PDFDoc(TRN_PDFDoc impl) : mp_doc(impl) {}
#endif
// @endcond
    
};
 
    };  // namespace PDF
};  // namespace pdftron
 
 
#include <Impl/PDFDoc.inl>
 
#endif // PDFTRON_H_CPPPDFPDFDoc