idomglyphs.h

Go to the documentation of this file.

/*
 * Copyright (C) 2007-2025 Global Graphics Software Ltd. All rights reserved.
 */
 
#ifndef EDLIDOMGLYPHS_H
#define EDLIDOMGLYPHS_H
 
#include <edl/edltypes.h>
#include <edl/edlgeom.h>
#include <edl/idombrush.h>
#include <edl/idompathgeometry.h>
#include <edl/idomgroup.h>
#include <edl/idomfont.h>
#include <edl/idomglyph.h>
#include <edl/idomnode.h>
#include <edl/idomresources.h>
#include <edl/idomtarget.h>
#include <edl/idompath.h>
#include <edl/iglyphsclusters.h>
#include <edl/edlrenderingintent.h>
#include <edl/edlblackpointcompensation.h>
 
_BEGIN_EDL_DOM_NAMESPACE
 
class IDOMGlyphs;
DECL_SMART_PTR(IDOMGlyphs);

class IDOMGlyphs : public IDOMNode
{
#define IDOMGlyphsClassID 0x26AA00B9, 0x290A4048, 0xA0D141C1, 0xEFCB15CE
public:

    typedef enum
    {
        eSSNone       = 0x00,
        eSSItalic     = 0x01,
        eSSBold       = 0x02,
#ifdef SWIG
        eSSBoldItalic = 0x01 | 0x02
#else
        eSSBoldItalic = eSSItalic | eSSBold
#endif
    } eStyleSimulations;

    static EDL_API IDOMGlyphsPtr create(IEDLClassFactory *pFactory,
                                        const EDLString &unicodeString,
                                        double size,
                                        const FPoint &position,
                                        const IDOMBrushPtr &brush,
                                        const IDOMFontPtr  &font,
                                        uint32 fontIndex = 0,
                                        eStyleSimulations styleSimulations = eSSNone,
                                        const FMatrix renderTransform = FMatrix(),
                                        const IDOMPathGeometryPtr &clip = IDOMPathGeometryPtr(),
                                        float opacity = 1.0f);
 

    class Data : public CClassParams
    {
    public:
        Data() :
            styleSimulations(eSSNone),
            opacity(1.0),
            bidiLevel(0),
            isSideways(false),
            fontIndex(0),
            blendMode(eBlendModeNormal),
            isCharPath(false),
            isInvisible(false),
            originX (0.0),
            originY (0.0),
            fontRenderingEmSize (0.0),
            overprintMode(false),
            fillOverprint(false)
        {}
        uint8               bidiLevel;
        EDLSysString        caretStops;
        EDLString           deviceFontName;
        double              fontRenderingEmSize;
        uint32              fontIndex; // >= 0, number identifying font face number in TTC
        double              originX, originY;
        bool                isSideways;
        EDLSysString        indices;
        EDLString           unicodeString;
        eStyleSimulations   styleSimulations;
        FMatrix             renderTransform;
        float               opacity;
        EDLString           language;
        IDOMFontPtr         font;
        IDOMTargetPtr       ptrNavigateLink;
        IDOMBrushPtr        ptrOpacityMask;
        IDOMPathGeometryPtr ptrClip;
        IDOMBrushPtr        ptrFill;
        eBlendMode          blendMode;
        bool                isCharPath;
        bool                isInvisible;
        bool                overprintMode;
        bool                fillOverprint;
    };

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

    virtual uint8 getBidiLevel () const = 0;

    virtual void setBidiLevel (uint8 bidiLevel) = 0;

    virtual const EDLSysString &getCaretStops () const = 0;

    virtual void setCaretStops (const EDLSysString& caretStops) = 0;

    virtual const EDLString &getDeviceFontName () const = 0;

    virtual void setDeviceFontName (const EDLString& name) = 0;

    virtual double getFontRenderingEmSize () const = 0;

    virtual void setFontRenderingEmSize (double emSize) = 0;

    virtual IDOMFontPtr getFont () const = 0;

    virtual void setFont (const IDOMFontPtr &font) = 0;

    virtual uint32 getFontIndex () const = 0;
    virtual void setFontIndex (uint32 index) = 0;

    virtual double getOriginX () const = 0;

    virtual void setOriginX (double originX) = 0;

    virtual double getOriginY () const = 0;

    virtual void setOriginY (double originY) = 0;

    virtual bool getIsSideways () const = 0;

    virtual void setIsSideways (bool isSideways) = 0;

    virtual const EDLSysString &getIndices () const = 0;

    virtual void setIndices (const EDLSysString& indices)= 0;

    virtual const EDLString &getUnicodeString () const = 0;

    virtual void setUnicodeString (const EDLString &unicodeString) = 0;

    virtual IGlyphsClustersPtr getClusters () const = 0;

    virtual void setClusters (const IGlyphsClustersPtr &clusters) = 0;

    virtual eStyleSimulations getStyleSimulations () const = 0;

    virtual void setStyleSimulations (eStyleSimulations styleSimulations) = 0;

    virtual const FMatrix &getRenderTransform() const = 0;

    virtual void setRenderTransform(const FMatrix &matrix) = 0;

    virtual float getOpacity() const = 0;

    virtual void setOpacity(float opc) = 0;

    virtual eBlendMode getBlendMode() const = 0;

    virtual void setBlendMode(eBlendMode blendMode) = 0;

    virtual IDOMTargetPtr getNavigateLink () const = 0;

    virtual void setNavigateLink (const IDOMTargetPtr &target) = 0;

    virtual const EDLString &getLanguage () const = 0;

    virtual void setLanguage (const EDLString &lang) = 0;

    virtual IDOMBrushPtr getOpacityMask() const = 0;

    virtual void setOpacityMask(const IDOMBrushPtr &ptrOpacityMask) = 0;

    virtual IDOMPathGeometryPtr getClip() const = 0;

    virtual void setClip(const IDOMPathGeometryPtr &ptrClip) = 0;

    virtual IDOMBrushPtr getFill() const = 0;

    virtual void setFill(const IDOMBrushPtr &ptrFill) = 0;

    virtual IDOMGlyph::CDOMGlyphDataVect getFlattenedGlyphInfo() const = 0;

    virtual bool getIsCharPath () const = 0;

    virtual void setIsCharPath (bool isCharPath) = 0;

    virtual bool getIsInvisible () const = 0;

    virtual void setIsInvisible (bool isInvisible) = 0;

    virtual IDOMPathNodePtr getEquivalentPath() const = 0;

    virtual IDOMNodePtr split() const = 0;

    virtual IDOMNodePtr hardSplit() const = 0;

    virtual bool validateInstructions() const = 0;

    virtual bool getFillOverprints() const = 0;

    virtual void setFillOverprints(bool overprint = true) = 0;

    virtual bool getOverprintMode() const = 0;

    virtual void setOverprintMode(bool mode = true) = 0;

    virtual eRenderingIntent getRenderingIntent() const = 0;

    virtual void setRenderingIntent(eRenderingIntent intent) = 0;

    virtual eBlackPointCompensation getBlackPointCompensation() const = 0;

    virtual void setBlackPointCompensation(eBlackPointCompensation compensation) = 0;
 
};
#define edlobj2IDOMGlyphs(src) edl_cast((IDOMGlyphs *)NULL, src)
#define dom2IDOMGlyphs(src) dom2NodeType<IDOMGlyphs, eDOMGlyphsNode>(src)
 
_END_EDL_DOM_NAMESPACE
 
#endif /* EDLIDOMGLYPHS_H */