idomfont.h

Go to the documentation of this file.

/*
 * Copyright (C) 2007-2025 Global Graphics Software Ltd. All rights reserved.
 */

 
#ifndef IDOMFONT_H
#define IDOMFONT_H
 
#include <map>
#include <edl/edltypes.h>
#include <edl/edlstream.h>
#include <edl/idomnode.h>
#include <edl/idomglyph.h>
#include <edl/isession.h>
#include <edl/edlvector.h>
#include <edl/idomhashable.h>
#include <edl/edlsimplebuffer.h>
#include <jawsmako/pdfobjects.h>
 
_BEGIN_EDL_DOM_NAMESPACE

class IDOMFontSource : public IEDLObject, public IDOMHashable
{
#define IDOMFontSourceClassID 0x2eed7bfe, 0x821011dc, 0x83140800, 0x200c9a66
public:
    typedef enum
    {
        eFontSourceTypeNone,            
        eFontSourceTypeStreamFilter,    
        eFontSourceTypeStream,          
        eFontSourceTypeFont,            
 
    } eFontSourceType;

    class Data : public CClassParams
    {
      public:
 
        eFontSourceType sourceType;
 
        Data ()
        {
            sourceType = eFontSourceTypeNone;
        }
    };

    static const CClassID &classID()
    {
        static CClassID id(IDOMFontSourceClassID);
        return id;
    };

    virtual eFontSourceType getFontSourceType() const = 0;

    virtual const EDLSysString &determineUri() const = 0;
};
DECL_SMART_PTR(IDOMFontSource);
#define edlobj2IDOMFontSource(src) edl_cast((IDOMFontSource *)nullptr, src)
 
 

class IDOMFontSourceStreamFilter : public IDOMFontSource
{
public:

    typedef enum
    {
        eFontStreamFilterTypeNone,            
        eFontStreamFilterTypeObfuscation,    
 
    } eFontStreamFilterType;

    virtual eFontStreamFilterType getFontStreamFilterType() const = 0;

    class Data : public IDOMFontSource::Data
    {
    public:
        IDOMFontSourcePtr inputFontSource;        //The input font source
    };

    virtual IInputStreamPtr getStream() const = 0;

    virtual const EDLSysString &determineUri() const = 0;

    virtual IDOMFontSourcePtr getInputFontSource() const = 0;
 
};
DECL_SMART_PTR(IDOMFontSourceStreamFilter);
#define edlobj2IDOMFontSourceStreamFilter(src) edl_cast((IDOMFontSourceStreamFilter *)nullptr, src)
 

class
IDOMFontSourceFromStream : public IDOMFontSource
{
#define IDOMFontSourceFromStreamClassID 0x6d2e3ca8, 0x821511dc, 0x83140800, 0x200c9a66
public:
    class Data : public IDOMFontSourceStreamFilter::Data
    {
    public:
        Data() : streamLength(0), fromPcl(false)
        {}
        EDLSysString uri;
        IInputStreamPtr stream;
        uint64 streamLength;
        bool fromPcl;
    };

    static const CClassID &classID()
    {
        static CClassID id(IDOMFontSourceFromStreamClassID);
        return id;
    };

    virtual IInputStreamPtr getStream() const = 0;

    virtual int64 getStreamLength() const = 0;

     virtual const EDLSysString &determineUri() const = 0;

    virtual bool getFromPcl() const = 0;
};
DECL_SMART_PTR(IDOMFontSourceFromStream);
#define edlobj2IDOMFontSourceFromStream(src) edl_cast((IDOMFontSourceFromStream *)nullptr, src)
 

class IDOMFontSourceObfuscationConverter : public IDOMFontSourceStreamFilter
{
#define IDOMFontSourceObfuscationConverterClassID 0x51e24e4a, 0x831a11dc, 0x83140800, 0x200c9a66
public:

    typedef enum
    {
        eObfuscate,        
        eDeobfuscate,    
 
    } eOperation;

