PdfAcroForm.h

 
#ifndef PDF_ACRO_FORM_H
#define PDF_ACRO_FORM_H
 
#include "PdfField.h"
 
namespace PoDoFo {
 
class PdfDocument;
 
enum class PdfAcroFormDefaulAppearance : uint8_t
{
    None = 0, 
    ArialBlack 
};
 
enum class PdfAcroFormSigFlags
{
    None = 0,
    SignaturesExist = 1,
    AppendOnly = 2,
};
 
class PODOFO_API PdfAcroForm final : public PdfDictionaryElement
{
    friend class PdfField;
    friend class PdfDocument;
    friend class PdfSigningContext;
    friend class PdfSignature;
 
private:
    PdfAcroForm(PdfDocument & doc,
                 PdfAcroFormDefaulAppearance defaultAppearance = PdfAcroFormDefaulAppearance::ArialBlack);
 
    PdfAcroForm(PdfObject& obj);
 
public:
    void SetNeedAppearances(bool needAppearances);
 
    bool GetNeedAppearances() const;
 
    PdfAcroFormSigFlags GetSigFlags() const;
 
    template <typename TField>
    TField& CreateField(const std::string_view& name);
 
    PdfField& CreateField(const std::string_view& name, PdfFieldType fieldType);
 
    PdfField& GetFieldAt(unsigned index);
 
    const PdfField& GetFieldAt(unsigned index) const;
 
    PdfField& GetField(const PdfReference& ref);
 
    const PdfField& GetField(const PdfReference& ref) const;
 
    void RemoveFieldAt(unsigned index);
 
    void RemoveField(const PdfReference& ref);
 
    unsigned GetFieldCount() const;
 
public:
    using FieldList = std::vector<std::shared_ptr<PdfField>>;
 
    template <typename TObject, typename TListIterator>
    class Iterator final
    {
        friend class PdfAcroForm;
    public:
        using difference_type = void;
        using value_type = TObject*;
        using pointer = void;
        using reference = void;
        using iterator_category = std::forward_iterator_tag;
    public:
        Iterator() { }
    private:
        Iterator(const TListIterator& iterator) : m_iterator(iterator) { }
    public:
        Iterator(const Iterator&) = default;
        Iterator& operator=(const Iterator&) = default;
        bool operator==(const Iterator& rhs) const
        {
            return m_iterator == rhs.m_iterator;
        }
        bool operator!=(const Iterator& rhs) const
        {
            return m_iterator != rhs.m_iterator;
        }
        Iterator& operator++()
        {
            m_iterator++;
            return *this;
        }
        Iterator operator++(int)
        {
            auto copy = *this;
            m_iterator++;
            return copy;
        }
        value_type operator*()
        {
            return (*m_iterator).get();
        }
        value_type operator->()
        {
            return (*m_iterator).get();
        }
    private:
        TListIterator m_iterator;
    };
 
    using iterator = Iterator<PdfField, FieldList::iterator>;
    using const_iterator = Iterator<const PdfField, FieldList::const_iterator>;
 
public:
    iterator begin();
    iterator end();
    const_iterator begin() const;
    const_iterator end() const;
 
private:
    // To be called by PdfField
    PdfField& CreateField(PdfObject& obj, PdfFieldType type);
    PdfField& AddField(std::unique_ptr<PdfField>&& field);
    std::shared_ptr<PdfField> GetFieldPtr(const PdfReference& ref);
 
    // To be called by PdfSignature/PdfSigningContext
    void SetSigFlags(PdfAcroFormSigFlags flags);
 
private:
    void init(PdfAcroFormDefaulAppearance defaultAppearance);
 
    PdfArray* getFieldArray() const;
 
    void initFields();
 
    PdfField& getField(unsigned index) const;
    PdfField& getField(const PdfReference& ref) const;
 
    void fixIndices(unsigned index);
 
private:
    using FieldMap = std::map<PdfReference, unsigned>;
 
private:
    FieldList m_Fields;
    std::unique_ptr<FieldMap> m_fieldMap;
    PdfArray* m_fieldArray;
};
 
template<typename TField>
TField& PdfAcroForm::CreateField(const std::string_view& name)
{
    return static_cast<TField&>(CreateField(name, PdfField::GetFieldType<TField>()));
}
 
};
 
ENABLE_BITMASK_OPERATORS(PoDoFo::PdfAcroFormSigFlags);
 
#endif // PDF_ACRO_FORM_H