pdfobjects.h

Go to the documentation of this file.

/*
 * Copyright (C) 2019-2025 Global Graphics Software Ltd. All rights reserved.
 */
 
#ifndef JAWSMAKO_PDFOBJECTS_H
#define JAWSMAKO_PDFOBJECTS_H

 
#include <jawsmako/types.h>
#include <jawsmako/hashable.h>
 
namespace JawsMako
{
    using namespace EDL;

    typedef enum
    {
        ePOTInteger      = 0,  
        ePOTBoolean      = 1,  
        ePOTReal         = 2,  
        ePOTString       = 3,  
        ePOTName         = 4,  
        ePOTArray        = 5,  
        ePOTDictionary   = 6,  
        ePOTNull         = 7,  
        ePOTReference    = 8,  
        ePOTFarReference = 9,  
        ePOTStream       = 10, 
        ePOTOperator     = 11, 
        ePOTLargeInteger = 12  
    } ePDFObjectType;

    class IPDFObject : public IRCObject, public IHashable
    {
      public:

        virtual ePDFObjectType getType() const = 0;

        virtual IPDFObjectPtr clone() const = 0;

        virtual IPDFObjectPtr deepClone() const = 0;

        virtual bool getIsExecutable() const = 0;

        virtual bool containsReferences() const = 0;

        virtual void emitPostScriptCode(const IOutputStreamPtr &dest) const = 0;
 
        //
        // Convenience functions
        //
 
#ifdef SWIG
        %apply double &OUTPUT { double &number };
#endif
        virtual bool getNumber(double &number) const = 0;
#ifdef SWIG
        %clear double &number;
#endif
 
#ifdef SWIG
        %apply float &OUTPUT { float &number };
#endif
        virtual bool getNumber(float &number) const = 0;
#ifdef SWIG
        %apply int32_t &OUTPUT { int32 &number };
#endif
 
#ifdef SWIG
        %apply int32_t &OUTPUT { int32 &number };
#endif
        virtual bool getNumber(int32 &number) const = 0;
#ifdef SWIG
        %clear int32 &number;
#endif

        static JAWSMAKO_API IPDFObjectPtr createNumber(double number);

        virtual bool getString(RawString &string) const = 0;
    };
    #define obj2IPDFObject(obj) JawsMako::IPDFObjectPtr(dynamic_cast<JawsMako::IPDFObject *>((IRCObject *) (obj)), true)
 
    // A useful templated utility for faster casting between object types
    // with checking, but without requiring dynamic casting.
    template <typename T>
    CSmartPtr<T> pdfObj2Type(const IPDFObjectPtr &object, ePDFObjectType type)
    {
        if (!object || object->getType() != type)
        {
            return CSmartPtr<T> ();
        }
        return CSmartPtr<T>(static_cast<T *>((IPDFObject *) object), true);
    }

    class IPDFInteger : public IPDFObject
    {
      public:
        virtual ~IPDFInteger() {}

        static JAWSMAKO_API IPDFIntegerPtr create(int32 integer);

        virtual int32 getValue() const = 0;
    };
    #define pdfObj2IPDFInteger(obj) JawsMako::pdfObj2Type<JawsMako::IPDFInteger>(obj, JawsMako::ePOTInteger)
    #define obj2IPDFInteger(obj) JawsMako::IPDFIntegerPtr(dynamic_cast<JawsMako::IPDFInteger *>((IRCObject *) (obj)), true)

    class IPDFBoolean : public IPDFObject
    {
      public:
        virtual ~IPDFBoolean() {}

        static JAWSMAKO_API IPDFBooleanPtr create(bool boolean);

        virtual bool getValue() const = 0;
    };
    #define pdfObj2IPDFBoolean(obj) JawsMako::pdfObj2Type<JawsMako::IPDFBoolean>(obj, JawsMako::ePOTBoolean)
    #define obj2IPDFBoolean(obj) JawsMako::IPDFBooleanPtr(dynamic_cast<JawsMako::IPDFBoolean *>((IRCObject *) (obj)), true)
 

    class IPDFReal : public IPDFObject
    {
      public:
        virtual ~IPDFReal() {}

        static JAWSMAKO_API IPDFRealPtr create(double real);