    class Data : public IDOMFontSource::Data
    {
    public:
        IDOMFontSourcePtr inputFontSource;        
        eOperation operation;                    
    };

    static const CClassID &classID()
    {
        static CClassID id(IDOMFontSourceObfuscationConverterClassID);
        return id;
    };

    virtual IInputStreamPtr getStream() const = 0;

    virtual const EDLSysString &determineUri() const = 0;

    virtual IDOMFontSourcePtr getInputFontSource() const = 0;
 
};
DECL_SMART_PTR(IDOMFontSourceObfuscationConverter);
#define edlobj2IDOMFontSourceObfuscationConverter(src) edl_cast((IDOMFontSourceFromStream *)nullptr, src)
 

class IDOMFont : public IDOMFontSource
{
#define IDOMFontClassID 0x4330123e, 0x7e6211dc, 0x83140800, 0x200c9a66
public:

    typedef uint32 CharCode;

    typedef std::map<CharCode, IDOMGlyph::GlyphID> CCharacterMap;

    typedef enum
    {
        eFontTypeUnknown,  
        eFontTypeOpenType, 
        eFontType3,        
        eFontTypePCLXL,    
        eFontTypePCL5      
    } eFontType;

    class Data : public CClassParams
    {
    public:
        IDOMFontSourcePtr fontSource;
    };

    static const CClassID &classID()
    {
        static CClassID id(IDOMFontClassID);
        return id;
    };

    virtual eFontType getFontType() const = 0;

    virtual IDOMFontSourcePtr getFontSource() const = 0;

    virtual void setFontSource(const IDOMFontSourcePtr &fontSource) = 0;

    virtual IInputStreamPtr getFontBaseStream() const = 0;

    virtual void getCharacterMap(CCharacterMap &characterMap, uint32 fontIndex = 0U) = 0;
};
DECL_SMART_PTR(IDOMFont);
#define edlobj2IDOMFont(src) edl_cast((IDOMFont *)nullptr, src)
 

typedef uint32    TableSignatureID;
 
 
class IFontOpenTypeTableAccessor  :  public IEDLObject
{
#define IFontOpenTypeTableAccessorClassID    0x06e3b890, 0xda2311dc, 0x95ff0800, 0x200c9a66
public:

    static const CClassID &classID()
    {
        static CClassID id(IFontOpenTypeTableAccessorClassID);
        return id;
    };

    virtual bool hasTable(TableSignatureID tableSignatureID) = 0;

    virtual int32 getTableSize(TableSignatureID tableSignatureID, bool withPadding = true) = 0;

    virtual uint32 getTableCheckSum(TableSignatureID tableSignatureID) = 0;

    virtual int32 tableWrite(const IOutputStreamPtr &outStream, TableSignatureID tableSignatureID, int32 startPos = 0, int32 endPos = -1, bool withPadding = true) = 0;

#ifdef SWIG
#if SWIGJAVA
    %apply char *BYTE {unsigned char *buf}
#endif
#if SWIGCSHARP
    %apply unsigned char INPUT[] {unsigned char *buf}
#endif
#endif
    virtual int32 tableCopy(unsigned char *buf, int32 bufSize, TableSignatureID tableSignatureId, bool withPadding = true) = 0;
#ifdef SWIG
    %clear unsigned char *buf;
#endif
};
 
DECL_SMART_PTR(IFontOpenTypeTableAccessor);
#define edlobj2IFontOpenTypeTableAccessor(src) edl_cast((IFontOpenTypeTableAccessor *)nullptr, src)
 
 
class IFontTrueTypeGlyphIDEnumerator  :  public IEDLObject
{
#define IFontTrueTypeGlyphIDEnumeratorClassID   0xa8c1c370, 0xdb1111dc, 0x95ff0800, 0x200c9a66
public:

    static const CClassID &classID()
    {
        static CClassID id(IFontTrueTypeGlyphIDEnumeratorClassID);
        return id;
    };

