document.h

// Copyright (c) 2009-2025 Avanquest Software. All rights reserved.
 
#ifndef PDFSDK_CXX_PDF_DOCUMENT_H_INCLUDED_
#define PDFSDK_CXX_PDF_DOCUMENT_H_INCLUDED_
 
#include <cstdint>
#include <filesystem>
#include <memory>
#include <span>
#include <string>
#include <vector>
 
#include <pdfsdk/core/types.h>
#include <pdfsdk/cxx/bytes.h>
#include <pdfsdk/cxx/math.h>
#include <pdfsdk/cxx/progress_monitor.h>
 
#include "forward_declarations.h"
#include "standard_security.h"
#include "wrapper_base.h"
 
namespace PDF {

class Document : public detail::RefCountedHandle<PDDoc> {
public:
    static Document OpenDocument(const std::filesystem::path& path,
                                 const std::wstring& password = std::wstring());

    static Document OpenDocumentFromMemory(std::span<const Byte> data,
                                           bool copy = false,
                                           const std::wstring& password = std::wstring());

    static Document OpenDocumentFromStream(std::shared_ptr<IDataSource> source,
                                           const std::wstring& password = std::wstring());

    static Document NewDocument(const RectF& mediaBox = RectF(0.0f, 792.0f, 612.0f, 0.0f));

    bool IsCompressed() const;

    bool IsModified() const;

    void SetModified(bool modified);

    bool IsRepaired() const;

    std::filesystem::path GetFilePath() const;

    uint64_t GetFileSize() const;

    PDVersion GetFileVersion() const;

    void Save(const std::filesystem::path& path,
              PDDocSaveFlags flags = kPDDocSaveFull | kPDDocSaveCompressed,
              ProgressMonitor* progmon = nullptr,
              const PDOptSaveSettings* optSettings = nullptr,
              const PDVersion* version = nullptr);

    void SaveToStream(IWriteSink& sink,
                      PDDocSaveFlags flags = kPDDocSaveFull | kPDDocSaveCompressed,
                      ProgressMonitor* progmon = nullptr,
                      const PDOptSaveSettings* optSettings = nullptr,
                      const PDVersion* version = nullptr);

    size_t GetNumPages() const;

    Page GetPage(size_t index) const;

    Page CreatePage(size_t insertAt, const RectF& mediaBox);

    void CreatePages(size_t insertAt, size_t count, const RectF& mediaBox);

    void DeletePages(const std::vector<size_t>& pageIndexes, ProgressMonitor* mon = nullptr);

    void DeletePage(size_t index);

    void InsertPages(size_t insertAt, const Document& sourceDoc, const std::vector<size_t>& sourcePageIndexes = {}, ProgressMonitor* mon = nullptr);

    void InsertPage(const Page& page, size_t insertAt);

    void MovePages(size_t insertAt, const std::vector<size_t>& pageIndexes, ProgressMonitor* mon = nullptr);

    std::wstring GetInfoString(PDAtom infoDictKey) const;

    void SetInfoString(PDAtom infoDictKey, const std::wstring& infoValue);

    std::string GetXmpMetadata() const;

    void SetXmpMetadata(const std::string& xmpPacket);

    PDFAFlavor GetPDFAFlavor() const;

    PDDateTime GetCreationDate() const;

    void SetCreationDate(const PDDateTime& date);

    PDDateTime GetModDate() const;

    void SetModDate(const PDDateTime& date);

    void SetPageLayout(PDAtom layout);

    PDAtom GetPageLayout() const;

    void SetPageMode(PDAtom mode);

    PDAtom GetPageMode() const;

    void SetPageDirection(PDPageDirection direction);

    PDPageDirection GetPageDirection() const;

    XObject CreateFormXObject(const Content& content);

    Pattern CreatePatternTiling(PDETilingPatternPaintType paintType,
                                PDETilingPatternTilingType tilingType,
                                const RectF& bbox,
                                float xStep,
                                float yStep,
                                const Content& content);