        virtual double getValue() const = 0;
    };
    #define pdfObj2IPDFReal(obj) JawsMako::pdfObj2Type<JawsMako::IPDFReal>(obj, JawsMako::ePOTReal)
    #define obj2IPDFReal(obj) JawsMako::IPDFRealPtr(dynamic_cast<JawsMako::IPDFReal *>((IRCObject *) (obj)), true)

    class IPDFNull : public IPDFObject
    {
      public:
        virtual ~IPDFNull() {}

        static JAWSMAKO_API IPDFNullPtr create();
    };
    #define pdfObj2IPDFNull(obj) JawsMako::pdfObj2Type<JawsMako::IPDFNull>(obj, JawsMako::ePOTNull)
    #define obj2IPDFNull(obj) JawsMako::IPDFNullPtr(dynamic_cast<JawsMako::IPDFNull *>((IRCObject *) (obj)), true)

    class IPDFString : public IPDFObject
    {
      public:
        virtual ~IPDFString() {}

        static JAWSMAKO_API IPDFStringPtr create(const RawString &string, bool executable = false, bool pdf2 = false);

        static JAWSMAKO_API IPDFStringPtr createText(const U8String &string, bool executable = false, bool pdf2 = false);

        static JAWSMAKO_API IPDFStringPtr create(const IInputStreamPtr &stream, bool executable = false, bool pdf2 = false, int64 startOffset = 0);

        virtual bool isUtf8Encoded() = 0;

        virtual const RawString &getValue() const = 0;

        virtual U8String getTextValue() const = 0;
    };
    #define pdfObj2IPDFString(obj) JawsMako::pdfObj2Type<JawsMako::IPDFString>(obj, JawsMako::ePOTString)
    #define obj2IPDFString(obj) JawsMako::IPDFStringPtr(dynamic_cast<JawsMako::IPDFString *>((IRCObject *) (obj)), true)

    class IPDFName : public IPDFObject
    {
      public:
        virtual ~IPDFName() {}

        static JAWSMAKO_API IPDFNamePtr create(IEDLClassFactory *pFactory, const RawString &name);

        static JAWSMAKO_API IPDFNamePtr create(const RawString &name, bool executable = false);

        virtual bool isValidUtf8() const = 0;

        virtual const RawString &getValue() const = 0;
    };
    #define pdfObj2IPDFName(obj) JawsMako::pdfObj2Type<JawsMako::IPDFName>(obj, JawsMako::ePOTName)
    #define obj2IPDFName(obj) JawsMako::IPDFNamePtr(dynamic_cast<JawsMako::IPDFName *>((IRCObject *) (obj)), true)

    class CPDFReference
    {
    public:
        CPDFReference()
        {
            m_objectNum = -1;
            m_generation = -1;
        }

        CPDFReference(int32 objectNum, int32 generation)
        {
            m_objectNum = objectNum;
            m_generation = generation;
        }

        int32 getObjectNum() const
        {
            return m_objectNum;
        }

        int32 getGeneration() const
        {
            return m_generation;
        }
 
        // For use in maps and other containers.
        bool operator==(const CPDFReference& other) const
        {
            return ((m_objectNum == other.m_objectNum) && (m_generation == other.m_generation));
        }
        bool operator<(const CPDFReference& other) const
        {
            if (m_objectNum < other.m_objectNum)
                return true;
            else if (m_objectNum > other.m_objectNum)
                return false;
            else if (m_generation < other.m_generation)
                return true;
            else
                return false;
        }
      private:
        int32 m_objectNum;
        int32 m_generation;
    };

    class IPDFReference : public IPDFObject
    {
      public:
        virtual ~IPDFReference() {}

        static JAWSMAKO_API IPDFReferencePtr create(const CPDFReference &reference);

        static JAWSMAKO_API IPDFReferencePtr create(int32 objectNum, int32 generation)
        {
            return create(CPDFReference(objectNum, generation));
        }

        virtual const CPDFReference &getValue() const = 0;

        int32 getObjectNum() const
        {
            return getValue().getObjectNum();
        }

        int32 getGeneration() const
        {
            return getValue().getGeneration();
        }
    };
    #define pdfObj2IPDFReference(obj) JawsMako::pdfObj2Type<IPDFReference>(obj, JawsMako::ePOTReference)
    #define obj2IPDFReference(obj) JawsMako::IPDFReferencePtr(dynamic_cast<JawsMako::IPDFReference *>((IRCObject *) (obj)), true)

