PDFDoc.h

Go to the documentation of this file.

//---------------------------------------------------------------------------------------
// Copyright (c) 2001-2008 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/Struct/STree.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 <Common/Iterator.h>

namespace pdftron {
        namespace PDF {

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 char* buf, ULong buf_size);

         ~PDFDoc ();

         bool IsEncrypted();

         bool InitSecurityHandler (void* custom_data = 0);

         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, ULong flags, Common::ProgressMonitor* progress);

         void Save(const char* &out_buf, ULong& out_buf_size, ULong flags, Common::ProgressMonitor* progress); 

         PageIterator GetPageIterator(UInt page_number=1);

         Page GetPage(UInt page_number);

         void PageRemove(const PageIterator& page_itr);

         void PageInsert(PageIterator& where, Page page);

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

         SDF::Obj GetAcroForm();

         FDF::FDFDoc FDFExtract();

         void FDFMerge(FDF::FDFDoc& fdf_doc);

         Action GetOpenAction();

         void SetOpenAction(const Action& action);

         void AddFileAttachment(const char* file_key, FileSpec embedded_file);

         PageLabel GetPageLabel(int page_num);

         void SetPageLabel(int page_num, PageLabel& label);

         void RemovePageLabel(int page_num);

         Struct::STree GetStructTree();

         bool HasOC() const;

         SDF::Obj GetOCGs() const;

         OCG::Config GetOCGConfig() const;

         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, UInt 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 ULong data_size, Filters::Filter filter_chain = Filters::Filter (0,false));
         SDF::Obj CreateIndirectRect(int x1,int y1,int x2,int y2);
         SDF::Obj CreateIndirectMatrix(Common::Matrix2D& mtx);


         SDF::SDFDoc& GetSDFDoc ();

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


         void Lock();

         void Unlock();

         bool IsLocked();


        TRN_PDFDoc mp_doc;
private:
        PDFDoc (const PDFDoc&);
        PDFDoc& operator= (const PDFDoc&);
};

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


#include <Impl/PDFDoc.inl>
#endif

---

© 2002-2008 PDFTron Systems Inc.