    Pattern CreatePatternShading(const Shading& shading);

    Font CreateFontFromInfo(const PDFontInfo& fontInfo, bool forceSysFont = true, PDEFontCreateFlags createFlags = kPDEFontCreateFlagsDefault);

    Font CreateFontEmbeddedCopy(const Font& font, PDEFontCreateFlags createFlags = kPDEFontCreateFlagsDefault);

    Font ConvertFontToType0(const Font& font, PDEFontCreateFlags createFlags = kPDEFontCreateFlagsDefault);

    template<class EnumProc>
    void EnumFonts(EnumProc enumProc, ProgressMonitor* mon = nullptr) const;

    size_t GetNumFormFields() const;

    FormField GetFormField(size_t index) const;

    void AddFormField(FormField field);

    void RemoveFormField(FormField field);

    FormField CreateFormField(const std::wstring& fullname, PDAtom type, PDFieldFlags flags);

    FormField FindFormField(const std::wstring& fullname) const;

    void RenameFormField(FormField field, const std::wstring& fullname);

    void ExportFormFDF(const std::filesystem::path& path,
                       std::span<const FormField> fields = std::span<const FormField>(),
                       bool exclude = true);

    std::vector<Byte> ExportFormFDFToMemory(std::span<const FormField> fields = std::span<const FormField>(),
                                            bool exclude = true);

    void ExportFormFDFToStream(IWriteSink& sink,
                               std::span<const FormField> fields = std::span<const FormField>(),
                               bool exclude = true);

    void ImportFormFDF(const std::filesystem::path& path);

    void ImportFormFDFFromMemory(std::span<const Byte> data);

    void ImportFormFDFFromStream(IDataSource& source);

    void ExportFormXFDF(const std::filesystem::path& path,
                        std::span<const FormField> fields = std::span<const FormField>(),
                        bool exclude = true);

    std::vector<Byte> ExportFormXFDFToMemory(std::span<const FormField> fields = std::span<const FormField>(),
                                             bool exclude = true);

    void ExportFormXFDFToStream(IWriteSink& sink,
                                std::span<const FormField> fields = std::span<const FormField>(),
                                bool exclude = true);

    void ImportFormXFDF(const std::filesystem::path& path);

    void ImportFormXFDFFromMemory(std::span<const Byte> data);

    void ImportFormXFDFFromStream(IDataSource& source);

    Object CreateActionFieldsData(std::span<const FormField> fields);

    void ResetForm(std::span<const FormField> fields = std::span<const FormField>(),
                   PDResetFormFlags flags = kPDResetFormFlagExclude);

    bool IsSigned() const;

    void SaveSignedVersion(FormField sigField, const std::filesystem::path& path) const;

    Action CreateActionURI(const std::string& uri);

    Action CreateActionGoTo(Dest dest);

    Action CreateActionGoToR(const FileSpec& fileSpec, size_t pageIndex);

    Action CreateActionJavaScript(const std::wstring& jscode);

    Action CreateActionSubmitForm(const std::string& serverUri);

    Action CreateActionResetForm();

    Action CreateActionHide();

    Action CreateActionNamed(PDAtom name);

    void SetOpenAction(Action action);

    Action GetOpenAction() const;

    Dest CreateDestXYZ(size_t pageIndex, const PointF& xy, float zoom, bool isRemote = false);

    Dest CreateDestFit(size_t pageIndex, bool isRemote = false);

    Dest CreateDestFitH(size_t pageIndex, float top, bool isRemote = false);

    Dest CreateDestFitV(size_t pageIndex, float left, bool isRemote = false);

    Dest CreateDestFitR(size_t pageIndex, const RectF& rect, bool isRemote = false);

    Dest CreateDestFitB(size_t pageIndex, bool isRemote = false);

    Dest CreateDestFitBH(size_t pageIndex, float top, bool isRemote = false);

    Dest CreateDestFitBV(size_t pageIndex, float left, bool isRemote = false);

    void SetOpenDestination(Dest dest);

    Dest GetOpenDestination() const;

