OP_NamedMicroNodes.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * COMMENTS:
 *      This is the base class to hold named micro nodes.
 */

#ifndef __OP_NAMEDMICRONODES_h__
#define __OP_NAMEDMICRONODES_h__

#include "OP_API.h"

#include "OP_DataMicroNode.h"

#include <UT/UT_Array.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_StringMap.h>
#include <UT/UT_UniquePtr.h>

class OP_Node;

// Add a name to OP_DataMicroNode and keep a cached list of dependents
// The dependents are rebuild only of the named micronode starts with a !
// character. We use it for clips: !clip:clip1
class OP_API OP_NamedDataMicroNode : public OP_DataMicroNode

{
public:
    OP_NamedDataMicroNode(OP_Node &node, const UT_StringHolder &name);

    const char * className() const override;
    const UT_StringHolder &getMicroNodeName() const;

    void rebuildDependents();
    const UT_Array<const OP_NamedDataMicroNode*> &dependents() const;

    void                    becameDirty(DEP_MicroNode &src,
                                const DEP_PropagateData &data) override;
public:
    UT_StringHolder myMicroNodeName;
    bool myRebuildDependents;

    UT_Array<const OP_NamedDataMicroNode*> myDependents;
};

// Base class for Nodes that want to have custom named micronodes.
class OP_API OP_NamedMicroNodes
{
public:
    OP_NamedMicroNodes(OP_Node *op);
    virtual ~OP_NamedMicroNodes();

    OP_NamedMicroNodes(OP_NamedMicroNodes &) = delete;
    OP_NamedMicroNodes &operator=(OP_NamedMicroNodes &) = delete;

    // Change the dataMicroNode on which dependencies are added during 
    // a Python SOP cook.
    // Use an empty name to revert to the original dataMicroNode.
    void setCurrentNamedDataMicroNode( const UT_StringHolder &name );

    // Returns the name of the current NamedMicroNode.
    SYS_FORCE_INLINE
    const UT_StringHolder &currentNamedDataMicroNode() const
        { return myDataMicroNodeName; }

    // Push a named micronode on the stack, connecting it to the current
    // micronode.
    void pushNamedDataMicroNode( const UT_StringHolder &name,
        bool reverse_dir=false );

    // Pop the current named micronode from the stack, setting the current node
    // to the previous node from the stack.
    void popNamedDataMicroNode();

    // Query the state of the previously cooked micronodes.
    const UT_StringMap<int> &getNamedDataMicroNodesState() const;

    // Dirty the state of the previously declared micronodes.
    void dirtyNamedDataMicroNodes( const UT_StringArray &names);

    // Extract the named micronode states.
    void updateNamedDataMicroNodesState();

    // Mark all the named micronodes as clean.
    void cleanNamedDataMicroNodes();

    // Destroy all the named micronodes.
    // Use when dependencies need to be rebuilt from scratch.
    // It's the only way to destroy a named micronode.
    void clearNamedDataMicroNodes();

    SYS_FORCE_INLINE
    const OP_NamedDataMicroNode* namedDataMicroNodeConst() const
        { return myDataMicroNodePtr; }

    // Pre/Post cook methods to hook the micronode to the real data micronode.
    // Also stashes myNamedDataMicroNodesState
    void namedMicroNodesPreCook();
    void namedMicroNodesPostCook(OP_DataMicroNode &dataMicroNode);
private:

    OP_Node *myOp;
    UT_StringHolder myDataMicroNodeName;
    OP_NamedDataMicroNode* myDataMicroNodePtr;
    UT_Array<OP_NamedDataMicroNode*> myDataMicroNodeStack;

    UT_Array<UT_UniquePtr<OP_NamedDataMicroNode>> myNamedDataMicroNodesArray;
    UT_StringMap<exint> myNamedDataMicroNodesMap;

    UT_StringMap<int> myNamedDataMicroNodesState;
};

#endif