    class CPDFFarReference
    {
      public:
        CPDFFarReference()
        {
            m_docId = INVALID_DOM_ID;
            m_allocatorId = INVALID_DOM_ID;
            m_objectNum = -1;
            m_generation = -1;
        }

        CPDFFarReference(DOMid docId, DOMid allocatorId, int32 objectNum, int32 generation)
        {
            m_docId = docId;
            m_allocatorId = allocatorId;
            m_objectNum = objectNum;
            m_generation = generation;
        }
 
        // For use in maps and other containers
        bool operator==(const CPDFFarReference &other) const
        {
            return (m_docId ==       other.m_docId &&
                   m_allocatorId == other.m_allocatorId &&
                   m_objectNum ==   other.m_objectNum &&
                   m_generation ==  other.m_generation);
        }
 
        bool operator!=(const CPDFFarReference &other) const
        {
            return !(other == *this);
        }
 
        bool operator<(const CPDFFarReference &other) const
        {
            if (m_docId < other.m_docId)
                return true;
            else if (m_docId > other.m_docId)
                return false;
            else if (m_allocatorId < other.m_allocatorId)
                return true;
            else if (m_allocatorId > other.m_allocatorId)
                return false;
            else if (m_objectNum < other.m_objectNum)
                return true;
            else if (m_objectNum > other.m_objectNum)
                return false;
            else if (m_generation < other.m_generation)
                return true;
            else
                return false;
        }

        DOMid getDocumentId() const
        {
            return m_docId;
        }

        DOMid getAllocatorId() const
        {
            return m_allocatorId;
        }

        int32 getObjectNum() const
        {
            return m_objectNum;
        }

        int32 getGeneration() const
        {
            return m_generation;
        }
 
      private:
        DOMid m_docId;
        DOMid m_allocatorId;
        int32 m_objectNum;
        int32 m_generation;
    };

    class IPDFFarReference : public IPDFObject
    {
      public:
        virtual ~IPDFFarReference() {}

        static JAWSMAKO_API IPDFFarReferencePtr create(const CPDFFarReference &reference);

        virtual const CPDFFarReference &getValue() const = 0;
    };
    #define pdfObj2IPDFFarReference(obj) pdfObj2Type<JawsMako::IPDFFarReference>(obj, JawsMako::ePOTFarReference)
    #define obj2IPDFFarReference(obj) JawsMako::IPDFFarReferencePtr(dynamic_cast<JawsMako::IPDFFarReference *>((IRCObject *) (obj)), true)

    class IPDFArray : public IPDFObject
    {
      public:
        virtual ~IPDFArray() {}

        static JAWSMAKO_API IPDFArrayPtr create(uint32 size = 0, bool executable = false);

        static JAWSMAKO_API IPDFArrayPtr create(const CPDFObjectVect &objects, bool executable = false);

        static JAWSMAKO_API IPDFArrayPtr createFromNumbers(const CDoubleVect &numbers);

        static JAWSMAKO_API IPDFArrayPtr createFromFloatNumbers(const CFloatVect &numbers);
 
#ifdef SWIG
#if SWIGJAVA
        %apply double [] { const double *numbers };
#endif
#if SWIGCSHARP
        %apply double INPUT[] { const double *numbers };
#endif
#endif
        static JAWSMAKO_API IPDFArrayPtr createFromNumbersArray(const double *numbers, uint32 numNumbers);
#ifdef SWIG
        %clear const double *numbers;
#endif

        static JAWSMAKO_API IPDFArrayPtr createFromNames(IEDLClassFactory *pFactory, const CRawStringVect &nameStrings);

        static JAWSMAKO_API IPDFArrayPtr createFromFBox(const FBox &box);

        virtual uint32 getSize() const = 0;

        virtual IPDFObjectPtr get(uint32 index) const = 0;

        virtual ePDFObjectType getTypeAtIndex(uint32 index) const = 0;

        virtual void put(uint32 index, const IPDFObjectPtr &value) = 0;

        virtual void insert(uint32 index, const IPDFObjectPtr &value) = 0;

        virtual void remove(uint32 index) = 0;

        virtual void append(const IPDFObjectPtr &value) = 0;

        virtual void copy(uint32 destIndex, const IPDFArrayPtr &sourceArray, uint32 sourceIndex) = 0;

        virtual bool getNumbers(CDoubleVect &numbers) = 0;

        virtual bool getBox(FBox &box) = 0;

        virtual int32 getInteger(uint32 index) const = 0;