    template<class EnumProc>
    void EnumDocLevelJSActions(EnumProc enumProc) const;

    Action GetDocLevelJSAction(std::string_view name) const;

    void RemoveDocLevelJS();

    FileSpec GetAttachment(std::string_view name) const;

    template<class EnumProc>
    void EnumAttachments(EnumProc enumProc) const;

    void AddAttachment(std::string_view name, FileSpec filespec);

    void RemoveAttachment(std::string_view name);

    size_t GetNumAttachments() const;

    std::string GetAttachmentNameByIndex(size_t index) const;

    FileSpec CreateFileSpec(PDAtom fileSys, const std::wstring& path);

    FileSpec CreateEmbeddedFile(const std::wstring& path);

    size_t GetNumOutputIntents() const;

    OutputIntent GetOutputIntent(size_t index) const;

    void AddOutputIntent(const OutputIntent& oi);

    void RemoveOutputIntent(const OutputIntent& oi);

    Bookmark GetRootBookmark() const;

    Bookmark CreateRootBookmark();

    OCConfig GetOCConfig() const;

    void SetOCConfig(const OCConfig& config);

    size_t GetNumOCAltConfigs() const;

    OCConfig GetOCAltConfig(size_t index) const;

    OCGroup CreateOCGroup(const std::wstring& name);

    size_t GetNumOCGroups() const;

    OCGroup GetOCGroup(size_t index) const;

    StructTreeRoot GetStructTree() const;

    StructTreeRoot CreateStructTree();

    void RemoveStructTree();

    Annot CreateTextAnnot(const RectF& rect);

    Annot CreateLinkAnnot(const RectF& rect, Action action);

    Annot CreateTextMarkupAnnot(PDAtom type, PDColorValue color, const QuadPoints& quads);

    Annot CreateInkAnnot(PDColorValue color, float lineWidth, const std::vector<std::vector<PointF>>& points);

    Annot CreateFreeTextAnnot(const RectF& rect);

    Annot CreateStampAnnot(const RectF& rect, const XObject& appearance);

    Annot CreateWidgetAnnot(const FormField& field, const RectF& rect);

    Annot CreateFileAttachmentAnnot(const FileSpec& fileSpec, const RectF& rect);

    Annot CreatePopupAnnot(const RectF& rect);

    Object GetObjectByID(uint32_t id) const;

    Object GetRootObject() const;

    Object GetInfoObject() const;

    Object CreateBoolObject(bool value, bool indirect = false);

    Object CreateIntObject(int64_t value, bool indirect = false);

    Object CreateRealObject(float value, bool indirect = false);

    Object CreateStringObjectUnicode(const std::wstring& unicode, bool indirect = false);

    Object CreateStringObject(const std::string& bytes, bool hex = false, bool indirect = false);

    Object CreateNameObject(PDAtom value, bool indirect = false);

    Object CreateArrayObject(bool indirect);

    Object CreateDictObject(bool indirect);

    Object CreateStreamObject(std::span<const Byte> data, const Object& attributesDict, const Object& encodeParms, bool encodeSource);

    Object CopyObject(const Object& source);

    ReadStream OpenXfaStream() const;

    StdSecurityParams GetStandardSecurityParams() const;

    void SetStandardSecurityParams(const StdSecurityParams& requestedParams);

    void RemoveSecurity();

    bool IsEncrypted() const;

    bool RequestPermission(PDPermReqObj object, PDPermReqOp operation, const std::wstring& password = std::wstring()) const;

    XObject ImportIcon(const Document& source, size_t pageIndex = 0);

    void CreatePageFromIcon(size_t insertAt, const Document& iconDoc, const XObject& icon);

    bool IsTaggedPDF() const;
 
    PDF_CXX_CORE_WRAPPER_DEFINE_MEMBERS_(Document, PDDoc)
};
 
}  // namespace PDF
 
#include "document_impl.inl"
 
#endif  // PDFSDK_CXX_PDF_DOCUMENT_H_INCLUDED_