idomgroup.h

Go to the documentation of this file.

/*
* Copyright (C) 2007-2025 Global Graphics Software Ltd. All rights reserved.
*/
 
#ifndef EDLIDOMGROUP_H
#define EDLIDOMGROUP_H
 
#include <edl/idomnode.h>
#include <edl/edlnamespaces.h>
#include <edl/edlfwd.h>
 
#include <edl/edlblend.h>
#include <edl/idombrush.h>
#include <edl/idomcolorspace.h>
#include <edl/idompathgeometry.h>
#include <jawsmako/types.h>
 
_BEGIN_EDL_DOM_NAMESPACE

class IDOMGroup : public IDOMNode
{
#define IDOMGroupClassID 0x4535624b, 0xc4c04966, 0x9a248943, 0x89527f98
public:
 
    virtual ~IDOMGroup () {}

    static EDL_API IDOMGroupPtr create(IEDLClassFactory *pFactory, const FMatrix &transform = FMatrix(), const IDOMPathGeometryPtr &clip = IDOMPathGeometryPtr());

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

    class Data : public CClassParams
    {
      public:
        FMatrix             renderTransform;
        IDOMPathGeometryPtr ptrClip;
    };

    virtual const FMatrix &getRenderTransform() const = 0;

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

    virtual IDOMPathGeometryPtr getClip() const = 0;

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

    virtual JawsMako::IOptionalContentDetailsPtr getOptionalContentDetails() const = 0;

    virtual void setOptionalContentDetails(const JawsMako::IOptionalContentDetailsPtr &details) = 0;

    virtual JawsMako::IMarkedContentDetailsPtr getMarkedContentDetails() const = 0;

    virtual void setMarkedContentDetails(const JawsMako::IMarkedContentDetailsPtr &details) = 0;
 
};
#define edlobj2IDOMGroup(src) edl_cast((IDOMGroup *)NULL, src)
static inline IDOMGroupPtr dom2IDOMGroup(const IDOMNodePtr &src)
{
    if (src)
    {
        switch (src->getNodeType())
        {
            case eDOMGroupNode:
            case eDOMTransparencyGroupNode:
            case eDOMCanvasNode:
            case eDOMCharPathGroupNode:
                return IDOMGroupPtr(static_cast<IDOMGroup *>((IDOMNode *)src), true);
            default:
                return IDOMGroupPtr();
        }
    }
    else
    {
        return IDOMTransparencyGroupPtr();
    }
}

class IDOMTransparencyGroup : public IDOMGroup
{
#define IDOMTransparencyGroupClassID 0x67dd9c06, 0x1e0f42b5, 0xba609ed6, 0x9931c071
public:
    static const CClassID &classID()
    {
        static CClassID id(IDOMTransparencyGroupClassID);
        return id;
    };

    static EDL_API IDOMTransparencyGroupPtr create(IEDLClassFactory *pFactory,
                                                   const FMatrix &transform = FMatrix(),
                                                   const IDOMPathGeometryPtr &clip = IDOMPathGeometryPtr(),
                                                   float opacity = 1.0f,
                                                   const IDOMBrushPtr &opacityMask = IDOMBrushPtr(),
                                                   eBlendMode blendMode = eBlendModeNormal,
                                                   const IDOMColorSpacePtr &colorSpace = IDOMColorSpacePtr(),
                                                   bool isolated = false,
                                                   bool knockout = false);

    class Data : public CClassParams
    {
    public:
        Data(): opacity(1.0), isolated(false), knockout(false), blendMode(eBlendModeNormal)
        {}
        float               opacity;
        eBlendMode          blendMode;
        IDOMColorSpacePtr   colorSpace;
        bool                isolated;
        bool                knockout;
        FMatrix             renderTransform;
        IDOMBrushPtr        ptrOpacityMask;
        IDOMPathGeometryPtr ptrClip;
    };

    virtual float getOpacity() const = 0;

    virtual void setOpacity(float opacity) = 0;

    virtual eBlendMode getBlendMode() const = 0;

    virtual void setBlendMode(eBlendMode blendMode) = 0;

    virtual IDOMColorSpacePtr getColorSpace() const = 0;

    virtual void setColorSpace(const IDOMColorSpacePtr &colorSpace) = 0;

    virtual bool getIsIsolated() const = 0;

    virtual void setIsIsolated(bool isolated) = 0;

    virtual bool getIsKnockout() const = 0;

    virtual void setIsKnockout(bool knockout) = 0;

    virtual IDOMBrushPtr getOpacityMask() const = 0;

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

    virtual eRenderingIntent getRenderingIntent() const = 0;

    virtual void setRenderingIntent(eRenderingIntent intent) = 0;

    virtual eBlackPointCompensation getBlackPointCompensation() const = 0;

    virtual void setBlackPointCompensation(eBlackPointCompensation compensation) = 0;
 
};
#define edlobj2IDOMTransparencyGroup(src) edl_cast((IDOMTransparencyGroup *)NULL, src)
static inline IDOMTransparencyGroupPtr dom2IDOMTransparencyGroup(const IDOMNodePtr &src)
{
    if (src)
    {
        switch (src->getNodeType())
        {
            case eDOMTransparencyGroupNode:
            case eDOMCanvasNode:
                return IDOMTransparencyGroupPtr(static_cast<IDOMTransparencyGroup *>((IDOMNode *)src), true);
            default:
                return IDOMTransparencyGroupPtr();
        }
    }
    else
    {
        return IDOMTransparencyGroupPtr();
    }
}
 
_END_EDL_DOM_NAMESPACE
 
 
#endif /* EDLIDOMGROUP_H */