PdfPage.h

 
#ifndef PDF_PAGE_H
#define PDF_PAGE_H
 
#include "PdfDeclarations.h"
 
#include <podofo/auxiliary/Rect.h>
 
#include "PdfAnnotationCollection.h"
#include "PdfCanvas.h"
#include "PdfContents.h"
#include "PdfField.h"
#include "PdfResources.h"
 
namespace PoDoFo {
 
class PdfDocument;
class InputStream;
class PdfPage;
 
struct PODOFO_API PdfTextEntry final
{
    std::string Text;
    int Page = -1;
    double X = -1;
    double Y = -1;
    double Length = -1;
    nullable<Rect> BoundingBox;
};
 
struct PODOFO_API PdfTextExtractParams final
{
    nullable<Rect> ClipRect;
    PdfTextExtractFlags Flags = PdfTextExtractFlags::None;
};
 
template <typename TField>
class PdfPageFieldIterableBase final
{
    friend class PdfPage;
 
public:
    PdfPageFieldIterableBase()
        : m_page(nullptr) { }
 
private:
    PdfPageFieldIterableBase(PdfPage& page)
        : m_page(&page) { }
 
public:
    class Iterator final
    {
        friend class PdfPageFieldIterableBase;
    public:
        using difference_type = void;
        using value_type = TField*;
        using pointer = void;
        using reference = void;
        using iterator_category = std::forward_iterator_tag;
    public:
        Iterator()
            : m_Field(nullptr) { }
    private:
        void stepIntoPageAnnot();
 
        Iterator(PdfAnnotationCollection::iterator begin,
            PdfAnnotationCollection::iterator end)
            : m_annotsIterator(std::move(begin)), m_annotsEnd(std::move(end)), m_Field(nullptr)
        {
            stepIntoPageAnnot();
        }
 
    public:
        Iterator(const Iterator&) = default;
        Iterator& operator=(const Iterator&) = default;
        bool operator==(const Iterator& rhs) const
        {
            return m_annotsIterator == rhs.m_annotsIterator;
        }
        bool operator!=(const Iterator& rhs) const
        {
            return m_annotsIterator != rhs.m_annotsIterator;
        }
        Iterator& operator++()
        {
            m_annotsIterator++;
            stepIntoPageAnnot();
            return *this;
        }
        Iterator operator++(int)
        {
            auto copy = *this;
            m_annotsIterator++;
            stepIntoPageAnnot();
            return copy;
        }
        value_type operator*() { return m_Field; }
        value_type operator->() { return m_Field; }
    private:
        PdfAnnotationCollection::iterator m_annotsIterator;
        PdfAnnotationCollection::iterator m_annotsEnd;
        value_type m_Field;
        std::unordered_set<PdfReference> m_visitedObjs;
    };
 
public:
    Iterator begin() const;
    Iterator end() const;
 
private:
    PdfPage* m_page;
};
 
using PdfPageFieldIterable = PdfPageFieldIterableBase<PdfField>;
using PdfPageConstFieldIterable = PdfPageFieldIterableBase<const PdfField>;
 
class PODOFO_API PdfPage final : public PdfDictionaryElement, public PdfCanvas
{
    PODOFO_PRIVATE_FRIEND(class PdfPageTest);
    friend class PdfPageCollection;
    friend class PdfDocument;
 
private:
    PdfPage(PdfDocument& parent, const Rect& size);
 
    PdfPage(PdfObject& obj);
    PdfPage(PdfObject& obj, std::vector<PdfObject*>&& parents);
 
public:
    void ExtractTextTo(std::vector<PdfTextEntry>& entries,
        const PdfTextExtractParams& params) const;
 
    void ExtractTextTo(std::vector<PdfTextEntry>& entries,
        const std::string_view& pattern = { },
        const PdfTextExtractParams& params = { }) const;
 
    Rect GetRect() const;
 
    Rect GetRectRaw() const override;
 
    void SetRect(const Rect& rect);
 
    void SetRectRaw(const Rect& rect);
 
    bool HasRotation(double& teta) const override;
 
    void SetMediaBox(const Rect& rect, bool raw = false);
 
    void SetCropBox(const Rect& rect, bool raw = false);
 
    void SetTrimBox(const Rect& rect, bool raw = false);
 
    void SetBleedBox(const Rect& rect, bool raw = false);
 
    void SetArtBox(const Rect& rect, bool raw = false);
 
    unsigned GetPageNumber() const;
 
    static Rect CreateStandardPageSize(const PdfPageSize pageSize, bool landscape = false);
 