    virtual IDOMGlyph::GlyphID getGlyphID() = 0;

    virtual bool haveMoreEnumerationItems() = 0;

    virtual bool nextEnumerationItem() = 0;
};
DECL_SMART_PTR(IFontTrueTypeGlyphIDEnumerator)
 
class IFontTrueTypeGlyphAccessor :  public IEDLObject
{
#define IFontTrueTypeGlyphAccessorClassID 0x114cab20, 0xda2311dc, 0x95ff0800, 0x200c9a66
public:

    static const CClassID &classID()
    {
        static CClassID id(IFontTrueTypeGlyphAccessorClassID);
        return id;
    };

    virtual bool hasGlyph(IDOMGlyph::GlyphID glyphID) = 0;

    virtual int32 getGlyphDataSize(IDOMGlyph::GlyphID glyphID) = 0;

    virtual int32 glyphDataWrite(const IOutputStreamPtr &outStream, IDOMGlyph::GlyphID glyphID) = 0;

    virtual IDOMGlyphIDEnumeratorPtr getDependantGlyphIDEnumerator(IDOMGlyph::GlyphID glyphID) = 0;
};
 
DECL_SMART_PTR(IFontTrueTypeGlyphAccessor);
#define edlobj2IFontTrueTypeGlyphAccessor(src) edl_cast((IFontTrueTypeGlyphAccessor *)nullptr, src)
 
class IDOMFontOpenType;
DECL_SMART_PTR(IDOMFontOpenType);
 
class IDOMFontOpenTypeTT ;
DECL_SMART_PTR(IDOMFontOpenTypeTT);

class IDOMFontOpenType : public IDOMFont
{
#define IDOMFontOpenTypeClassID 0x287baf3f, 0x307e4aa0, 0xa66f981f, 0xd4ac090a
public:
    static EDL_API IDOMFontOpenTypePtr create(IEDLClassFactory *pFactory, const IInputStreamPtr &stream);

    typedef enum
    {
        eOpenTypeFontTypeUnknown,            
        eOpenTypeFontTypeTTF,                
        eOpenTypeFontTypeCFF,                
        eOpenTypeFontTypeTTC,                
 
    } eOpenTypeFontType;

    typedef enum
    {
        eOriginalTypeOpenType,            
        eOriginalType1,                   
        eOriginalType2,                   
        eOriginalType42,                  
        eOriginalType9,                   
        eOriginalType11,                  
        eOriginalPclTrueType              
    } eOriginalFontType;

    class EDL_API Signature
    {
    public:

        typedef enum
        {
            eSignatureNone    = -1,
 
            // Font type signatures
            eSignatureTTF = 0,                  
            eSignatureCFF,                      
            eSignatureTTC,                      
 
            // OpenType TrueType Signatures
 
            eSignatureBASE,                     
            eSignatureCMAP,                     
            eSignatureGSUB,                     
            eSignatureLTSH,                     
            eSignatureOS2,                      
            eSignatureHead,                     
            eSignatureHhea,                     
            eSignatureVhea,                     
            eSignatureMAXP,                     
            eSignatureName,                     
            eSignatureCvt,                      
            eSignatureFpgm,                     
            eSignatureGasp,                     
            eSignatureGdir,                     
            eSignatureGlyf,                     
            eSignatureLoca,                     
            eSignaturePost,                     
            eSignaturePrep,                     
            eSignatureMort,                     
            eSignatureHmtx,                     
            eSignatureVmtx,                     
            eSignatureVORG,                     
            eSignatureEnd                      // End of list marker
 
        } eSignature;

        Signature()
        {
            set(eSignatureNone);
        }
 

        Signature (const char *str)
        {
            m_eSignature = eSignatureNone;
            set(str);
        }

        Signature(eSignature sSignature)
        {
            set(sSignature);
        }

        Signature(TableSignatureID signature)
        {
            m_eSignature = eSignatureNone;
            set(signature);
        }
 
        void set (const char *str);

