PdfDocument.h

// SPDX-FileCopyrightText: 2006 Dominik Seichter <domseichter@web.de>
// SPDX-FileCopyrightText: 2020 Francesco Pretto <ceztko@gmail.com>
// SPDX-License-Identifier: LGPL-2.0-or-later OR MPL-2.0
 
#ifndef PDF_DOCUMENT_H
#define PDF_DOCUMENT_H
 
#include "PdfTrailer.h"
#include "PdfCatalog.h"
#include "PdfIndirectObjectList.h"
#include "PdfAcroForm.h"
#include "PdfFontManager.h"
#include "PdfMetadata.h"
#include "PdfPageCollection.h"
#include "PdfNameTrees.h"
#include "PdfXObjectForm.h"
#include "PdfImage.h"
#include "PdfColorSpace.h"
#include "PdfPattern.h"
#include "PdfFunction.h"
#include "PdfInfo.h"
#include "PdfOutlines.h"
#include "PdfExtension.h"
 
namespace PoDoFo {
 
class PdfAction;
class PdfExtGState;
class PdfEncrypt;
class PdfDocument;
 
template <typename TField>
class PdfDocumentFieldIterableBase final
{
    friend class PdfDocument;
 
public:
    PdfDocumentFieldIterableBase()
        : m_doc(nullptr) { }
 
private:
    PdfDocumentFieldIterableBase(PdfDocument& doc)
        : m_doc(&doc) { }
 
public:
    class Iterator final
    {
        friend class PdfDocumentFieldIterableBase;
    public:
        using difference_type = void;
        using value_type = TField*;
        using pointer = void;
        using reference = void;
        using iterator_category = std::forward_iterator_tag;
    public:
        Iterator();
    private:
        Iterator(PdfDocument& doc);
    public:
        Iterator(const Iterator&) = default;
        Iterator& operator=(const Iterator&) = default;
        bool operator==(const Iterator& rhs) const;
        bool operator!=(const Iterator& rhs) const;
        Iterator& operator++();
        Iterator operator++(int);
        value_type operator*() { return m_Field; }
        value_type operator->() { return m_Field; }
    private:
        void increment();
        void stepIntoPageOrForm(PdfPageCollection& pages);
        bool stepIntoPageAnnot(PdfAnnotationCollection& annots);
        void stepIntoFormField(PdfAcroForm& form);
    private:
        PdfDocument* m_doc;
        unsigned m_pageIndex;
        PdfAnnotationCollection::iterator m_pageAnnotIterator;
        PdfAcroForm::iterator m_acroFormIterator;
        value_type m_Field;
        std::unordered_set<PdfReference> m_visitedObjs;
    };
 
public:
    Iterator begin() const;
    Iterator end() const;
 
private:
    PdfDocument* m_doc;
};
 
using PdfDocumentFieldIterable = PdfDocumentFieldIterableBase<PdfField>;
using PdfDocumentConstFieldIterable = PdfDocumentFieldIterableBase<const PdfField>;
 
class PODOFO_API PdfDocument
{
    friend class PdfMetadata;
    friend class PdfXObjectForm;
    friend class PdfPageCollection;
    friend class PdfMemDocument;
    friend class PdfStreamedDocument;
 
public:
    virtual ~PdfDocument();
 
    PdfOutlines& GetOrCreateOutlines();
 
    PdfNameTrees& GetOrCreateNames();
 
    PdfAcroForm& GetOrCreateAcroForm(PdfAcroFormDefaulAppearance eDefaultAppearance = PdfAcroFormDefaulAppearance::ArialBlack);
 
    void CollectGarbage(PdfGarbageCollectionFlags flags = PdfGarbageCollectionFlags::None);
 
    std::unique_ptr<PdfImage> CreateImage();
 
    std::unique_ptr<PdfXObjectForm> CreateXObjectForm(const Rect& rect);
 
    std::unique_ptr<PdfDestination> CreateDestination();
 
    std::unique_ptr<PdfColorSpace> CreateColorSpace(PdfColorSpaceFilterPtr filter);
 
    std::unique_ptr<PdfFunction> CreateFunction(PdfFunctionDefinitionPtr definition);
 
