PDFDoc.h

Go to the documentation of this file.

//---------------------------------------------------------------------------------------
// Copyright (c) 2001-2018 by PDFTron Systems Inc. All Rights Reserved.
// Consult legal.txt regarding legal and license information.
//---------------------------------------------------------------------------------------
#ifndef PDFTRON_H_CPPPDFPDFDoc
#define PDFTRON_H_CPPPDFPDFDoc

#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/Annot.h>
#include <Common/Iterator.h>
#include <SDF/SignatureHandler.h>

namespace pdftron {
    namespace PDF {
        namespace OCG{
            class Config;
        }
        namespace Struct{class STree;};

typedef Common::Iterator<Page> PageIterator;

typedef Common::Iterator<Field> FieldIterator;


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 (SDF::SecurityHandler handler);

     void RemoveSecurity();

    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);

    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;

     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); 

     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
    };

     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));

     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 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);

        
    //for xamarin use only
    static PDFDoc* CreateInternal(ptrdiff_t impl);
    ptrdiff_t GetHandleInternal();

#ifndef SWIGHIDDEN

    TRN_PDFDoc mp_doc;
    //for xamarin use only
    PDFDoc(TRN_PDFDoc impl) : mp_doc(impl) {}
#endif
    
};

    };  // namespace PDF
};  // namespace pdftron


#include <Impl/PDFDoc.inl>

#endif // PDFTRON_H_CPPPDFPDFDoc