PDFDoc.h

Go to the documentation of this file.

//---------------------------------------------------------------------------------------
// Copyright (c) 2001-2012 by PDFTron Systems Inc. All Rights Reserved.
// Consult legal.txt regarding legal and license information.
//---------------------------------------------------------------------------------------

#ifndef   H_CPPPDFDoc
#define   H_CPPPDFDoc

#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 <Common/Iterator.h>

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

typedef Common::Iterator<Page> PageIterator;

typedef Common::Iterator<Field> FieldIterator;


class PDFDoc
{
public:

         PDFDoc ();

         PDFDoc (SDF::SDFDoc& sdfdoc);

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

         SDF::SecurityHandler GetSecurityHandler ();

         void SetSecurityHandler (SDF::SecurityHandler handler);

         void RemoveSecurity();

        PDFDocInfo GetDocInfo();

         PDFDocViewPrefs GetViewPrefs();

         bool IsModified () 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

         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 insertBeforeThisPage
                , PDFDoc& sourceDoc
                , int startPage
                , int endPage 
                , enum InsertFlag flag 
#ifndef SWIG            
                , Common::ProgressMonitor * monitor = 0
#endif
                );

        void InsertPages(int insertBeforeThisPage
                , PDFDoc& sourceDoc
                , const PageSet& sourcePageSet
                , enum InsertFlag flag
#ifndef SWIG
                , Common::ProgressMonitor * monitor = 0
#endif
                );

        
        void MovePages(int moveBeforeThisPage
                , PDFDoc& sourceDoc
                , int startPage
                , int endPage
                , enum InsertFlag flag
#ifndef SWIG
                , Common::ProgressMonitor * monitor = 0
#endif
                );

        
        void MovePages(int moveBeforeThisPage
                , PDFDoc& sourceDoc
                , const PageSet& sourcePageSet
                , 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();

         FDF::FDFDoc FDFExtract();

         void FDFMerge(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 IsLocked();
         
         bool TryLock( int milliseconds = 0 );

         UString GetFileName() const;

#ifndef SWIGHIDDEN
        TRN_PDFDoc mp_doc;
#endif
private:
        PDFDoc (const PDFDoc&);
        PDFDoc& operator= (const PDFDoc&);
};

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


#include <Impl/PDFDoc.inl>
#endif

---

© 2002-2012 PDFTron Systems Inc.