        void set(TableSignatureID signature)
        {
            m_signatureID = signature;
        }

        void set(eSignature signature);

        TableSignatureID getSignatureID()
        {
            return m_signatureID;
        }

        eSignature getSignatureType()
        {
            return m_eSignature;
        }
 
        void getStr(char *str);

        static const char *signatureToStr(TableSignatureID signatureID)
        {
            static char sigStr[5];
 
            Signature   sig(signatureID);
 
            sig.getStr(sigStr);
            sigStr[4] = '\0';
 
            return sigStr;
        }

        bool equals(TableSignatureID signature)
        {
            return (signature == m_signatureID);
        }

        bool equals(Signature &signature)
        {
            return (m_signatureID == signature.m_signatureID);
        }

        bool isLessThan(TableSignatureID signature)
        {
            return (m_signatureID < signature);
        }

        bool isGreaterThan(TableSignatureID signature)
        {
            return (m_signatureID > signature);
        }

        bool equals(eSignature signature)
        {
            Signature sig(signature);
 
            return equals(sig);
        }
 
    private:
 
        TableSignatureID m_signatureID;
        eSignature m_eSignature;
    };
 
    class CCIDMap;
    DECL_SMART_PTR(CCIDMap);

    class CCIDMap : public IRCObject
    {
      public:
        EDLRawString       registry;   
        EDLRawString       ordering;   
        int32              supplement; 
        CEDLVector<uint16> mapping;    
 
        static EDL_API CCIDMapPtr create(const EDLRawString &registry,
                                         const EDLRawString &ordering,
                                         int32 supplement,
                                         const CEDLVector<uint16> &mapping);
    };

    class Data : public IDOMFont::Data
    {
      public:
        Data()
        {
            obfuscated          = false;
            embedded            = true;
            originalFontType    = eOriginalTypeOpenType;
            psStandardFont      = false;
            pdfStandardFont     = false;
            subsetted           = false;
            flags               = -1;
        }
        bool                embedded;
        bool                obfuscated;
        EDLRawString        requestedFontName;
        bool                psStandardFont;
        bool                pdfStandardFont;
        bool                subsetted;
        int32               flags;
        CEDLSimpleBuffer    panose;
        eOriginalFontType   originalFontType;
        CEDLSimpleBuffer    originalOS2Table;
        CCIDMapConstPtr     cidMap;
        EDLRawString        originalPdfEncoding;
    };

    static const CClassID &classID()
    {
        static CClassID id(IDOMFontOpenTypeClassID);
        return id;
    };

    virtual bool getObfuscated() const = 0;

    virtual bool getIsPSStandardFont() const = 0;

    virtual bool getIsPDFStandardFont() const = 0;

    virtual bool getEmbedded() const = 0;

    virtual void setEmbedded(bool embedded) = 0;

    virtual bool getSubsetted() const = 0;

    virtual EDLRawString getRequestedFontName() const = 0;

    virtual EDLSysString getPostScriptName(IEDLClassFactory *pFactory, int32 fontIndex) = 0;

    virtual EDLSysString getFullName(IEDLClassFactory *pFactory, int32 fontIndex) = 0;

    virtual eOpenTypeFontType getOpenTypeFontType() = 0;

    virtual eOriginalFontType getOriginalFontType() = 0;

    virtual IFontOpenTypeTableAccessorPtr getFontOpenTypeTableAccessor(uint32 fontIndex = 0) = 0;

    virtual IFontTrueTypeGlyphAccessorPtr getFontTrueTypeGlyphAccessor(uint32 fontIndex = 0, bool stripInstructions = false) = 0;

    virtual uint16 getFontLicenseFromOS2Table(uint32 fontIndex = 0) = 0;

    virtual bool getIsRestricted(uint32 fontIndex = 0) = 0;

    virtual IDOMFontOpenTypeTTPtr createTrueTypeOnlyFontVersion(const ISessionPtr &ptrSession, bool regenerateStream) = 0;