        virtual bool containsCompositeObject(const IPDFObjectPtr &object) const = 0;
    };
    #define pdfObj2IPDFArray(obj) JawsMako::pdfObj2Type<JawsMako::IPDFArray>(obj, JawsMako::ePOTArray)
    #define obj2IPDFArray(obj) JawsMako::IPDFArrayPtr(dynamic_cast<JawsMako::IPDFArray *>((IRCObject *) (obj)), true)

    class IPDFDictionary : public IPDFObject
    {
      public:
        virtual ~IPDFDictionary() {}

        static JAWSMAKO_API IPDFDictionaryPtr create(IEDLClassFactory *pFactory, uint32 size = 0);

        virtual uint32 getSize() const = 0;

        virtual IPDFNamePtr getKeyAtIndex(uint32 index) const = 0;

        virtual IPDFObjectPtr getValueAtIndex(uint32 index) const = 0;

        virtual ePDFObjectType getValueTypeAtIndex(uint32 index) const = 0;

        virtual IPDFObjectPtr get(const char *key) const = 0;

        virtual IPDFObjectPtr get(const RawString &key) const = 0;

        virtual IPDFObjectPtr get(const IPDFNamePtr &key) const = 0;

        virtual void put(const char *key, const IPDFObjectPtr &value) = 0;

        virtual void put(const RawString &key, const IPDFObjectPtr &value) = 0;

        virtual void put(const IPDFNamePtr &key, const IPDFObjectPtr &value) = 0;

        virtual void undefine(const char *key) = 0;

        virtual void undefine(const RawString &key) = 0;

        virtual void undefine(const IPDFNamePtr &key) = 0;

        virtual void copy(const IPDFDictionaryPtr &sourceDict, uint32 sourceIndex) = 0;

        virtual void putInteger(const IPDFNamePtr &key, int32 integer) = 0;

        virtual void putInteger(const RawString &key, int32 integer) = 0;

        virtual void putReal(const IPDFNamePtr &key, double real) = 0;
        
        virtual void putReal(const RawString &key, double real) = 0;

        virtual bool containsCompositeObject(const IPDFObjectPtr &object) const = 0;

        class Iterator
        {
          public:
            Iterator(const IPDFDictionaryPtr &dict, bool begin)
            {
                if (!dict)
                {
                    throwEDLError(EDL_ERR_BAD_ARGUMENTS);
                }
                m_index = 0;
                m_limit = dict->getSize();
                m_dict = dict;
 
                if (begin)
                {
                    if (m_limit > 0 && dict->getKeyAtIndex(0) == NULL)
                    {
                        // First index is an empty slot - skip it
                        increment();
                    }
                }
                else
                {
                    m_index = m_limit;
                }
            }
 
            Iterator(const Iterator &other)
            {
                assign(other);
            }
 
            Iterator()
            {
                m_index = 0;
                m_limit = 0;
                m_dict  = NULL;
            }
 
            const Iterator &operator=(const Iterator &other)
            {
                assign(other);
                return *this;
            }
 
            Iterator &operator++()
            {
                increment();
                return *this;
            }
            Iterator operator++(int)
            {
                Iterator i = *this;
                increment();
                return i;
            }
            bool operator==(const Iterator &other) const
            {
                return (m_index == other.m_index &&
                        m_dict == other.m_dict);
            }
            bool operator!=(const Iterator &other) const
            {
                return (m_index != other.m_index ||
                        m_dict != other.m_dict);
            }

            uint32 getIndex() const
            {
                if (!m_dict)
                {
                    throwEDLError(EDL_ERR_UNDEFINED);
                }
                return m_index;
            }

            IPDFNamePtr getKey() const
            {
                if (!m_dict)
                {
                    throwEDLError(EDL_ERR_UNDEFINED);
                }
                if (m_index == m_limit)
                {
                    throwEDLError(JM_ERR_RANGE_ERROR);
                }
                IPDFNamePtr key = m_dict->getKeyAtIndex(m_index);
                if (!key)
                {
                    throwEDLError(JM_ERR_RANGE_ERROR);
                }
                return key;
            }

            IPDFObjectPtr getValue() const
            {
                if (!m_dict)
                {
                    throwEDLError(EDL_ERR_UNDEFINED);
                }
                if (m_index == m_limit)
                {
                    throwEDLError(JM_ERR_RANGE_ERROR);
                }
                return m_dict->getValueAtIndex(m_index);
            }