    std::unique_ptr<PdfUncolouredTilingPattern> CreateTilingPattern(std::shared_ptr<PdfUncolouredTilingPatternDefinition> definition);
 
    std::unique_ptr<PdfColouredTilingPattern> CreateTilingPattern(std::shared_ptr<PdfColouredTilingPatternDefinition> definition);
 
    std::unique_ptr<PdfShadingPattern> CreateShadingPattern(PdfShadingPatternDefinitionPtr definition);
 
    std::unique_ptr<PdfShadingDictionary> CreateShadingDictionary(PdfShadingDefinitionPtr definition);
 
    std::unique_ptr<PdfExtGState> CreateExtGState(PdfExtGStateDefinitionPtr definition);
 
    template <typename Taction>
    std::unique_ptr<Taction> CreateAction();
 
    std::unique_ptr<PdfAction> CreateAction(PdfActionType type);
 
    std::unique_ptr<PdfFileSpec> CreateFileSpec();
 
    bool IsPrintAllowed() const;
 
    bool IsEditAllowed() const;
 
    bool IsCopyAllowed() const;
 
    bool IsEditNotesAllowed() const;
 
    bool IsFillAndSignAllowed() const;
 
    bool IsAccessibilityAllowed() const;
 
    bool IsDocAssemblyAllowed() const;
 
    bool IsHighPrintAllowed() const;
 
    void PushPdfExtension(const PdfExtension& extension);
 
    bool HasPdfExtension(const std::string_view& ns, int64_t level) const;
 
    void RemovePdfExtension(const std::string_view& ns, int64_t level);
 
    std::vector<PdfExtension> GetPdfExtensions() const;
 
    PdfAcroForm& MustGetAcroForm();
 
    const PdfAcroForm& MustGetAcroForm() const;
 
    PdfNameTrees& MustGetNames();
 
    const PdfNameTrees& MustGetNames() const;
 
    PdfOutlines& MustGetOutlines();
 
    const PdfOutlines& MustGetOutlines() const;
 
    PdfDocumentFieldIterable GetFieldsIterator();
    PdfDocumentConstFieldIterable GetFieldsIterator() const;
 
    void Reset();
 
public:
    virtual bool HasOwnerPermissions() const = 0;
 
    virtual const PdfEncrypt* GetEncrypt() const = 0;
 
    bool IsEncrypted() const;
 
public:
    bool IsStrictParsing() const { return m_IsStrictParsing; }
 
    PdfCatalog& GetCatalog() { return *m_Catalog; }
 
    const PdfCatalog& GetCatalog() const { return *m_Catalog; }
 
    PdfPageCollection& GetPages() { return *m_Pages; }
 
    const PdfPageCollection& GetPages() const { return *m_Pages; }
 
    PdfTrailer &GetTrailer() { return *m_Trailer; }
 
    const PdfTrailer& GetTrailer() const { return *m_Trailer; }
 
    const PdfInfo* GetInfo() const;
 
    PdfMetadata& GetMetadata() { return m_Metadata; }
 
    const PdfMetadata& GetMetadata() const { return m_Metadata; }
 
    PdfIndirectObjectList& GetObjects() { return m_Objects; }
 
    const PdfIndirectObjectList& GetObjects() const { return m_Objects; }
 
    PdfAcroForm* GetAcroForm() { return m_AcroForm.get(); }
 
    const PdfAcroForm* GetAcroForm() const { return m_AcroForm.get(); }
 
    PdfNameTrees* GetNames() { return m_NameTrees.get(); }
 
    const PdfNameTrees* GetNames() const { return m_NameTrees.get(); }
 
    PdfOutlines* GetOutlines();
 
    const PdfOutlines* GetOutlines() const;
 
    PdfFontManager& GetFonts() { return m_FontManager; }
 
protected:
    void SetEntryPoints(std::unique_ptr<PdfObject>&& trailer, PdfObject& catalog);
 
    void SetStrictParsing(bool value);
 
    void Init();
 
    virtual void reset();
 
    void Clear();
 
    virtual void clear();
 
