idomnode.h

Go to the documentation of this file.

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

 
#ifndef IDOMNODE_H
#define IDOMNODE_H
 
#include <edl/iedlobject.h>
#include <edl/iedlenum.h>
#include <edl/edltypes.h>
#include <edl/idomid.h>
#include <edl/edlproperty.h>
#include <edl/edlgeom.h>
#include <edl/edlvector.h>
 
 
_BEGIN_EDL_DOM_NAMESPACE

typedef enum
{
    eDOMContentRootNode,                 
    eDOMDocumentSequenceNode,           
    eDOMDocumentNode,                   
    eDOMFixedDocumentNode,                 
    eDOMPageNode,                       
    eDOMFixedPageNode,                     
    eDOMGroupNode,                         
    eDOMCharPathGroupNode,                 
    eDOMTransparencyGroupNode,             
    eDOMCanvasNode,                       
    eDOMGlyphsNode,                       
    eDOMGlyphNode,                         
    eDOMPathNode,                       
    eDOMRefNode,                         
    eDOMJobTkContentNode,               
    eDOMJobTkNodeNode,                     
    eDOMJobTkValueNode,                   
    eDOMJobTkGenericNodeNode,           
    eDOMJobTkGenericCharacterDataNode,     
    eDOMVisualRootNode,                   
    eDOMOutlineNode,                     
    eDOMOutlineEntryNode,               
    eDOMAnnotationAppearanceNode,       
    eDOMFormNode,                       
    eDOMFormInstanceNode,               
    eDOMFragmentNode,                   
    eDOMTileNode,                       
    eDOMNodeTypeCnt,                     
 
} eDOMNodeType;
 
class IDOMNode;
DECL_SMART_PTR(IDOMNode);
typedef CEDLVector<IDOMNodePtr> CDOMNodeVect;

class IDOMNodeFlags
{
  public:
    virtual ~IDOMNodeFlags ()
    {}

    enum DOMNodeFlags
    {
        eNodeRenderFlag        = 8,  
        eNodeUnpackFlag        = 9,  
        eNodeDirtyFlag         = 10, 
        eNodeInterestingFlag   = 11, 
        eNodeExcludeFromRender = 12, 
        eNodeSelectedFlag      = 15, 
        eNodeUserFlag          = 16  
    };

    virtual bool get(uint32 position) const = 0;

    virtual void set(uint32 position, bool value = true) = 0;
 
};
 

class IDOMNode : public IEDLObject
{
  public:
    virtual ~IDOMNode()
    {}

    virtual DOMid getDOMid() const = 0;

    virtual void setDOMid(DOMid id) = 0;

    virtual eDOMNodeType getNodeType() const = 0;

    virtual bool getProperty(const EDLSysString &propertyName, PValue &propertyValue) const = 0;

    virtual void setProperty(const EDLSysString &propertyName, const PValue &propertyValue) = 0;

    virtual void removeProperty(const EDLSysString &propertyName) = 0;

    virtual IEDLSysStringCollectionEnumPtr getPropertyCollectionEnum() = 0;

    virtual bool hasChildNodes() const = 0;

    virtual IDOMNodePtr getParentNode () const = 0;

    virtual IDOMNodePtr getFirstChild () const = 0;

    virtual IDOMNodePtr getLastChild () const = 0;

    virtual IDOMNodePtr getNextChild (const IDOMNodePtr &child) const = 0;

    virtual IDOMNodePtr getPreviousChild (const IDOMNodePtr &child) const = 0;

    virtual IDOMNodePtr getPreviousSibling () const = 0;

    virtual IDOMNodePtr getNextSibling () const = 0;

    virtual void appendChild (const IDOMNodePtr &child) = 0;

    virtual void insertChild (const IDOMNodePtr &ptrPreviousSibling, const IDOMNodePtr &child, bool bCheckComplete = true) = 0;

    virtual IDOMNodePtr extractChild(const IDOMNodePtr &child) = 0;

    virtual void replaceChild(const IDOMNodePtr &oldChild, const IDOMNodePtr &newChild) = 0;

    virtual bool isComplete() const = 0;

    virtual void setComplete() = 0;

    virtual IDOMNodeFlags * getFlags() = 0;

    virtual void setParentNode (const IDOMNodePtr &ptrParent) = 0;

    virtual void setPreviousSibling(const IDOMNodePtr &ptrPreviousSibling) = 0;

    virtual void setNextSibling (const IDOMNodePtr &ptrNextSibling) = 0;

    virtual bool isAncestor (const IDOMNodePtr &ptrCandidate) = 0;
 
    // Bounds
    virtual FRect getBounds(bool applyTransform = true, bool applyClip = true)
    {
        FRect bounds;
        
        // Get the bounds of the children
        IDOMNodePtr node = getFirstChild();
        while (node)
        {
            FRect childBounds = node->getBounds();
            bounds.unionRect(childBounds);
            node = node->getNextSibling();
        }
        return bounds;
    }
    
    virtual bool copyNodeData(IDOMNode *pSourceNode) = 0;
    
    virtual IDOMNodePtr cloneNode(IEDLClassFactory *pFactory) const = 0;
    
    virtual IDOMNodePtr cloneTree(IEDLClassFactory *pFactory) const = 0;
    
    virtual void cloneTreeAndAppend(IEDLClassFactory *pFactory, const IDOMNodePtr &dest) const = 0;

    virtual void completeTree() = 0;
    
    virtual void removeCompleteFlagFromTree() = 0;
    
    virtual void findChildrenOfType(eDOMNodeType type, CDOMNodeVect &nodes, bool searchForms = false) = 0;
 
    typedef bool (*WalkTreeFunc)(void *priv, const IDOMNodePtr &node);

    virtual void walkTree(WalkTreeFunc func, void *priv, bool descendIntoBrushes = false, bool descendIntoForms = false) = 0;
    
    static EDL_API FMatrix effectiveTransformationOfNode(const IDOMNodePtr &node);
 
    typedef void (*NodeDeleteFunc)(const IDOMNode *node, void *priv);
    
    virtual void notifyOnDestruct(NodeDeleteFunc func, void *priv) = 0;

    virtual void unregisterNotify(NodeDeleteFunc func, void *priv) = 0;
};
#define edlobj2IDOMNode(src) edl_cast((IDOMNode *)NULL, src)
 
template <class T, eDOMNodeType NT>
static inline CSmartPtr<T> dom2NodeType(const IDOMNodePtr &src)
{
    if (src && src->getNodeType() == NT)
    {
        return CSmartPtr<T>(static_cast<T *>((IDOMNode *)src), true);
    }
    else
    {
        return CSmartPtr<T>();
    }
}
 
_END_EDL_DOM_NAMESPACE
 
#endif /* IDOMNODE_H */