    Rect GetMediaBox(bool raw = false) const;
 
    Rect GetCropBox(bool raw = false) const;
 
    Rect GetTrimBox(bool raw = false) const;
 
    Rect GetBleedBox(bool raw = false) const;
 
    Rect GetArtBox(bool raw = false) const;
 
    unsigned GetRotation() const;
 
    double GetRotationRaw() const;
 
    void SetRotation(int rotation);
 
    bool MoveTo(unsigned index);
 
    template <typename TField>
    TField& CreateField(const std::string_view& name, const Rect& rect, bool rawRect = false);
 
    PdfField& CreateField(const std::string_view& name, PdfFieldType fieldType, const Rect& rect, bool rawRect = false);
 
    PdfPageFieldIterable GetFieldsIterator();
    PdfPageConstFieldIterable GetFieldsIterator() const;
 
public:
    unsigned GetIndex() const { return m_Index; }
    PdfContents& GetOrCreateContents();
    PdfResources& GetOrCreateResources() override;
    inline const PdfContents* GetContents() const { return m_Contents.get(); }
    inline PdfContents* GetContents() { return m_Contents.get(); }
    const PdfContents& MustGetContents() const;
    PdfContents& MustGetContents();
    inline const PdfResources* GetResources() const { return m_Resources.get(); }
    inline PdfResources* GetResources() { return m_Resources.get(); }
    const PdfResources& MustGetResources() const;
    PdfResources& MustGetResources();
    inline PdfAnnotationCollection& GetAnnotations() { return m_Annotations; }
    inline const PdfAnnotationCollection& GetAnnotations() const { return m_Annotations; }
 
private:
    // To be called by PdfPageCollection
    void FlattenStructure();
    void SetIndex(unsigned index) { m_Index = index; }
 
    void EnsureResourcesCreated() override;
 
    void CopyContentsTo(OutputStream& stream) const override;
 
    PdfObjectStream& GetOrCreateContentsStream(PdfStreamAppendFlags flags) override;
 
    PdfObjectStream& ResetContentsStream() override;
 
    PdfResources* getResources() override;
 
    PdfObject* getContentsObject() override;
 
    PdfDictionaryElement& getElement() override;
 
    PdfObject* findInheritableAttribute(const std::string_view& name) const;
 
    PdfObject* findInheritableAttribute(const std::string_view& name, bool& isShallow) const;
 
    void initNewPage(const Rect& size);
 
    void ensureContentsCreated();
    void ensureResourcesCreated();
 
    Rect getPageBox(const std::string_view& inBox, bool isInheritable, bool raw) const;
 
    void setPageBox(const PdfName& inBox, const Rect& rect, bool raw);
 
    void loadRotation();
 
private:
    PdfElement& GetElement() = delete;
    const PdfElement& GetElement() const = delete;
    PdfObject* GetContentsObject() = delete;
    const PdfObject* GetContentsObject() const = delete;
 
private:
    unsigned m_Index;
    std::vector<PdfObject*> m_parents;
    std::unique_ptr<PdfContents> m_Contents;
    std::unique_ptr<PdfResources> m_Resources;
    PdfAnnotationCollection m_Annotations;
    int m_Rotation;
};
 
template<typename TField>
TField& PdfPage::CreateField(const std::string_view& name, const Rect & rect, bool rawRect)
{
    return static_cast<TField&>(CreateField(name, PdfField::GetFieldType<TField>(), rect, rawRect));
}
 
template<typename TField>
typename PdfPageFieldIterableBase<TField>::Iterator PdfPageFieldIterableBase<TField>::begin() const
{
    if (m_page == nullptr)
        return Iterator();
    else
        return Iterator(m_page->GetAnnotations().begin(), m_page->GetAnnotations().end());
}
 
template<typename TField>
typename PdfPageFieldIterableBase<TField>::Iterator PdfPageFieldIterableBase<TField>::end() const
{
    if (m_page == nullptr)
        return Iterator();
    else
        return Iterator(m_page->GetAnnotations().end(), m_page->GetAnnotations().end());
}
 
template<typename TField>
void PdfPageFieldIterableBase<TField>::Iterator::stepIntoPageAnnot()
{
    while (true)
    {
        if (m_annotsIterator == m_annotsEnd)
            break;
 
        auto& annot = **m_annotsIterator;
        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;
        }
 
        m_annotsIterator++;
    }
 
    m_Field = nullptr;
    m_visitedObjs.clear();
}
 
};
 
#endif // PDF_PAGE_H