    virtual PdfVersion GetPdfVersion() const = 0;
 
    virtual void SetPdfVersion(PdfVersion version) = 0;
 
private:
    PdfDocument(bool empty = false);
 
    PdfDocument(const PdfDocument& doc);
 
    // Called by PdfPageCollection
    void AppendDocumentPages(const PdfDocument& doc);
    void InsertDocumentPageAt(unsigned atIndex, const PdfDocument& doc, unsigned pageIndex, std::unordered_map<PdfReference, PdfObject*>& map);
    void AppendDocumentPages(const PdfDocument& doc, unsigned pageIndex, unsigned pageCount, std::unordered_map<PdfReference, PdfObject*>& map);
 
    // Called by PdfXObjectForm
    Rect FillXObjectFromPage(PdfXObjectForm& xobj, const PdfPage& page, PdfFillFormFlags flags, std::unordered_map<PdfReference, PdfObject*>* map);
 
    PdfInfo& GetOrCreateInfo();
 
    void createAction(PdfActionType type, std::unique_ptr<PdfAction>& action);
 
private:
    void deletePages(unsigned atIndex, unsigned pageCount);
 
    void appendOutlineItems(PdfOutlineItem& destParent, const PdfOutlineItem* srcItem,
        const PdfIndirectObjectList& srcObjects, std::unordered_map<PdfReference, PdfObject*>& mappedObjects);
 
    void resetPrivate();
 