            ePDFObjectType getValueType() const
            {
                if (!m_dict)
                {
                    throwEDLError(EDL_ERR_UNDEFINED);
                }
                if (m_index == m_limit)
                {
                    throwEDLError(JM_ERR_RANGE_ERROR);
                }
                return m_dict->getValueTypeAtIndex(m_index);
            }
          private:
            void assign(const Iterator &other)
            {
                m_dict = other.m_dict;
                m_index = other.m_index;
                m_limit = other.m_limit;
            }
            void increment()
            {
                if (m_index == m_limit)
                {
                    throwEDLError(JM_ERR_RANGE_ERROR);
                }
                do
                {
                    m_index++;
                }
                while (m_index < m_limit && m_dict->getKeyAtIndex(m_index) == NULL);
            }
 
            uint32            m_index;
            uint32            m_limit;
            IPDFDictionaryPtr m_dict;
        };

        virtual Iterator begin() = 0;

        virtual Iterator end() = 0;
    };
 
    static IPDFDictionaryPtr pdfObj2IPDFDictionary(const IPDFObjectPtr &object)
    {
        if (!object || (object->getType() != ePOTDictionary && object->getType() != ePOTStream))
        {
            return IPDFDictionaryPtr();
        }
        return IPDFDictionaryPtr(static_cast<IPDFDictionary *>((IPDFObject *) object), true);
    }
    #define obj2IPDFDictionary(obj) JawsMako::IPDFDictionaryPtr(dynamic_cast<JawsMako::IPDFDictionary *>((IRCObject *) (obj)), true)

    class IPDFStream : public IPDFDictionary
    {
      public:
        virtual ~IPDFStream() {}

        static JAWSMAKO_API IPDFStreamPtr create(IEDLClassFactory *pFactory, const IInputStreamPtr &stream, uint32 size = 0);

        virtual IRAInputStreamPtr getStream() const = 0;

        virtual IInputStreamPtr getRawStream() const = 0;
    };
    #define pdfObj2IPDFStream(obj) JawsMako::pdfObj2Type<JawsMako::IPDFStream>(obj, JawsMako::ePOTStream)
    #define obj2IPDFStream(obj) JawsMako::IPDFStreamPtr(dynamic_cast<JawsMako::IPDFStream *>((IRCObject *) (obj)), true)

    class IPDFOperator : public IPDFObject
    {
      public:
        virtual ~IPDFOperator() {}
 
        static JAWSMAKO_API IPDFOperatorPtr create(const U8String &operatorName);
        static JAWSMAKO_API IPDFOperatorPtr create(uint32 operatorId);

        virtual U8String getValue() const = 0;

        virtual uint32 getOperatorId() const = 0;
    };
    #define pdfObj2IPDFOperator(obj) JawsMako::pdfObj2Type<JawsMako::IPDFOperator>(obj, JawsMako::ePOTOperator)
    #define obj2IPDFOperator(obj) JawsMako::IPDFOperatorPtr(dynamic_cast<JawsMako::IPDFOperator *>((IRCObject *) (obj)), true)

    class IPDFObjectStore : public IRCObject
    {
      public:
        virtual ~IPDFObjectStore() {}

        virtual IPDFObjectStorePtr clone() const = 0;

        virtual IPDFFarReferencePtr getRootObjectReference() const = 0;

        virtual IPDFObjectPtr getRootObject() const = 0;

        virtual bool hasReferencedObject(const IPDFObjectPtr &reference) const = 0;

        virtual IPDFObjectPtr resolve(const IPDFObjectPtr &object) const = 0;

        virtual void resolveArray(IPDFArrayPtr &array) const = 0;

        virtual void dirtyObject(const IPDFObjectPtr &object) = 0;

        virtual void dirtyRootObject() = 0;

        virtual IPDFReferencePtr newReference() = 0;

        virtual void store(const IPDFObjectPtr &object, const IPDFReferencePtr &reference, bool markDirty = true) = 0;

        virtual IPDFReferencePtr storeUsingNewReference(const IPDFObjectPtr &object)
        {
            IPDFReferencePtr reference = newReference();
            store(object, reference, true);
            return reference;
        }

        virtual IPDFFarReferencePtr getFarReferenceForReference(const IPDFReferencePtr &reference) const = 0;
    };
}
 
#endif /* JAWSMAKO_PDFOBJECTS_H */