    virtual IDOMFontOpenTypePtr createSubsetFont(const ISessionPtr &ptrSession, const CEDLVector<uint16> &usedGlyphs, const CEDLVector<uint32> &usedUnicode) = 0;

    virtual IDOMFontOpenTypePtr createRenamedFont(const ISessionPtr &ptrSession, const EDLSysString &fontName, uint32 fontIndex = 0) = 0;

    virtual const CEDLSimpleBuffer &getOriginalOS2Table() const = 0;

    virtual CCIDMapConstPtr getCidMap() const = 0;

    virtual int32 getFlags() const = 0;

    virtual const CEDLSimpleBuffer &getPanose() const = 0;

    virtual void setCidMap(const CCIDMapConstPtr &cidMap) = 0;

    virtual bool validateInstructions(const ISessionPtr &session, uint32 fontIndex = 0) = 0;

    virtual IDOMFontOpenTypePtr stripInstructions(const ISessionPtr &session, uint32 fontIndex = 0, bool all = false) = 0;

    virtual EDLRawString getOriginalPdfEncoding() const = 0;

    virtual void removeOriginalPdfEncoding() = 0;
};
#define edlobj2IDOMFontOpenType(src) edl_cast((IDOMFontOpenType *)nullptr, src)
 
 

class IDOMFontOpenTypeTT : public IDOMFontOpenType
{
#define IDOMFontOpenTypeTTClassID 0x47fda935, 0xb25944b3, 0xbdc1061b, 0x7356cf50
 
public:

    static const CClassID &classID()
    {
        static CClassID id(IDOMFontOpenTypeTTClassID);
        return id;
    };

    class Data : public IDOMFontOpenType::Data
    {
      public:
        Data()
        {
            fontIndex = 0;
        }
        uint32 fontIndex;
    };

    virtual int32 writeFont(const IOutputStreamPtr &outStream) = 0;

     virtual int32 writeFont(const EDLSysString &filePath, bool isTemplate = false)
     { return -1; }
 
};
DECL_SMART_PTR(IDOMFontOpenTypeTT);
#define edlobj2IDOMFontOpenTypeTT(src) edl_cast((IDOMFontOpenTypeTT *)nullptr, src)

class IDOMType3Font : public IDOMFont
{
#define IDOMType3FontClassID 0xb885316f, 0x7b114d80, 0x8fbe958c, 0xf1b34ab3
public:
    class Data : public CClassParams
    {
    public:
        JawsMako::IPDFDictionaryPtr fontDict;
        IEDLTempStorePtr            tempStore;
        IEDLClassFactory           *pFactory;
    };

    static const CClassID &classID()
    {
        static CClassID id(IDOMType3FontClassID);
        return id;
    };

    virtual DOMid getId() const = 0;

    virtual bool hasGlyph(const EDLSysString &glyphName) const = 0;

    virtual IDOMGlyphPtr getGlyph(const EDLSysString &glyphName) const = 0;

    virtual bool hasGlyph(uint32 codePoint) const = 0;

    virtual IDOMGlyphPtr getGlyph(uint32 codePoint) const = 0;

    virtual bool hasGlyph(IDOMGlyph::GlyphID glyphID) const = 0;

    virtual IDOMGlyphPtr getGlyph(IDOMGlyph::GlyphID glyphID) const = 0;

    virtual CDOMGlyphVect getGlyphs() const = 0;

    virtual void deleteGlyphs() = 0;

    virtual void addGlyph(const IDOMGlyphPtr &glyph) = 0;

    virtual FRect getBBox() = 0;

    virtual JawsMako::IPDFDictionaryPtr getFontDictionary() const = 0;
};
DECL_SMART_PTR(IDOMType3Font);
#define edlobj2IDOMType3Font(src) edl_cast((IDOMType3Font *)nullptr, src)
 
 
_END_EDL_DOM_NAMESPACE
 
 
#endif /* IDOMFONT_H */