    void lazyLoadOutlines();
    void lazyLoadInfo();
 
private:
    PdfDocument& operator=(const PdfDocument&) = delete;
 
private:
    PdfIndirectObjectList m_Objects;
    PdfMetadata m_Metadata;
    PdfFontManager m_FontManager;
    bool m_IsStrictParsing;
    bool m_InfoLazyLoaded;
    bool m_OutlinesLazyLoaded;
    std::unique_ptr<PdfObject> m_TrailerObj;
    std::unique_ptr<PdfTrailer> m_Trailer;
    std::unique_ptr<PdfCatalog> m_Catalog;
    std::unique_ptr<PdfInfo> m_Info;
    std::unique_ptr<PdfPageCollection> m_Pages;
    std::unique_ptr<PdfAcroForm> m_AcroForm;
    std::unique_ptr<PdfOutlines> m_Outlines;
    std::unique_ptr<PdfNameTrees> m_NameTrees;
};
 
template<typename TAction>
std::unique_ptr<TAction> PdfDocument::CreateAction()
{
    std::unique_ptr<TAction> ret;
    createAction(PdfAction::GetActionType<TAction>(), reinterpret_cast<std::unique_ptr<PdfAction>&>(ret));
    return ret;
}
 
template<typename TField>
typename PdfDocumentFieldIterableBase<TField>::Iterator PdfDocumentFieldIterableBase<TField>::begin() const
{
    if (m_doc == nullptr)
        return Iterator();
    else
        return Iterator(*m_doc);
}
 
template<typename TField>
typename PdfDocumentFieldIterableBase<TField>::Iterator PdfDocumentFieldIterableBase<TField>::end() const
{
    return Iterator();
}
 
template<typename TField>
PdfDocumentFieldIterableBase<TField>::Iterator::Iterator()
    : m_doc(nullptr), m_pageIndex(0), m_Field(nullptr)
{
}
 
template<typename TField>
PdfDocumentFieldIterableBase<TField>::Iterator::Iterator(PdfDocument& doc)
    : m_doc(&doc), m_pageIndex(0), m_Field(nullptr)
{
    stepIntoPageOrForm(doc.GetPages());
}
 
template<typename TField>
bool PdfDocumentFieldIterableBase<TField>::Iterator::operator==(const Iterator& rhs) const
{
    if (m_doc == nullptr && rhs.m_doc == nullptr)
        return true;
 
    return m_doc == rhs.m_doc && m_pageIndex == rhs.m_pageIndex && m_pageAnnotIterator == rhs.m_pageAnnotIterator && m_acroFormIterator == rhs.m_acroFormIterator;
}
 
template<typename TField>
bool PdfDocumentFieldIterableBase<TField>::Iterator::operator!=(const Iterator& rhs) const
{
    if (m_doc == nullptr && rhs.m_doc == nullptr)
        return false;
 
    return m_doc != rhs.m_doc || m_pageIndex != rhs.m_pageIndex || m_pageAnnotIterator != rhs.m_pageAnnotIterator || m_acroFormIterator != rhs.m_acroFormIterator;
}
 
template<typename TField>
typename PdfDocumentFieldIterableBase<TField>::Iterator& PdfDocumentFieldIterableBase<TField>::Iterator::operator++()
{
    increment();
    return *this;
}
 
template<typename TField>
typename PdfDocumentFieldIterableBase<TField>::Iterator PdfDocumentFieldIterableBase<TField>::Iterator::operator++(int)
{
    auto copy = *this;
    increment();
    return copy;
}
 
template<typename TField>
void PdfDocumentFieldIterableBase<TField>::Iterator::increment()
{
    if (m_doc == nullptr)
        return;
 
    auto& pages = m_doc->GetPages();
    if (m_pageIndex < pages.GetCount())
    {
        m_pageAnnotIterator++;
        if (stepIntoPageAnnot(pages.GetPageAt(m_pageIndex).GetAnnotations()))
            return;
 
        m_pageIndex++;
        stepIntoPageOrForm(pages);
    }
    else
    {
        m_acroFormIterator++;
        stepIntoFormField(m_doc->MustGetAcroForm());
    }
}
 
// Update the iterator for the current page index, or switch to form iteration
template<typename TField>
void PdfDocumentFieldIterableBase<TField>::Iterator::stepIntoPageOrForm(PdfPageCollection& pages)
{
    while (true)
    {
        if (m_pageIndex >= pages.GetCount())
            break;
 
        auto& annots = pages.GetPageAt(m_pageIndex).GetAnnotations();
        m_pageAnnotIterator = annots.begin();
        if (stepIntoPageAnnot(annots))
            return;
 
        m_pageIndex++;
    }
 
    auto form = m_doc->GetAcroForm();
    if (form != nullptr)
    {
        m_acroFormIterator = form->begin();
        stepIntoFormField(*form);
        return;
    }
 
    // End of iteration
    m_doc = nullptr;
    m_Field = nullptr;
    m_visitedObjs.clear();
}
 
// Verify the current page annotation iterator. It updates the current field
// and returns true if a valid unvisited field is found, false otherwise
template<typename TField>
bool PdfDocumentFieldIterableBase<TField>::Iterator::stepIntoPageAnnot(PdfAnnotationCollection& annots)
{
    while (true)
    {
        if (m_pageAnnotIterator == annots.end())
            break;
 
        auto& annot = **m_pageAnnotIterator;
        PdfField* field = nullptr;
        if (annot.GetType() == PdfAnnotationType::Widget &&
            (field = &static_cast<PdfAnnotationWidget&>(annot).GetField(),
                m_visitedObjs.find(field->GetObject().GetIndirectReference()) == m_visitedObjs.end()))
        {
            m_Field = field;
            m_visitedObjs.insert(field->GetObject().GetIndirectReference());
            return true;
        }
 
        m_pageAnnotIterator++;
    }
 
    return false;
}
 
// Verify the current AcroForm field iterator. It updates the current field
// if a valid unvisited leaf field is found, or it ends the iteration otherwise
template<typename TField>
void PdfDocumentFieldIterableBase<TField>::Iterator::stepIntoFormField(PdfAcroForm& form)
{
    while (true)
    {
        if (m_acroFormIterator == form.end())
            break;
 
        auto& field = **m_acroFormIterator;
        if (field.GetChildren().GetCount() == 0
            && m_visitedObjs.find(field.GetObject().GetIndirectReference()) == m_visitedObjs.end())
        {
            m_Field = &field;
            m_visitedObjs.insert(field.GetObject().GetIndirectReference());
            return;
        }
 
        m_acroFormIterator++;
    }
 
    // End of iteration
    m_doc = nullptr;
    m_Field = nullptr;
    m_visitedObjs.clear();
}
 
};
 
 
#endif  // PDF_DOCUMENT_H