OP/OP_Node.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.
 *
 * Produced by:
 *      Side Effects Software Inc.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        OP Library (C++)
 *
 * COMMENTS:    The base class for all OP operators
 *
 */

#ifndef __OP_Node_h__
#define __OP_Node_h__

#include "OP_API.h"
#include <iostream.h>
#include <SYS/SYS_AtomicInt.h>
#include <SYS/SYS_Math.h>
#include <UT/UT_Algorithm.h>
#include <UT/UT_Color.h>
#include <UT/UT_Error.h>
#include <UT/UT_String.h>
#include <UT/UT_IntArray.h>
#include <UT/UT_RefArray.h>
#include <UT/UT_PtrArray.h>
#include <UT/UT_BitArray.h>
#include <UT/UT_Vector3.h>
#include <UT/UT_PathSearch.h>
#include <UT/UT_TokenString.h>
#include <UT/UT_XformOrder.h>
#include <UT/UT_Options.h>
#include <IMG/IMG_Raster.h>
#include "OP_DataTypes.h"
#include "OP_Error.h"
#include "OP_ExtraInput.h"
#include "OP_Lock.h"
#include "OP_Parameters.h"
#include "OP_NodeFlags.h"
#include "OP_NetworkBoxItemFlags.h"
#include "OP_Version.h"
#include "OP_Context.h"
#include "OP_Cache.h"
#include "OP_Dependency.h"
#include "OP_NetworkBoxItem.h"
#include "OP_BundleReferences.h"
#include "OP_OTLLicenseType.h"
#include "OP_PropagateData.h"
#include "OP_TaskState.h"

#include <UT/UT_VectorTypes.h>

class UT_Ramp;
class UT_WorkArgs;
class UT_WorkBuffer;
class UT_StringArray;
class UT_InfoTree;
class UT_Undo;
class UT_BoundingBox;
class PY_CompiledCode;
class PY_Result;
class DD_Source;
class DD_ChoiceList;
class CL_Clip;
class CL_Track;
class EV_SYMBOL;        // EXPR library
class CMD_Args;
class PRM_BatchList;
class PRM_Parm;
class PRM_RefId;
class OP_Operator;
class OP_OutputCodeParms;
class OP_InputIndirect;
class OP_ParmInterest;
class OP_Input;
class OP_Node;
class OP_Network;
class OP_Group;
class OP_Bundle;
class OP_PreDefRules;
class OP_GalleryEntry;
class OP_SaveFlags;
class OP_GlobContext;
class DOP_Parent;
class VOP_CodeGenerator;
class VOP_ScriptMaterialCodeMapper;

// avoid lengthy compilation dependency
typedef UT_PtrArray<const CL_Track *>   CL_TrackListC;  
typedef UT_PtrArray<OP_Node *>          OP_NodeList;    

typedef int  (*OP_EditCallback)(void *data, OP_Node *src,
                CL_Track *track, float t, float value);

// Utility for detecting cycles when traversing graphs
typedef UT_CycleDetect<OP_Node *>       OP_NodeCycleDetect;
struct OP_NodeParmRef
{
    OP_NodeParmRef(const OP_Node *eval_node = 0,
                   const PRM_Parm *parm_ref = 0,
                   int vi = -1)
        : myEvalNode(eval_node)
        , myParmRef(parm_ref)
        , myVectorIndex(vi)
    {
    }

    bool operator==(const OP_NodeParmRef &other)
    {
        return (myEvalNode == other.myEvalNode
                && myParmRef == other.myParmRef
                && myVectorIndex == other.myVectorIndex);
    }

    const OP_Node *     myEvalNode;     // node evaluating the given parameter
    const PRM_Parm *    myParmRef;      // pointer to evaluated parameter
    int                 myVectorIndex;  // parameter component index
};
typedef UT_CycleDetect<OP_NodeParmRef>  OP_NodeParmRefCycle;

// Mutex utility types
typedef UT_LockedRawPtr<OP_ExtraInputList, OP_Lock>
                                        OP_LockedExtraInputs;
typedef UT_LockedRawPtr<const OP_ExtraInputList, OP_Lock>
                                        OP_LockedConstExtraInputs;
typedef UT_LockedRawPtr<OP_NodeList, OP_Lock>
                                        OP_LockedNodeList;
typedef UT_LockedRawPtr<const OP_NodeList, OP_Lock>
                                        OP_LockedConstNodeList;

// The prefix used to specify an operator where a path would normally be used.
#define OPREF_PREFIX            "op:"
#define OPREF_PREFIX_LEN        3

//This constant comes in handy when a client is storing OP_Node ids and 
//then polling for a node using OP_Node::lookupNode(id), and they need to 
//specify that their stored id is currently invalid,  i.e. if the
//corresponding node was deleted. This can obviously also be used for
//other things
#define OP_INVALID_NODE_ID      -999

// Please, no spaces in these table names!
#define INVALID_TABLE_NAME      "Node"
#define OBJ_TABLE_NAME          "Object"
#define SOP_TABLE_NAME          "Sop"
#define POPNET_TABLE_NAME       "Particle"
#define POP_TABLE_NAME          "Pop"
#define CHOPNET_TABLE_NAME      "ChopNet"
#define CHOP_TABLE_NAME         "Chop"
#define ROP_TABLE_NAME          "Driver"
#define SHOP_TABLE_NAME         "Shop"
#define COP2_TABLE_NAME         "Cop2"
#define COPNET_TABLE_NAME       "CopNet"
#define VOP_TABLE_NAME          "Vop"
#define VOPNET_TABLE_NAME       "VopNet"
#define DOP_TABLE_NAME          "Dop"

// Manager and Director tabel names:
#define MGR_TABLE_NAME          "Manager"
#define DIR_TABLE_NAME          "Director"

// These are the "script" directories where help and initialization scripts
// are found.
#define INVALID_SCRIPT_NAME     "node"
#define OBJ_SCRIPT_NAME         "obj"
#define SOP_SCRIPT_NAME         "sop"
#define POPNET_SCRIPT_NAME      "part"
#define POP_SCRIPT_NAME         "pop"
#define CHOPNET_SCRIPT_NAME     "ch"
#define CHOP_SCRIPT_NAME        "chop"
#define ROP_SCRIPT_NAME         "out"
#define SHOP_SCRIPT_NAME        "shop"
#define COPNET_SCRIPT_NAME      "img"
#define COP2_SCRIPT_NAME        "cop2"
#define VOP_SCRIPT_NAME         "vop"
#define VOPNET_SCRIPT_NAME      "vex"
#define DOP_SCRIPT_NAME         "dop"

// Manager and Director scripts...  I doubt these will be used.
#define MGR_SCRIPT_NAME         "mgr"
#define DIR_SCRIPT_NAME         "dir"

// These are the op type names.  These are used by icons among others.
#define INVALID_OPTYPE_NAME     "NODE"
#define OBJ_OPTYPE_NAME         "OBJ"
#define SOP_OPTYPE_NAME         "SOP"
#define POPNET_OPTYPE_NAME      "PART"
#define POP_OPTYPE_NAME         "POP"
#define CHOPNET_OPTYPE_NAME     "CHOPNET"
#define CHOP_OPTYPE_NAME        "CHOP"
#define ROP_OPTYPE_NAME         "ROP"
#define SHOP_OPTYPE_NAME        "SHOP"
#define COP2_OPTYPE_NAME        "COP2"
#define COPNET_OPTYPE_NAME      "IMG"
#define VOP_OPTYPE_NAME         "VOP"
#define VOPNET_OPTYPE_NAME      "VOPNET"
#define DOP_OPTYPE_NAME         "DOP"

// These are the types of the manager nodes & director nodes.
// Manager nodes are things like /shop which don't have a specific
// type 
// The director node is the root node which has everything inside it.
#define MGR_OPTYPE_NAME         "MGR"
#define DIR_OPTYPE_NAME         "DIR"

#define OP_DEFAULT_COLOR_R      0.8F
#define OP_DEFAULT_COLOR_G      0.8F
#define OP_DEFAULT_COLOR_B      0.8F
#define OP_DEFAULT_COLOR        UT_RGB, \
                                OP_DEFAULT_COLOR_R, \
                                OP_DEFAULT_COLOR_G, \
                                OP_DEFAULT_COLOR_B

enum OP_OpTypeId
{
    INVALID_OPTYPE_ID = -1,
    OBJ_OPTYPE_ID       = 0,
    SOP_OPTYPE_ID,
    POPNET_OPTYPE_ID,
    POP_OPTYPE_ID,
    CHOPNET_OPTYPE_ID,
    CHOP_OPTYPE_ID,
    ROP_OPTYPE_ID,
    SHOP_OPTYPE_ID,
    COP2_OPTYPE_ID,
    COPNET_OPTYPE_ID,
    VOP_OPTYPE_ID,
    VOPNET_OPTYPE_ID,
    DOP_OPTYPE_ID,
    MGR_OPTYPE_ID,
    DIR_OPTYPE_ID,
    NUM_MANAGERS
};

// These are some special defines used by VOPs. They need to be here
// because the OP_ConnectionMemory has to handle these operators in a
// special way,
#define VOP_OUTPUT_NODE_NAME            "output"
#define VOP_SUBNET_OUTPUT_NODE_NAME     "suboutput"
#define VOP_SUBNET_INPUT_NODE_NAME      "subinput"

// These defines provide a common place where the names of the management
// operator types are defined.
#define SHOP_MANAGEMENT_OPTYPE          "shopnet"
#define POP_MANAGEMENT_OPTYPE           "popnet"
#define COP2_MANAGEMENT_OPTYPE          "cop2net"
#define ROP_MANAGEMENT_OPTYPE           "ropnet"
#define CHOP_MANAGEMENT_OPTYPE          "chopnet"
#define SOP_MANAGEMENT_OPTYPE           "sopnet"
#define OBJ_MANAGEMENT_OPTYPE           "objnet"
#define VOP_MANAGEMENT_OPTYPE           "vopnet"
#define DOP_MANAGEMENT_OPTYPE           "dopnet"

// This class has each of the above entities filled out.
// You can thus convert between different types by looking up
// with the known key and extracting what you want from this class.
// Looking up by id is fast, the rest requires a scan.
class OP_API OP_TypeInfo
{
public:
    OP_OpTypeId          myOptypeId;
    const char          *myOptypeName;
    const char          *myTableName;
    const char          *myScriptDir;
};

//___________________________________________________________________________


//
// a container class to describe the instantaneous state of a parameter
//
class OP_API opParmData
{
public:
    float        myValue;
    UT_String    myLabel;
    OP_Node     *myNode;
    int          myIndex;
    int          mySubIndex;

    int          operator==(const opParmData &v) const
                 {
                     return (myValue == v.myValue && 
                             myLabel == v.myLabel &&
                             myNode == v.myNode &&
                             myIndex == v.myIndex &&
                             mySubIndex == v.mySubIndex
                             );
                 }
};


// Blank class definitions for all our node types...
class OBJ_Node;
class SOP_Node;
class POP_Node;
class POPNET_Node;
class CHOPNET_Node;
class CHOP_Node;
class COP2_Node;
class COPNET_Node;
class ROP_Node;
class SHOP_Node;
class VOP_Node;
class VOPNET_Node;
class DOP_Node;

#define INSTANTIATE_FINDNODE_FUNCTIONS(PREFIX)                  \
    PREFIX##_Node *find##PREFIX##Node(const char *path) const   \
    {                                                           \
        OP_Node         *node;                                  \
                                                                \
        node = findNode(path);                                  \
        if (node) return node->castTo##PREFIX##Node();          \
        return 0;                                               \
    }
#define INSTANTIATE_CASTNODE_FUNCTIONS(PREFIX)                  \
    PREFIX##_Node *castTo##PREFIX##Node() const                 \
    {                                                           \
        /* If this is triggered, use CAST_FOONODE instead */    \
        /* This is because foo->bar() should not be done with */ \
        /* NULL foo for aesthetic reasons. */                   \
        UT_ASSERT(this);                                        \
        if (!this) return 0;                                    \
        if (getOpTypeID() == PREFIX##_OPTYPE_ID)                \
        {                                                       \
            return (PREFIX##_Node *) this;                      \
        }                                                       \
        return 0;                                               \
    }

/// This macro allows us to run another macro for all node types
#define INSTANTIATE_FOR_ALL_NODE_TYPES(MACRO_FUNC)              \
    MACRO_FUNC(OBJ)                                             \
    MACRO_FUNC(SOP)                                             \
    MACRO_FUNC(POPNET)                                          \
    MACRO_FUNC(POP)                                             \
    MACRO_FUNC(CHOPNET)                                         \
    MACRO_FUNC(CHOP)                                            \
    MACRO_FUNC(ROP)                                             \
    MACRO_FUNC(SHOP)                                            \
    MACRO_FUNC(COP2)                                            \
    MACRO_FUNC(COPNET)                                          \
    MACRO_FUNC(VOP)                                             \
    MACRO_FUNC(VOPNET)                                          \
    MACRO_FUNC(DOP)

class OP_API OP_Node : public OP_Parameters, public OP_NetworkBoxItem
{
public:
    // Methods to convert our enums and strings:
    static const OP_TypeInfo    *getOpInfoFromOpTypeID(OP_OpTypeId opid);
    static const OP_TypeInfo    *getOpInfoFromOpTypeName(const char *name);
    static const OP_TypeInfo    *getOpInfoFromTableName(const char *name);
    static const OP_TypeInfo    *getOpInfoFromScriptDir(const char *dir);
    
    OP_Network          *getParent()  const { return myParent; }
    
    //Return the network this item resides in (i.e. getParent()). This method
    //was introduced to provide a standardized way of accessing the parent
    //network of all different network box item types.
    virtual OP_Network  *getParentNetwork() const;

    // This function looks up our parent tree to determine if the given node
    // is our parent, grandparent, great-grandparent...
    bool                 getIsContainedBy(const OP_Node *testparent) const;

    /// Return the name of this node's parent
    const UT_String     &getNetName() const;

    /// This returns the OP_OpTypeId which corresponds to this node type.
    /// Management nodes will return the type they really are, which
    /// is likely different than the network they currently reside in.
    virtual OP_OpTypeId  getOpTypeID() const = 0;

    // This is the proper way to determine the optype.
    // Do not assume your parents child type is your type!  This will only
    // become less true as time goes on :>
    // The strings returned are the *_OPTYPE_NAME defined in OP_Network.h
    virtual const char  *getOpType() const = 0;

    virtual OP_ItemType  getItemType() const;
    
    /// @anchor OP_Node_findFOONode
    ///
    /// FOO_Node *findFOONode(const char *path) const; @n
    ///     This function searches for the node at path relative
    ///     to this node.  If not found, or if the found node is
    ///     not of type FOO_Node, it returns NULL.  The result
    ///     is already cast to FOO_Node.
    // @{
    INSTANTIATE_FOR_ALL_NODE_TYPES(INSTANTIATE_FINDNODE_FUNCTIONS)
    // @}

    /// @anchor OP_Node_castToFOONode
    ///
    /// FOO_Node *castToFOONode() const; @n
    ///     This type checks the current node against FOO_Node.
    ///     If the cast is legal, this is returned.  Otherwise, NULL.
    ///     While it likely will do the "right" thing with this == NULL,
    ///     that case is UT_ASSERTed as it is just asking for trouble.
    // @{
    INSTANTIATE_FOR_ALL_NODE_TYPES(INSTANTIATE_CASTNODE_FUNCTIONS)
    // @}

    /// Obtain the node's script which is called when it is being deleted.
    const UT_String     &getDelScript(void) const    { return myDelScript; }

    /// Set the node's deletion script. Returns true if the delete script was
    /// set successfully.
    bool                 setDelScript(const char *str);

    /// Accessors for this node's comment string.
    // @{
    const UT_String     &getComment(void) const      { return myComment; }
    bool                 setComment(const char *str);
    // @}
    
    /// Accessors for this node's color in the network view pane
    // @{
    // getColor() used to return a reference, converted it to a pointer so we 
    // can abstract this method up to OP_NetworkBoxItem and allow item types 
    // without colors to simply return NULL
    virtual const UT_Color *getColor() const    { return &myColor; }
    virtual bool            setColor(const UT_Color &col);
    // @}

    /// Node position/scale is used by the UI.
    // @{
    // These are in absolute coordinates, not the UI coordinates found in
    // OPUI_Worksheet, though.
    virtual void         setXY(fpreal x, fpreal y);
    virtual fpreal       getX() const { return myPosX; }
    virtual fpreal       getY() const { return myPosY; }
    virtual fpreal       getW() const;
    virtual fpreal       getH() const;
    // @}

    /// Set the node's location like setXY(), but first check if the new
    /// position is valid.  Also update any netboxes containing this node
    /// and send an OP_UI_MOVED event.
    bool                 setXYWithBoundsChecks(fpreal x, fpreal y);

    void                 pickRequest(int shift);
    
    /// Set allow_rel_paths to true to accept "." or ".." as valid paths.
    static int           isValidOpName(const char *s,
                                       bool allow_rel_paths = false,
                                       bool ignore_node_names_env_var = false);
    static int           isValidOpPath(const char *s);
    static bool          forceValidOpName(UT_String &name);

    /// Override these methods so that search-and-replace operations
    /// affect our delete script as well as our parameters.
    // @{
    virtual int          findString(const char *str, bool fullword,
                                    bool usewildcards) const;
    virtual int          changeString(const char *from, const char *to,
                                      bool fullword);
    // @}
    
    //  These are no-ops for nodes but will be implemented for networks:
    virtual int          getNchildren() const;
    virtual OP_Node     *getChild(const char *name, int *hint=0) const;
    virtual OP_Node     *getChild(int index) const;
    void                 getPickedChildren(OP_NodeList &picked,
                                           bool include_hidden=false) const;
    void                 getAllChildren(OP_NodeList &children) const;
    virtual OP_Node     *matchChild(const char *pattern, OP_Node *prevmatch=0,
                                        const char *optype=0,
                                        int casesensitive = 0) const;
    virtual OP_Node     *matchChildBackwards(const char *pattern,
                                        OP_Node *prevmatch=0,
                                        const char *optype=0,
                                        int casesensitive = 0) const;
    virtual OP_Network  *createProxyRefNode( const char *path );

    // Returns the node with the requested unique integer identifier.
    static OP_Node      *lookupNode(int unique_id, bool include_proxy=false)
                         {
                             if( unique_id >= 0 && unique_id <= theUniqueId
                                     && theUniqueNodes[unique_id] )
                             {
                                 if( include_proxy || !theUniqueNodes[unique_id]
                                                           ->isProxyRefNode() ) 
                                     return theUniqueNodes[unique_id];
                             }
                             return 0;
                         }
    // Fills the provided array with every node that currently exists.
    static void          getAllNodes(OP_NodeList &nodes);

    int                  getUniqueId() const
                         { return myUniqueId; }

    // The following function will take a standard pattern and expand
    // all the groups out of the pattern, leaving a simple pattern
    // in the result.
    bool                 expandGroupPattern(const char *pattern,
                                            UT_String &result,
                                            bool expandToFullPaths = false);

    // The following methods take a standard pattern and return whether
    // the pattern contains the specified bundle or group.
    bool                 patternContainsBundle(const char *pattern,
                                               const OP_Bundle *bundle) const;
    bool                 patternContainsGroup(const char *pattern,
                                              const OP_Group *group) const;

    virtual int          isManager() const;
    // This differs from isManager.  Managers are the old school static
    // things which are always present in fixed directories.  Management
    // nodes are managers that are in the wrong directory.
    virtual int          isManagementNode() const;
    // This is a bit broader than management nodes.  These nodes may
    // be in the right directory, but represent an unexpected change
    // of directory type, so need to be tracked so our tree filter
    // will know about them.
    bool                 isEffectivelyAManagementNode() const;

    // This function checks if the node is a subnet. Now that we can have
    // NWN subnets (object subnets, vopnet subnets), we need to explicitly
    // specify if these types of subnets count. In some cases we want them
    // to count (such as checking for VOPNET subnets to see if we can
    // generate code, or SHOP subnets to see if we can save to a palette).
    // In other cases we want to exclude these management ops (such as
    // when deciding to show the "Create Type From" menu item or checking
    // if we can do an opwire -i command).
    virtual int          isSubNetwork(bool includemanagementops) const;
    virtual int          isNetwork() const;
    virtual int          isInSubNetwork() const;

    bool                 isProxyRefNode() const
                            { return myIsProxyRefNode; }
    void                 setProxyRefNode(bool f)
                            { myIsProxyRefNode = f; }

    // isNetworkWithKids() will return 1 if the node is a network and the
    // operator table for the node contains children which can be added to the
    // node.
    int                  isNetworkWithKids() const;

    virtual int          isVex() const;

    // methods for managing the bundles we depend on in so that any change to
    // the bundle in which we are interested triggers bundleChange call.
    // NB: getParmBundle methods find or create a bundle ad it to the
    //     internal list of referenced bundles
    OP_Bundle *          getParmBundle(const char* parm_name, int vector_index,
                                UT_String &pattern, OP_Network *creator,
                                const char *filter);
    void                 markBundleRefsAsUnused();
    void                 cleanUnusedBundleRefs();
    void                 cleanAllBundleRefs();

    // The bundleChanged() method is called whenever a bundle referenced by the
    // OP is changed.  The bundle is passed to the OP to let the OP know that
    // it's out of date.  The function should return 1 if the event was handled
    // properly or 0 if it failed.  The return codes are used for debugging
    // only.
    virtual bool         bundleChanged(const OP_Bundle *bundle);
    // If a bundle changes, you should call this method to touch the parameter
    // which the bundle affects.  The name is the token of the parm.
    void                 touchBundleParm(const char *name);
    void                 touchBundleParm(int parm_index);

    // Function to determine if Display and Render node ptrs are the same
    virtual int          getDandROpsEqual() { return 1; }
    // Function to update info about whether Render and Display node ptrs
    // are the same. Recurses tree and updates all kids values.
    virtual int          updateDandROpsEqual(int = 1) { return 1; }

    int                  isAncestor(const OP_Node *node,
                                    int checkextra=1) const;

    // Get the info text for this op. This non-virtual function does
    // all the stuff common to all operator types.
    const char          *getInfoText(OP_Context &context, int verbose,
                                     int max_separator_length = -1);
    // Get Info Text that is specific to this node type.
    virtual void         getNodeSpecificInfoText(OP_Context &context,
                                                 int verbose,
                                                 UT_WorkBuffer &text);

    /// Uses the path (eg. "/obj/geo1") to find a node in our heirarchy
    OP_Node             *findNode(const char *path) const;

    /// Same as findNode() except it will return NULL if the path is to a node
    /// that is either not a descendent of this node, or if it isn't the same
    /// type as our children.
    OP_Node             *findSubNode(const char *path) const;
    
    /// Implemented in OP_Network, but put here as a virtual to make working
    /// with hscript easier so that it can be called directly on an op node
    virtual OP_NetworkBox     *findNetworkBox(const char * /*name*/)
                               { return NULL; }

    /// Implemented in OP_Network, but put here as a virtual to make working
    /// with hscript easier so that it can be called directly on an op node
    virtual OP_PostIt* findPostItNote(const char * /*const_path*/)
                                { return NULL; }
    
    /// Same as findNode or findNetworkBox, but more generalized so you can 
    /// search through multiple items with just one method. 'item_type_mask' is
    /// used to specify what type of items you want to consider in your search.
    virtual OP_NetworkBoxItem *findItem(const char *const_path, 
                                        OP_ItemTypeMask item_type = 
                                        OP_ITEMTYPE_ALL);

    // These functions will adhere to certain conventions, such as a reference
    // to an object actually means a reference to the display or render
    // guy in that object.  This will also check this->isCookingRender
    // to determine if it should auto-use the Render or Display.
    // These will not fail if the returned node is the node itself.
    SOP_Node            *getSOPNode(const char *path, int addextra = 0) const;
    // This method will use the render node of the composite network if
    // it is a comp rather than a cop2 that is pointed to...
    COP2_Node           *getCOP2Node(const char *path, int addextra = 0) const;
    // And this one will also use the render node, which corresponds to the
    // cook node in POPs land.
    POP_Node            *getPOPNode(const char *path, int addextra = 0) const;
    // And this one will use the display node, which corresponds to the
    // cook node in DOPs land.
    DOP_Node            *getDOPNode(const char *path, int addextra = 0) const;
    ROP_Node            *getROPNode(const char *path, int addextra = 0) const;
    
    /// Returns the full operator path of this node
    virtual void         getFullPath(UT_String &str) const;

    /// Returns the path of this node relative to its getCreator()
    virtual void         getPathWithSubnet(UT_String &str) const;

    /// Returns the path of this node relative to 'base_node'
    void                 getRelativePathTo(const OP_Node *base_node,
                                           UT_String &result) const;

    /// This will try to complete the path by finding the longest suffix
    /// that will work with the given prefix.  It will only complete up
    /// to the next child.  If it finds a valid child, it will append
    /// a slash (/).
    void                 completePath(const char *prefixpath, 
                                      UT_String &completepath) const;

    virtual CH_Channel  *getTrackChannel(const char *name);

    virtual bool         findParmFromTrack(float t, const char *trackname,
                                           OP_NodeParmRefCycle &cycle,
                                           OP_Node *&node,
                                           PRM_Parm *&parm, int &vecidx);

    // Batch evaluation of named parameters.  This method requires extra lookup
    // since parameters are specified by names, but it can handle generic
    // parameter layout.
    virtual void         evaluateBatchParms(PRM_BatchList &list, double now); 

    // Do global expansion on a pattern - get lists of channels or nodes
    // If expand is given, concatenated with full list of names
    // If list is given, appended with list of nodes.
    // If dependent given, addExtraInputs.
    void                 globNodes(const char *pat, UT_String *expand,
                                        UT_PtrArray<OP_Node *> *list=0,
                                        OP_GlobContext *context = 0,
                                        const char *prefix = " ");

    CH_Channel          *findChannel(const char *path);
    void                 globChannels(const char *, UT_String &expand,
                                        OP_GlobContext *context = 0,
                                        const char *prefix = " ") const;

    void                 globChannels(const char *pattern,
                                      CH_ChannelList &clist,
                                      OP_GlobContext *context = 0,
                                      OP_Node *dependent = 0);

    void                 globChanRefs(const char *pattern,
                                      CH_ChannelRefList &list,
                                      OP_GlobContext *context = 0,
                                      OP_Node *dependent = 0);

    int                  globParms(const char *pattern, float t,
                                   UT_RefArray<opParmData> &list,
                                   OP_GlobContext *context = 0,
                                   OP_Node *dependent = 0,
                                   int calc_value = 1);

    // this version only globs the current node
    void                 globNodeParms(const char *pattern, float t,
                                       UT_RefArray<opParmData> &list,
                                       OP_GlobContext *context,
                                       OP_Node *dependent,
                                       int calc_value,
                                       bool animated_only);

    // this version only globs the current node
    void                 globNodeChannels(const char *pattern,
                                          CH_ChannelList &list,
                                          OP_GlobContext *context,
                                          int *parm_start = NULL,
                                          UT_IntArray *parm_indices = NULL
                                          ) const;

    // this version only globs the current node
    void                 globNodeChanRefs(const char *pattern,
                                          CH_ChannelRefList &list,
                                          OP_GlobContext *context,
                                          int *parm_start = NULL,
                                          UT_IntArray *parm_indices = NULL
                                          ) const;

    ///Same as 'globNodes', except for network boxes. This is to be implemented
    ///by OP_Network, but has been put here so it can be called directly on 
    ///OP_Node like all the other "glob" methods without a cast
    virtual void         globNetworkBoxes(const char *pat, UT_String *expand,
                                    UT_PtrArray<OP_NetworkBox *> *list=0,
                                    OP_GlobContext *glob_context = 0,
                                    const char *prefix = " ");

    virtual void         globPostIts(const char *pat, UT_String *expand,
                                    UT_PtrArray<OP_PostIt *> *list=0,
                                    OP_GlobContext *glob_context = 0,
                                    const char *prefix = " ");

    // Fetch all channels from this node on down.
    int                  getAllChannels(CH_ChannelList &list, int scoped=0);

    // If you override opChanged() in a sub-class, you must call
    // the OP_Node base method from the sub-class method
    virtual void         opChanged(OP_EventType reason, void *data=0);

    // If you override opChanged() in a subclass, you should first call
    // opShouldHandleChange() before taking any custom action.
    virtual bool         opShouldHandleChange(OP_EventType reason);

    // This function is called whenever we have a parameter that references
    // another parameter, and that referenced parameter changes. The pi
    // value is the index of the parameter containing the reference.
    virtual void         referencedParmChanged(int pi);

    /// Mark this node as needing a full recook.
    /// If 'evensmartcache' is true, a recook will occur even if all the
    /// parameters match in this node and all its inputs (only valid for
    /// COP2_Node). 
    virtual void         forceRecook(bool evensmartcache = true);

    /// This method causes any operators that load files to recook.
    /// By default, this searches for 'file' operators by iterating through
    /// inputs. Parms of type PRM_FILE are also marked dirty. Other nodes that
    /// load files differently may wish to override this method.
    virtual void         reloadExternalFiles();

    /// Determines if this node needs to cook.
    ///
    /// The queryonly flag will not flag this as a read attempt to the
    /// caching mechanisms, and thus not update the touch time.
    virtual unsigned     needToCook(OP_Context &context, bool queryonly=false);

    /// Cook this node's data. Returns true upon success, false otherwise.
    ///
    /// Upon failure, use OP_Parameters::error() and
    /// OP_Parameters::getErrorMessages() to determine reason.
    virtual bool         cook(OP_Context &context);

    /// Schedule a task for cooking this node in parallel and wait for it to
    /// finish. Returns true upon success, false otherwise.
    bool                 parallelCook(OP_Context &context);

    /// Cook the given node list in parallel
    static bool          parallelCook(OP_Context &context,
                                      const OP_NodeList &nodes);

    /// The cook lock is used to protect per node data structures during
    /// cooking. Use it in the following idiom:
    /// @code
    /// OP_CookLock::Scope scope(getCookLock(), /*acquire=*/false);
    /// if (!lockForCooking(scope))
    /// {
    ///     UTaddDeadlockError();
    ///     return false;
    /// }
    /// @endcode
    // @{
    OP_CookLock &        getCookLock()  { return myCookLock; }
    bool                 lockForCooking(OP_CookLock::Scope &scope);
    // @}

    OP_TaskState &       taskState()        { return myTaskState; }
    const OP_TaskState & taskState() const  { return myTaskState; }

    // This normally chains to cookInputGroups.
    // Some networks, such as SOPs, use it to be able to
    // properly lock their gdp pointer around the cook.
    virtual OP_ERROR     pubCookInputGroups(OP_Context &context, int alone = 0);

    void                 bumpVersionParm()     { myVersionParms++; }
    int                  cookParmsModified() const
                         { return myVersionParms != myVersionCache; }

    // The data class of an OP is currently used solely for networks which
    // contain heterogeneous node types (i.e. used in SHOP networks to
    // distinguish different shader types).  A data class of 0 is returned by
    // default.
    // A value of 0 is returned by default.
    virtual int          getDataClass() const;

    // The xform order for how to interpret the given channel.  Default
    // is XYZ.
    virtual void         getXformOrder(UT_XformOrder &xord, CH_Channel *chp);

    // "getCookedData" should return a void * version of the results of
    // the cook. NULL if it fails with appropriate stuff in our error manager.
    virtual OP_DATA_TYPE getCookedDataType() const = 0;
    virtual void        *getCookedData(OP_Context &);
    virtual void         deleteCookedData() = 0;
    
    // This queries whether the given context has cache data associated with
    // it.  It avoids actually marking the data as read.
    virtual bool         hasCookedData(OP_Context &);

    virtual int          saveCookedData(ostream &os, OP_Context &,
                                        int binary = 0) = 0;
    virtual bool         loadCookedData(UT_IStream &is, const char *path=0);
    virtual int          saveCookedData(const char *filename, OP_Context &) = 0;

    /// Get the transform from this node's space to the 'to' node's space.
    /// Returns 1 if this was possible, 0 otherwise (e.g. failure to cook).
    virtual int          getRelativeTransform(OP_Node &to, UT_Matrix4 &xform,
                                              OP_Context &context);
    virtual int          getRelativeTransform(OP_Node &to, UT_DMatrix4 &xform,
                                              OP_Context &context);
    // overrides for OPs that can capture (right now only OBJ_Bone)
    virtual int          getRelativeCaptureTransform(OP_Node &to, 
                                              UT_Matrix4 &xform,
                                              OP_Context &context);
    virtual int          getRelativeCaptureTransform(OP_Node &to, 
                                              UT_DMatrix4 &xform,
                                              OP_Context &context);
    virtual void         getRotations(float, float &, float &, float &);

    // these next two are the minimal overrides for subclasses that have
    // transforms (see OBJ_Node)
    virtual int          getWorldTransform(UT_DMatrix4 &xform, OP_Context &);
    virtual int          getIWorldTransform(UT_DMatrix4 &xform, OP_Context &);
    // these next two version simply call the virtual versions that take a
    // UT_DMatrix4, except converting it to UT_Matrix4
    int                  getWorldTransform(UT_Matrix4 &xform, OP_Context &);
    int                  getIWorldTransform(UT_Matrix4 &xform, OP_Context &);

    /// Registers an error for cooking the given node's transform. If label is
    /// supplied, then it will be used as a label of the transform error.
    void                 addTransformError(const OP_Node &node,
                                           const char *label=0) const;

    // Compute the bounding box for the operator (if applicable).  If the box
    // could be computed, return true, else return false.
    virtual bool        getBoundingBox(UT_BoundingBox &box, OP_Context &);

    // This is used by VOPNETs to determine which table needs to be
    // refreshed when they change.
    virtual const char  *getInternalOpTable() const 
                         { return INVALID_TABLE_NAME; }
    virtual OP_Operator *getInternalOperator() const
                         { return 0; }

    // this one is here so that SOP_Skeleton can use an OBJ_Bone method.
    virtual void         stashCaptureAngles(float time);

    virtual const char  *inputLabel(unsigned idx) const;
    virtual const char  *outputLabel(unsigned idx) const;

    // returns a label that is applied to the drawn connector. NULL may be
    // returned as 'no label'.
    virtual const char  *inputConnectorLabel(unsigned idx);
    
    // if true, the connector to the input will be dashed rather than solid.
    virtual int          isRefInput(unsigned ) const            { return 0; }

    // find out if the node has any reference outputs, ie nodes which will
    // return true at least once from isRefInput(). Continue recursing down if
    // no ref outputs have been found and if the current node is not built
    // explicitly (if recurse_on_implicits is true).
    bool                 hasRefOutputs(bool recurse_on_implicits = false) const;

    // returns the index of the auxilary input, if any (currently only used
    // for the mask inputs in COPs).
    virtual int          getAuxInput() const;
    
    //  The lock method is used to lock the OP.
    //  Returns the previous state of the lock flag.
    //
    // Note that to mimic the behaviour of the lock button, you MUST
    // call setModelLock, not setLock, or your next unlock won't have
    // a cached data.
    int                  setLock(int state, int saveundo = 1);
    int                  getSoftLock() const {return flags().getSoftLocked();}
    int                  getHardLock() const {return flags().getHardLocked();}
    int                  getLock() const     {return flags().getLocked(); }
    // getNetworkLock() checks to see if the OP is effectively locked by
    // the network, i.e., each of the OPs output branches connect to a locked
    // OP down the network. Returns > 0 if locked, <= 0 if unlocked.
    // When relaxedlockcheck is set, subnet branches that are not displayed
    // are ignored.
    int                  getNetworkLock(bool relaxedlockcheck = false,
                                        const OP_Node *inputNode = NULL) const;
    //  The Model lock is similar to the normal lock but will also cause
    //  the node data to be saved.
    virtual int          setModelLock(int on_off, 
                                      void *modeler = 0,
                                      int allow_softlock_promotion=0,
                                      UT_Undo *undo = 0);
    int                  getModelLock() const;

    // The unload flag triggers whether we keep the ops data around
    // after a cook or discard it as soon as its not needed.  Its currently
    // only implemented in CHOPs.
    int                  setUnload(int on_off);
    int                  getUnload() const;

    // Returns whether this node has data loaded into it.
    virtual bool         isLoaded() const { return true; }

    // This will explicitly delete all data associated with the OP
    // false is returned if no data was deleted (ie, OP is in use, etc)
    // Only works with SOPs now.
    virtual bool         unloadData();

    // Take control for flags
    void                 takeActivateFlag(uchar flag, bool enable=true,
                                          bool send_flag_event=true);
    void                 takeDeactivateFlag(uchar flag)
                         { takeActivateFlag(flag, false); }
    bool                 takeIsActiveFlag(uchar flag) const;
    void                 setHasTakeData(int onoff);

    bool                 canAccessFlag(unsigned mask, uchar flag) const;

    // The template flag indicates that the node date should be displayed
    // The display & render flags indicate that the node is turned on
    // for display purposes or for rendering purposes, which may take
    // on different meanings per node type.
    // Setting save data only has meaning for some node types.
    virtual int          setPicked(int on_off, 
                                   bool propagate_parent_event = true);

    /// The edit flag is used whenever something is picked
    /// from the viewport. This causes the pane paths to
    /// be changed to the first writable parent of the
    /// node being picked.
    int                  setEditPicked(int on_off, 
                                   bool propagate_parent_event = true);

    void                 setAutoscope(bool on_off) { myAutoscope = on_off; }
    bool                 isAutoscope() { return myAutoscope; }

    int                  setCurrent(int on_off);
    int                  setExpose(int on_off);
    int                  setBypass(int on_off);
    int                  setTemplate(int on_off);
    int                  setFootprint(int on_off);
    int                  setXray(int on_off);
    int                  setDisplay(int on_off);
    int                  setRender(int on_off);
    int                  setHighlight(int on_off);
    int                  setModified(int on_off);
    int                  setSaveBypass(int on_off);
    int                  setSaveData(int on_off);
    // these are for subclasses to implement, they do nothing by default
    virtual int          setPickable(int on_off);
    virtual int          setAudio(int on_off);
    virtual int          setExport(int on_off);
    virtual int          setDebug(int on_off);

    /// The user has set the template flag. If we are turning on the template
    /// flag, we do the same as setTemplate(). If we are turning it *off*,
    /// we also turn off the selectable template (footprint) flag.
    void userSetTemplate(bool onoff);

    /// The user has set the selectable template flag. If we are making a node
    /// into a selectable template, we turn on the template flag as well.
    /// If we are turning off selectable template, we leave template alone.
    void userSetSelectableTemplate(bool onoff);

    // Here are the generalised versions, they add a bit of overhead to
    // the code because of the big switch statement.
    virtual int          setFlag(char tag, int on_off);
    virtual int          getFlag(char tag) const;

    virtual int          getPicked()   const  {return flags().getPicked(); }
    virtual int          getEditPicked() const
                                        { return flags().getEditPicked(); }
    int                  getCurrent()  const;
    int                  getDisplay()  const  {return flags().getDisplay(); }
    int                  getRender()   const  {return flags().getRender(); }
    int                  getHighlight()const  {return flags().getHighlight();}
    int                  getBypass()   const  {return flags().getBypass(); }
    int                  getTemplate() const  {return flags().getTemplate(); }
    int                  getFootprint() const {return flags().getFootprint(); }
    int                  getXray() const      {return flags().getXray(); }
    int                  getExpose()   const  {return flags().getExpose(); }
    int                  getModified() const  {return flags().getModified(); }
    int                  getSaveBypass() const{return flags().getSaveBypass(); }
    int                  getSaveData() const  {return flags().getSaveData(); }
    virtual int          getHasTakeData() const
                                        { return flags().getHasTakeData(); }
    virtual int          getPickable();
    virtual int          getAudio() const;
    virtual int          getExport() const;
    virtual int          getDebug() const;
    OP_Node             *getPickableSelfOrParent();

    // Methods to allow sub-classes extra flags
    virtual void         setExtraFlag(char, int) {}

    //  The following method is used by sub-classes to piggy-back onto the
    //  opset command.  Currently, only OBJ_Node uses this to set the axis
    //  flag.  The flag is 1 to turn it on, 0 to turn it off, -1 if nothing
    //  needs to be changed.
    virtual void         setExtraFlags(int axis);

    // The compress flag indicates that the OP connector should be displayed
    // in a compressed UI. In ICE this means don't display the mini raster
    // image.
    int                  setCompress(int on_off);
    int                  getCompress() const;

    // This method sets this node as the current and picked node and correctly
    // adjusts the picked states of the other sibling nodes.
    void                 setCurrentAndPicked();          

    // setVisible() simply calls setDisplay() at this level but subclasses
    // override this to perform smarter behaviour. Objects for example will
    // try to set the display flag on parent subnets and change visible object
    // parameters as necessary.
    // Returns true if it was successful, false if there were not sufficient
    // permissions.
    virtual bool         setVisible(int onoff);
    virtual bool         getVisible() const;

    // Note: This is a covariant return type overload from OP_NetworkBoxItem.
    // OP_NodeFlags inherits from OP_NetworkBoxItemFlags, so we can return an
    // OP_NodeFlags from our implementations of flags().
    virtual const OP_NodeFlags  &flags() const
    { return static_cast<const OP_NodeFlags &>(OP_NetworkBoxItem::flags()); }
    virtual OP_NodeFlags        &flags()
    { return static_cast<OP_NodeFlags &>(OP_NetworkBoxItem::flags()); }

    virtual void         getSaveFlagsString(UT_String &cmd,
                                            const char *flags,
                                            bool save_to_hip) const;
    virtual void         getPreParmSaveFlagsString( UT_String &cmd ) const;
    virtual void         getPostParmSaveFlagsString( UT_String &cmd ) const;

    int                  hasOpInterest(void *data, OP_EventMethod m) const
                             { return myEventValue.hasOpInterest(data, m); }
    void                 addOpInterest(void *data, OP_EventMethod m)
                             { myEventValue.addOpInterest(data, m); }
    void                 removeOpInterest(void *data, OP_EventMethod m)
                             { myEventValue.removeOpInterest(data, m); }
    int                  isBeingDeleted() const
                             { return myBeingDeleted; }
    void                 setNodeBeingDeleted(int beingdeleted);

    /// Move the upper-left most node in 'ops' to x-coordinate 'x' and to have
    /// its TOP border at y-coordinate 'y', and move all other nodes in 'ops'
    /// by the same amount. All netboxes in 'netboxes' will also be moved that
    /// amount. If a netbox's top border is higher than any node's top border,
    /// everything will be moved down accordingly. Note that the repositioning
    /// calculation does not include the nodes contained in the network boxes
    /// in 'netboxes'.
    static void          repositionOpsMaxY(OP_NodeList &ops, 
                                        UT_PtrArray<OP_NetworkBox *> &netboxes, 
                                        float x, float y);

    /// Minimum inputs that must be connected to a node for it to cook.
    virtual unsigned     minInputs() const;

    /// Maximum inputs that can be connected to a node.
    virtual unsigned     maxInputs() const;

    /// Number of input connectors that should be visible on a node. This is
    /// only used by VOPs and DOPs. All other OPs return maxInputs() here.
    virtual unsigned     getNumVisibleInputs() const;

    /// Returns the number of ordered inputs on a node with unordered inputs.
    /// Even nodes with unordered inputs can have a few ordered inputs before
    /// the unordered inputs start. If hasUnorderedInputs returns false, this
    /// function is meaningless.
    virtual unsigned     orderedInputs() const;

    /// Maximum number of output connectors on a node. Only VOPs and DOPs ever
    /// return a value other than 1 here.
    virtual unsigned     maxOutputs() const;

    /// Number of output connections that should be visible on a node tile.
    /// Only used by VOPs and DOPs.
    virtual unsigned     getNumVisibleOutputs() const;

    /// Returns true if the operator type says we have unordered inputs.
    bool                 hasUnorderedInputs() const;

    /// Size of myInputs array. Note that this array may contain null entries,
    /// so this is not necessarily the same as the number of connections.
    virtual unsigned     nInputs() const { return myInputs.entries(); }

    // The number of nodes actually connected to this node. This function
    // goes through the myInputs array and counts non-null entries.
    unsigned             nConnectedInputs() const;

    unsigned             getActiveInputIndex() const
                         { return myActiveInputIndex; }
    void                 setActiveInputIndex(unsigned idx);

    /// Returns the node connected to a particular input (may be null).
    OP_Node             *getInput(unsigned idx, bool mark_used=false) const;

    /// Returns the first non-null input beyond the specified starting index.
    /// This function can be used to easily loop through all connected inputs.
    int                  getConnectedInputIndex(int startAt = -1) const;

    /// Gets the index of the Nth non-null connection to this node.
    int                  getNthConnectedInput(int n) const;

    /// Override this to specify the inputs which are needed for cooking this
    /// node which can be executed in parallel.
    virtual void         getParallelInputs(OP_Context &context,
                                           OP_NodeList &nodes) const;

    /// Sets a given input to connect to an output of a particular node.
    virtual OP_ERROR     setInput(unsigned idx, OP_Node *op,
                                  unsigned outputIdx = 0);

    /// Connects an input to an indirect input of our parent subnet.
    virtual OP_ERROR     setIndirectInput(unsigned idx,
                                          OP_InputIndirect *input);

    /// Connects an input to particular node by name in the network.
    virtual OP_ERROR     setInputReference(unsigned idx, const char *label,
                                           int keeppos, unsigned outputIdx = 0);

    /// Returns the index of the first connection from node "who" to this node,
    /// or -1 if "who" is not an input.
    int                  whichInputIs(const OP_Node *who) const;

    /// Returns the index of the first connection of an indirect input.
    int                  whichInputIs(const OP_InputIndirect *who) const;

    // Returns the index of the Nth connection of an idirect input.
    int                  whichInputIs(const OP_InputIndirect *whoi, int cnt) const;

    // Extra inputs are non-wire based dependencies that this node has.
    // Access to this array has to be serialized so always use
    // getLockedExtraInputs() to do this.
    OP_LockedExtraInputs
    getLockedExtraInputs()
    {
        return OP_LockedExtraInputs(myExtraInputsList, myExtraInputsLock);
    }
    OP_LockedConstExtraInputs
    getLockedExtraInputs() const
    {
        return OP_LockedConstExtraInputs(myExtraInputsList, myExtraInputsLock);
    }
    void getExtraInputsCopy(OP_SimpleExtraInputArray &extra_inputs) const
    {
        OP_Lock::Scope lock(myExtraInputsLock);

        for (int i = 0; i < myExtraInputsList.entries(); i++)
        {
            extra_inputs.append(
                OP_SimpleExtraInput(myExtraInputsList(i)->getNode(),
                                    myExtraInputsList(i)->getInterestType()));
        }
    }
    void getExtraInputNodes(OP_NodeList &extras) const
    {
        OP_Lock::Scope lock(myExtraInputsLock);

        for (int i = 0; i < myExtraInputsList.entries(); i++)
            extras.append(myExtraInputsList.getExtraInput(i));
    }

    // Returns an index of the output which goes out from this node to the target_node,
    // and connects to the target_node at the specified input index.
    // Returns -1 if the connection doesn't exist.
    int  whichOutputIs(OP_Node* target_node, int input_on_target_node);

    // Returns the index of an input into which source_node is connected
    // on this node. counter determines the Nth such connection from 
    // source node to this particular node.
    int whichInputIs(OP_Node* source_node, int counter);

    // Compacts the inputs array, removing all null entries.
    void                 consolidateInputs();
    virtual void         clearUnreferencedInputs();
    virtual OP_Input    *getInputReference(unsigned idx, int grow=1);
    virtual OP_Input    *getInputReferenceConst(unsigned idx) const;
    virtual int          doDeleteRewire() const { return 1; }
    // This moves the input at srcidx to dstidx.  forcesubnet will enable
    // modificatio of subnet inputs and outputs even when inside a
    // blockModify().
    virtual void         moveInput(int srcidx, int dstidx,
                                   bool forcesubnet = false);
    OP_ERROR             insertInput(unsigned idx, OP_Node *op,
                                     unsigned outputIdx);
    OP_ERROR             insertIndirectInput(unsigned idx,
                                             OP_InputIndirect *input);

    /// Declares that this node depends on the @c op parameter for the given
    /// reason.
    /// @note This method is deprecated for OP_INTEREST_NAME.
    /// @warn This method assumes that getCookLock() has already been acquired!
    virtual void         addExtraInput(OP_Node *op, OP_InterestType type);

    // addExprOpDependency is a helper function for building dependencies for
    // the expression library callback functions.
    static void          addExprOpDependency(const char *arg_str,
                                             const PRM_RefId &ref_id,
                                             OP_InterestType interest_type);
    static void          addExprOpDependency1From2(const char *arg_str1,
                                             const char *arg_str2,
                                             const PRM_RefId &ref_id,
                                             OP_InterestType interest_type);
    static void          addExprOpParmDependency(const char *arg_str,
                                                 const PRM_RefId &ref_id,
                                                 OP_InterestType interest_type);
    // NB: is reponsible for freeing new_arg!
    static void          changeExprOpRef(const char *arg_str,
                                         char *&new_arg,
                                         const char *new_fullpath,
                                         const char *old_fullpath,
                                         const char *old_cwd);
    // NB: is reponsible for freeing new_arg!
    static void          changeExprOpRef1From2(const char *arg_str1,
                                         const char *arg_str2,
                                         char *&new_arg1,
                                         char *&new_arg2,
                                         const char *new_fullpath,
                                         const char *old_fullpath,
                                         const char *old_cwd);
    // NB: is reponsible for freeing new_arg!
    static void          changeExprOpParmRef(const char *arg_str,
                                             char *&new_arg,
                                             const char *new_fullpath,
                                             const char *old_fullpath,
                                             const char *old_cwd,
                                             const char *chan_name,
                                             const char *old_chan_name);

    void                 addGenericOpNameReference( const UT_String &oppath );
    void                 addGenericOpNameReference( const PRM_RefId &ref_id,
                                                    OP_Node *node );

    static void          moveAndUpdateDependencies( 
                            const OP_NodeList &src_nodes,
                            const OP_NodeList &dest_nodes );

    static void          updateChannelPtrs( CH_CollectionList &parents );

    // Make this function public so it can be called by OPUI_EditSubnet
    // and possibly others. Note that it is defined in PRM_ParmOwner so
    // that it can be called from the PRM library.
    virtual void         rebuildParmDependency( int parm_index );

    // Clear op name dependencies
    virtual void         clearParmDependency( int parm_index );
    // decrementOpReference() should only be called by clearParmDependency()
    void                 decrementOpReference(int node_id);

    virtual void         dumpDependencies();
    void                 dumpOpDependents(OP_Node *ref, int brief, ostream &os);
    int                  countReferences(int op_id);
    // NB: This function assumes that refs is sorted without duplicate entries!
    void                 getExistingOpReferences(OP_NodeList &refs,
                                                 bool recurse);
    // NB: This function assumes that deps is sorted without duplicate entries!
    void                 getExistingOpDependents(OP_NodeList &deps,
                                                 bool recurse);
    UT_RefArray<OP_Dependency>  &getOpDependents() { return myOpDependents; }

    // Gets a list of parms that reference one of our channels/parms.
    void                 getParmsThatReference(const char *channame,
                                               UT_PtrArray<PRM_Parm *> &parms,
                                               UT_IntArray &parmsubidxs);

    virtual void         inputConnectChanged(int which);

    // The number of nodes this node's output is connected to. If outputIdx
    // is >= 0, only those nodes connected to that specific output are
    // considered. Otherwise the total of all outputs is returned.
    unsigned             nOutputs(int outputIdx = -1) const;
    // Returns the "idx"th node connected to our output.
    OP_Node             *getOutput(unsigned idx, int outputIdx = -1);
    // Returns a const pointer to the "idx"th node connected to our output.
    const OP_Node       *getOutput(unsigned idx, int outputIdx = -1) const;

    // Obtain a locked copy of the extra outputs. ie. nodes which have this
    // node as an extra input.
    OP_LockedNodeList
    getLockedExtraOutputs()
    {
        return OP_LockedNodeList(myExtraOutputsList, myExtraOutputsLock);
    }
    OP_LockedConstNodeList
    getLockedExtraOutputs() const
    {
        return OP_LockedConstNodeList(myExtraOutputsList, myExtraOutputsLock);
    }

    /// Obtain the list of outputs from this node. If any of them are subnets,
    /// this function will return the actual connected node inside them.
    void                 getNonSubnetOutputs( OP_NodeList &nodes ) const;

    // obtains an output node that leads to a target node (e.g., during network
    // traversal). Null if target is not a descendent. 
    OP_Node             *getOutputTowardsNode( const OP_Node *target );

    /// Fill in 'tree' with details that are common to all node types. Then call
    /// fillInfoTreeNodeSpecific() to get specific details about this specific
    /// node (be it a SOP, CHOP, etc)
    void                 fillInfoTree(UT_InfoTree &tree, float time);

    /// Triggered by 'fillInfoTree()', this virtual function adds all node-
    /// specific info to 'tree'. All child classes must create their own 
    /// branches under 'tree' to place their info
    virtual void         fillInfoTreeNodeSpecific(UT_InfoTree &tree,float time);

    /// This method has to do with 'fillInfoTree()' above. When the call to 
    /// fillInfoTree() completes, the UT_InfoTree 'tree' will be parsed and 
    /// displayed in a dialog box by OPUI_OpInfoDialog, at which point, that 
    /// class will want to ask us - which branch of the tree would you like to
    /// be selected by default when the dialog is displayed for the first time?
    virtual const char  *getDefaultSelectedInfoTreeBranchName() const;
    
    //  These methods get input data for the OP.  If they return an error code
    //  >= UT_ERROR abort, then the errno should be set, and there may be a
    //  further local error message.  There is no error checking to ensure that
    //  each locked source is only released once, so it's up to the user.  The
    //  standard method is to call lockInputs(), then call unlockInputs() on
    //  exit.  However, in some cases (i.e. switch SOP) only some sources need
    //  to be cooked.
    //
    //  lockInput() will return an error code >= UT_ERROR iff idx <
    //  minInputs().  Otherwise, it's considered to be an optional input, so no
    //  data will be returned.  A simple rule of thumb:  If lockInput() returns
    //  ok, the source has to be unlocked, otherwise it shouldn't be unlocked!
    //  If lockInputs() detects an error, it will automatically unlock the
    //  inputs so that unlockInputs() should NOT be called!
    virtual OP_ERROR       lockInput(unsigned idx, OP_Context &context);
    virtual void         unlockInput(unsigned idx);
    virtual OP_ERROR       lockInputs(OP_Context &context);
    virtual void         unlockInputs(void);

    //  This "serial" number refers to the number of times that the geometry
    //  had been changed.  Note, only the "modeller" should bump the cook count,
    //  the OP cook method does this also, but has privilaged access.
    int                  getCookCount(void) const { return myCookCount; }
    void                 triggerOutputChanged();
    void                 triggerUIChanged();

    //  Returns the index of cooked input to a SOP switch
    virtual int          cookedInputIndex() const { return -1; }

    bool                 setMinimumCacheSize(int min_size);

    OP_VERSION           getVersionParms() const { return myVersionParms; }

    // This will be called if the timeInterest flag is set.
    // This will return true if the node needs to be dirtied for cooking
    virtual bool         handleTimeChange(double /* t */) { return false; }

    /// Returns true if the OP depends on time at the given time.  This
    /// is sensitive to handleTimeChange's overrides.
    bool                 isTimeDependent(OP_Context &context);

    static int           getGlobbedNodes(OP_Node *cwd, UT_String &holder,
                                const char *pattern, UT_WorkArgs &argv,
                                OP_GlobContext *context);
    
    static int           getGlobbedNetworkBoxes(OP_Node *cwd, UT_String &holder,
                                const char *pattern, UT_WorkArgs &argv,
                                OP_GlobContext *context);

    static int           getGlobbedPostIts(OP_Node *cwd, UT_String &holder,
                                const char *pattern, UT_WorkArgs &argv,
                                OP_GlobContext *context);

    // Runs the creation script (if there is one). The return value is false
    // if the node was deleted while running the script. In this case
    // obviously the node pointer becomes invalid and should not be used
    // any more. It returns true if the node still exists.
    virtual bool         runCreateScript();
    // Go through all our parms to match the values to the current hip file
    // units settings.
    void                 updateParmsToMatchCurrentUnits();

    /// Matches the node to the current HDA definition, loading the contents
    /// section if ncecessary and setting the match flag.
    virtual void         matchOTLDefinition();

    /// Unmatches (unlocks) the node from the current HDA definition.
    virtual void         unmatchOTLDefinition();

    /// Returns the error string where we keep all errors generated during
    /// our most recent synchronization attempt.
    const UT_String     &getSyncErrors() const
                         { return mySyncErrors; }
    /// Returns the error level generated in our last synchronization attempt.
    OP_ERROR             getSyncErrorLevel() const
                         { return mySyncErrorLevel; }

    /// Interface to flag that specifies whether or not we match our definition.
    int                  getMatchesOTLDefinition() const;

    /// Utility function for syncing/unsyncing all uncestor nodes.
    static void          propagateMatchOTLDefinitionToAncestors(OP_Node *node,
                                                  bool sync_flag);

    // Some extra functions for dealing with access rights as they relate
    // to matching the OTL definition.
    int                  getCanDeviateFromOTLDefinition() const;
    void                 setAllChildAssetPermissions(int permission);
    // Returns true if this node is contained inside a locked HDA, but
    // is marked as an editable node within that HDA.
    bool                 getIsEditableAssetSubNode() const;

    // Turn off our export flag and the export flags of our children.
    void                 turnOffAllChildExports(void);

    // Collection of methods for working with licensed assets.
    bool                 haveLicenseToAccessContents() const;
    bool                 haveLicenseToAccessParentContents() const;
    bool                 haveAncestorWithoutFullLicense(bool ignore_self) const;
    OP_OTLLicenseType    getLicense() const;
    // Get the first (oldest) ancestor without a license to access contents.
    OP_Node             *getFirstExecLicenseOnlyAncestor(
                                                bool ignore_self = true) const;
    // Get the last (youngest) ancestor without a license to access contents.
    OP_Node             *getLastExecLicenseOnlyAncestor(
                                                bool ignore_self = true) const;

    // Save as a series of ASCII commands.
    void                 saveWires(ostream &os, const char *name, 
                                                int dogeneral = 0);
    void                 saveOutputWires(ostream &os, const char *name, 
                                                int dogeneral = 0);
    virtual void         saveIntrinsicCommand(ostream &os, const char *name);
    
    //Writes to 'os' a string of hscript commands to recreate this node.
    virtual OP_ERROR     saveCommand(ostream &os,
                                     const char *name,
                                     int valuesOnly,
                                     int defaultstoo,
                                     int docreate,
                                     int doparms,
                                     int doflags,
                                     int dowires,
                                     int dowiresout,
                                     int frames,
                                     int dogeneral,
                                     int dochblock,
                                     float x,
                                     float y,
                                     const char *netboxname,
                                     int dospareparms);

    // This method saves a chlock style command for this node's parameters.
    // name        - the name of the node to print on the command;
    // command     - the name of the command;
    // flag_method - a PRM_Parm method that can be queried for the flag to
    //               output;
    // defaultstoo - prints a default "-*" or "+*" as the first parameter
    // reverse     - normally the default is "-*" followed by the list of
    //               parameters that result true for flag_method().  If 
    //               reverse is true, then the default is "+*" followed by
    //               the parameters where flag_method() is false.  Only useful
    //               when defaultstoo is true.
    // parm_array  - an optional array of parameters whose values should be
    //               printed.  If this array is NULL, then the entire node
    //               is searched.
    void                 saveParameterFlags(ostream &os, const char *name,
                                     const char *command,
                                     bool (PRM_Parm::*flag_method)(int) const,
                                     bool defaultstoo, bool reverse,
                                     UT_RefArray<opParmData> *parm_array);

    void                 saveUserDataCommand(
                                     ostream &os, const char *node_name);

    enum RampError
    {
        RAMP_ERR_SUCCESS,
        RAMP_ERR_NOT_FOUND,
        RAMP_ERR_FIRST_OR_LAST_KEY
    };
    virtual RampError    rampCommand(bool remove, float pos, float rgba[4]);
    RampError            rampCommand(bool remove, float pos, float rgba[4],
                                     UT_Ramp &ramp);

    virtual bool         loadRamp(UT_IStream &is, const char *path=0);

    bool                 loadRamp(UT_IStream &is, UT_Ramp &ramp,
                                  const char *path=0);
    OP_ERROR             saveRamp(ostream &os, UT_Ramp &ramp,
                                  const char *name = 0, int command = 0);

    bool                 getUserData(const char *key, std::string &result);
    void                 setUserData(const char *key, const std::string &data);
    bool                 hasUserData(const char *key);
    bool                 deleteUserData(const char *key);
    const UT_Options    &userData() const { return myUserData; }
    bool                 loadUserData(UT_IStream &is, const char *path=NULL);
    OP_ERROR             saveUserData(ostream &os, const char *path);

    bool                 loadExtraInputs(UT_IStream &is, const char *path=0);

    void                 saveOverrides(ostream &os);
    void                 saveOverrides(ostream &os, OP_Node *root,
                                       const UT_String &rootpath,
                                       bool &added);
    void                 saveChildOverrides(ostream &os, OP_Node *root,
                                            const UT_String &rootpath,
                                            bool &added);
    bool                 loadOverride(UT_IStream &is);
    virtual UT_ErrorSeverity
                         prmCookOverrides(float t, int thread,
                                          const char *parm_name, int vec_idx);
    virtual bool         isParmPendingOverride(const char *parm_name,
                                               int vec_idx) const;
    OP_ERROR             cookOverrides(OP_Context &c);

    virtual void         removeOverrideDestination(OP_Node * /*dest*/) {}
    virtual void         removeOverrideDestination(OP_Node * /*dest*/,
                                                   int /*parm_idx*/) {}

    // Overriding virtual function in PRM_ParmOwner to run a command.
    virtual void         executeCommand(const char *command,
                                        ostream *out,
                                        ostream *err) const;
    virtual void         pushAsPwdAndRunPython(
                            PY_CompiledCode &compiled_code,
                            PY_Result::Type desired_result_type,
                            PY_Result &result,
                            PY_EvaluationContext *context=NULL) const;

    OP_ERROR             executeHscriptScript(UT_String &script, float now);
    OP_ERROR             executePythonScript(UT_String &script, float now);

    void                 addPythonNodeError(const PY_Result &py_result);
    
    void                 saveInputs(ostream &os);
    bool                 loadInputs(UT_IStream &is, const char *path=0);

    void                 checkInputs(); // this method will check the
                                        // node references in all the inputs

    // Saves out extra information for this node to be included in a dialog
    // script that defines an operator type created from this one.
    virtual void         saveDialogScriptExtraInfo(ostream &os);

    // Fills in the supplied default gallery entry with info from this node.
    virtual void         createGalleryEntry(OP_GalleryEntry &entry);

    // When a string parameter can have the syntax: 'op:/...', use these
    // evaulate methods to do the approprate checking and reference building.
    // These methods will return a reference to the OP_Node if one is
    // referenced.  If the syntax is something like:
    //          op:/foo/bar[32]
    // Then the optime will be (32-1)/$FPS rather than the evaluation time.
    void                 evalOpPathString(UT_String &val, int pi, int vi,
                                    float t, int &op_id, float &op_time,
                                    int expanded = 1);
    void                 evalOpPathString(UT_String &val, const char *pn,
                                    int &pi, int vi, float t,
                                    int &op_id, float &op_time, int expanded=1);
    static int           findOpFramePair(const char *path, int &op_id,
                                    float &frame);

    /// Build a UT_XformOrder out of TRS and XYZ parameter values
    static void          buildXformOrder(int trs, int xyz,
                                UT_XformOrder &order);

    /// Translate a TRS parameter menu index into the UT_XformOrder type
    static UT_XformOrder::rstOrder  getMainOrder( int trs );
    /// Translate a UT_XformOrder type into a TRS parameter menu index
    /// (inverse of getMainOrder())
    static int           getMainOrderMenuIndex(UT_XformOrder::rstOrder order);
    /// Translate a XYZ parameter menu index into the UT_XformOrder type
    static UT_XformOrder::xyzOrder  getRotOrder( int xyz );
    /// Translate a UT_XformOrder type into a XYZ parameter menu index
    /// (inverse of getRotOrder())
    static int           getRotOrderMenuIndex(UT_XformOrder::xyzOrder order);

    static UT_Vector3    getXformPivot(int trs,
                                  float tx, float ty, float tz,
                                  float px, float py, float pz);
    static UT_Vector3    getPivotParmValue(int trs,
                                  float tx, float ty, float tz,
                                  float px, float py, float pz);
    static void          buildXform(int trs, int xyz,
                                float tx, float ty, float tz,
                                float rx, float ry, float rz,
                                float sx, float sy, float sz,
                                float px, float py, float pz,
                                UT_Matrix4 &mat);
    static void          buildXform(int trs, int xyz,
                                float tx, float ty, float tz,
                                float rx, float ry, float rz,
                                float sx, float sy, float sz,
                                float px, float py, float pz,
                                UT_DMatrix4 &mat);
    static void          buildXform(int trs, int xyz,
                                float tx, float ty, float tz,
                                float rx, float ry, float rz,
                                float sx, float sy, float sz,
                                float s_xy, float s_xz, float s_yz,
                                float px, float py, float pz,
                                UT_Matrix4 &mat);
    static void          buildXform(int trs, int xyz,
                                float tx, float ty, float tz,
                                float rx, float ry, float rz,
                                float sx, float sy, float sz,
                                float s_xy, float s_xz, float s_yz,
                                float px, float py, float pz,
                                UT_DMatrix4 &mat);
    static void          buildXform(int trs, 
                                float tx, float ty, float rz,
                                float sx, float sy, float px, float py,
                                UT_Matrix3 &mat);
    static void          buildXform(int trs, 
                                float tx, float ty, float rz,
                                float sx, float sy, float px, float py,
                                UT_DMatrix3 &mat);
    static void          buildXform(int trs, 
                                float tx, float ty, float rz,
                                float sx, float sy, float s_xy,
                                float px, float py,
                                UT_Matrix3 &mat);
    static void          buildXform(int trs, 
                                float tx, float ty, float rz,
                                float sx, float sy, float s_xy,
                                float px, float py,
                                UT_DMatrix3 &mat);

    virtual int          getTranslateParmIndex();

    // This is done only after a load to make sure that
    // all inputs have been resolved correctly.
    void                 resolveInputReferences();

    static void          clearAllPendingUndoFlags();

    virtual void         clearUndoFlags();
    virtual void         setAnyUndoFlag();
    void                 saveForUndoInput();

    void                 blockModify(int on_off, int propagate = 1);
    int                  isBlockModify(void) const;
    virtual void         propagateEndBlockModify();

    int                  getNParmInterests() const
                         { return myParmInterestCount; }
    const OP_ParmInterest *getParmInterest(int index) const
                         {
                            return (index < myParmInterestCount)
                                 ?  myParmInterests(index) : 0;
                         }

    /// Mark the fact that this node's dstindex parm is depends on the value of
    /// src node's srcindex parm. dstindex may be -1 to express that this
    /// node's data depends on src node's srcindex parm.
    /// @note srcindex must be valid.
    /// @warn This method assumes that getCookLock() has already been acquired!
    void                 addParmInterest(OP_Node *src, int srcindex,
                                         int dstindex);
    void                 dumpParmInterests() const;

    // Only returns anything in the case of chops
    virtual const CL_Clip *getClip(OP_Context *context = 0);

    /// Returns the a chop network path suitable for storing motion effects
    /// associated with this node.
    void                 getMotionEffectsNetworkPath(UT_String &path);

    // Performance queries
    float                getCookDuration() const;
    const char          *getCookDurationString() const;

    // Query color for Net Overview rendering
    virtual int          getNetOverviewColor( UT_Color &color );
    
    // Those operators which need a ramp editor must define this method.
    virtual UT_Ramp     *getRamp();

    virtual int          isCookingRender() const { return 0; }
    virtual void         setCookingRender(int val);

    virtual void         clearInterrupted();
    int                  wasInterrupted() const { return flags().interrupted; }

    // work-around to display warning message when export src or destination
    // are renamed.  OP_Node::cook clears the error messages when a node export
    // changes so we had to save the fact that a rename conflict is pending
    void                setRenameConflict()
                        { myRenameConflict = 1; }
    void                setRunningCreateScript(int onoff);

    // Base class methods to output code to a file or a stream:
    virtual int         outputCode(OP_OutputCodeParms &, OP_Context &);

    virtual float       getTimeTransform(int input, float t);
    virtual void        getInputRes(int input, float t,
                                    const OP_Context &context,
                                    OP_Context &input_context);

    // Utility methods:
    static void         setIndentLevel(int numspaces);
    static void         writeIndent(ostream &os, int indent);
    static void         writeSpaces(ostream &os, int spaces);
    static void         writeFileHeader(ostream &os, const char *filename, 
                                        const char *prefix);

    UT_TokenString &     getHashCode(OP_Context &context, int group_mask =1);
    virtual UT_TokenString & getParmHashCode(OP_Context &context,
                                             int group_mask = 1);

    virtual int         getNumInputsToHash();
    virtual OP_Node    *getInputToHash(int i);
    
    void                clearHashCodeFlags();
    bool                isHashCodeBuilt() const { return myBuiltHashCode;}
    void                builtHashCode(bool b = true) { myBuiltHashCode = b; }
    void                buildInputHashCode(UT_TokenString &string,
                                           OP_Context &context,
                                           int group_mask,
                                           int level);

    // If an interactive state was used to create this node, set it here.
    void                 setCreatorState(const char *s)
                         { myCreatorState.harden(s); }
    const UT_String     &getCreatorState() const   { return myCreatorState;    }
    void                 builtExplicitly(int yn)   { myBuiltExplicitly = yn;   }
    int                  wasBuiltExplicitly() const{ return myBuiltExplicitly; }

    bool                 matchesState(const char *state) const;

    // Don't even think about calling changeParmTemplate if you aren't
    // OP_Operator.
    virtual void         changeParmTemplate(PRM_Template *new_template);

    void                 ensureInputsAndOutputsAreValid();

    // Connect the node to an input.  If branch_off is false and the input node
    // currently has outputs, the node will be inserted before the outputs.
    void                 connectToInputNode(OP_Node &inputnode, int input_idx,
                                            int branch_off=0);

   // This method should be called when the user edits an overridden channel
    virtual int                  editCallback(CL_Track *track, float t,
                                              float newValue);

    // This mechanism allows users to communicate editing changes
    static OP_EditCallback       getEditCallback(void *&data);
    static void                  setEditCallback(OP_EditCallback func,
                                                 void *data);

    // These build an xform matrix based upon the given parameters.
    // The axis is the axis around which to rotate by 90 degrees.  If
    // it is lower case, it will be rotated by +90, if it is upper case,
    // by -90.  To not rotate at all, use '-'.
    static void          buildQuadricXform(UT_Matrix4 &mat,
                                float tx, float ty, float tz,
                                float sx, float sy, float sz,
                                char axis = 'y');

    static void          buildQuadricXform(UT_DMatrix4 &mat,
                                float tx, float ty, float tz,
                                float sx, float sy, float sz,
                                char axis = 'y');

    static int           buildOpMenu(OP_Network *net, PRM_Name *theMenu,
                                int theMenuSize, int (*doAdd)(OP_Node *) = 0,
                                int startItem = 0, PRM_Parm *parm = 0,
                                int showSubnets = 1, int expandSubnets = 1,
                                bool recurse = false);

    // Build the "Predefined Rules" menu that is common to several OPs
    // including Event and Group POPs. This is built from the text file table
    // OP<name>Rules, where name is the OP type (ie Event).
    static void          buildPreDefRulesMenu(PRM_Name *menu,
                                              OP_PreDefRules &pdr);

    // Allows operators to use their own local table for variables and build
    // structures on demand...  Implement the syntax highlight version only
    // if you need to resolve variables for syntax highlighting that are not
    // normally resolved by the generic resolveVariable() method.
    virtual const CH_LocalVariable *resolveVariable(const char *name);
    virtual const CH_LocalVariable *resolveExtraVariableForSyntaxHighlight(
                                                            const char *name);

    // This value bumps whenever nodes are created/deleted/renamed.
    static int           getNameSerialIndex();

    // export mapping techniques
    virtual void        setMapping(int idx, int type, const char *label = 0);
    virtual int         getMapping(int idx, const char *&label) const;

    // drag-n-drop receive methods
    virtual int         acceptDragDrop(DD_Source &src, const char *label);
    virtual int         testDragDrop(DD_Source &src);
    virtual void        getDragDropChoice(DD_Source &src, DD_ChoiceList &c);

    // These methods are used to give quick overview information about a node
    bool                hasComment() const;
    bool                hasParmsNotAtFactoryDefault() const;
    bool                hasAnimatedParms() const;
    bool                hasChopOverriddenParms() const;

    /// traverseInputs calls 'callback' on this node and all its inputs.
    /// If callback returns true for any node, it will stop and return
    /// true, otherwise it will return false;
    /// @param callback             Callback function
    /// @param data                 User data passed to the callback function
    /// @param follow_subnets       If input is a subnet, we continue
    ///                             traversing from its display node.
    /// @param follow_ref_inputs    Follow inputs marked as reference inputs
    /// @param follow_extra_inputs  Follow nodes which this node implicitly
    ///                             depends on.
    /// @param extra_interest_mask  For extra inputs, this mask allows one to
    ///                             restrict which of those dependency types
    ///                             follow.
    //@{
    bool                traverseInputs(bool (*callback)(OP_Node &, void *),
                                       void *data,
                                       bool follow_subnets,
                                       bool follow_ref_inputs,
                                       bool follow_extra_inputs,
                                       OP_InterestType extra_interest_mask =
                                                OP_INTEREST_ALL);
    bool                traverseInputs(bool (*callback)(const OP_Node &, void*),
                                       void *data,
                                       bool follow_subnets,
                                       bool follow_ref_inputs,
                                       bool follow_extra_inputs,
                                       OP_InterestType extra_interest_mask =
                                                OP_INTEREST_ALL) const;
    //@}
    
    /// Traverses children of this node, calling 'callback' on all children.
    /// If callback returns true, the traversal stops at that node.
    bool                traverseChildren(bool (*callback)(OP_Node &, void*),
                                         void *data,
                                         bool recurse_into_subnets);

    // This method returns true if the OP_Node makes use of its footprint
    // flag and false otherwise.
    virtual bool         usesFootprint() const  { return false; }

    void                 getExternalReferences(UT_StringArray &reflist,
                                               UT_StringArray *nodelist = 0,
                                               bool from_children_too = true,
                                               bool collapse = false,
                                               bool check_missing = false,
                                               bool show_missing_only = false);
    virtual bool         getSaveWithVopnets();
    virtual void         runDelScript();
    /// Overriden in VOPs to remove any channel refrences we may have 
    /// to the node being deleted.
    virtual void         preDelete() { }

    // Two functions for upcasting this node to a DOP_Parent. DOP_Parent
    // is a class which owns a simulation and has DOP_Nodes as children.
    virtual DOP_Parent          *castToDOPParent()              { return 0; }
    virtual const DOP_Parent    *castToDOPParent() const        { return 0; }

    // This function upcasts this node to a VOP_CodeGenerator.
    // VOP_CodeGenerator is a class which generates VEX code from the VOPs
    // contained inside the node.
    virtual VOP_CodeGenerator   *getVopCodeGenerator()          { return 0; }

    /// This function returns a string that encodes all the necessary
    /// information about a node-based material that helps the script-based
    /// materials to function properly. The string usually encodes info stored
    /// on child nodes, such as rendering properties or procedurals. Then
    /// the script node can use that info to provide necessary data
    /// for rendering.
    /// Returns true if the method provides usable information.
    virtual bool                getScriptMaterialInfo( UT_String & mat_info,
                                    VOP_ScriptMaterialCodeMapper * mapper )
                                { return false; }

    /// Returns the sub type name, if the node's operator wants to be
    /// saved as an OTL in a special way (ie, other than the regular
    /// scripted operator handling). The sub type name is then used
    /// to distinguish how to handle the HDA creation.
    virtual const char  *getOTLSubType()                        { return 0; }

    // Set the channel alias for a channel (or parm subindex).  Returns true
    // if successful and false otherwise.
    bool                 setChannelAlias(PRM_Parm &parm, int subindex, 
                                         const char *alias_name);

    void                 disconnectAllInputsOutputs(bool keepSelected, 
                                bool forceDisconnectOutputs = false);

    void                 disconnectAllInputs(void);
    void                 disconnectAllOutputs(void);

    // Notify dependents that a parm name has changed.
    virtual void         notifyParmRenameDependents( 
                                        const UT_String &chan_name,
                                        const UT_String &old_chan_name );

    void                 writeChannel(CH_Channel *channel, ostream &os,
                                      const char *name, bool frames);
    void                 writeAllChannels(ostream &os, const char *name,
                                          bool frames, bool dochblock,
                                          bool dospareparms);

    // Run the callback function for a particular parm, and the callbacks
    // of any parms linked to this parm. Returns false if the node is
    // deleted while running the callback.
    virtual bool         triggerParmCallback(PRM_Parm *parmptr, float now,
                                             int value, void *data);

    virtual int64        getMemUsage(UT_Bool onlythis) const;
    int64                getExtraInputMemUsage() const;
    static void          printOpMemoryUsageStats(ostream &os);


    /// This method will unscope all the channels belonging to this op.
    /// If the recurse flag is set it will recurse through the children
    /// (at this level the recurse flag is ignored).
    virtual void         unscopeChannels(bool recurse);

    /// This method takes a pattern string and will perform the ch_scope_op
    /// on each of our paramaeters that match the pattern.   This method
    /// primarily supports the chscope command.
    virtual void         setChannelScope(const char *pattern, 
                                         OP_ScopeOp scope_op,
                                         const OP_ScopeOptions &scope_opts);

    //A simple wrapper around getName() to allow us to abstract its 
    //functionality up to OP_NetworkBoxItem.
    virtual const UT_String     &getItemName() const { return getName(); }
    
    // This function is called when our spare parm definition is changing.
    virtual bool         changeSpareParms(UT_IStream &istream,
                                          UT_String &errors);
    // This function is called during the changeSpareParms operation when
    // one of our parameters is being removed.
    virtual void         spareParmRemoved(const char *parmname);
    
    // This is a secondary parm list where all obsolete parameters are
    // placed (if any)
    virtual PRM_ParmList    *createObsoleteParmList();
    virtual void             resolveAndDeleteObsoleteParmList(
                                                PRM_ParmList *&obsolete_parms);

    // Sets the given stamping parameter.
    // Returns true if the param was changed. Note that we may return false
    // even if this was a valid operation as param might have already been
    // set to the given value.
    // If the warned variable is given, then we only warn if its contents
    // is false. Then in that case, we will set it to true when needed.
    bool                 setGlobalFloatParam(const char *param,
                                        float value,
                                        bool *warned);
    bool                 setGlobalStringParam(const char *param,
                                        const char *strvalue,
                                        bool *warned);

    // This allows one to prevent chop cooking due to parameter modifications
    // until the outermost block is done. When given the 'data' pointer, it
    // will be initialized for subsequent calls to propagateModification().
    void                 beginPropagateModification(OP_PropagateData *data = 0);
    void                 endPropagateModification();

    // Add any OTL-defined operators used by this node to the specified table.
    virtual void         getActiveOperatorsDefinedByOTL(
                                        UT_HashTable &active_operators) const;

    // Returns true if we are in the middle of a call to sendBulkNotifications,
    // Or doing some other operation that involves sending out a whole bunch
    // of change notifications all at once. This allows VOP Networks to avoid
    // over-cooking.
    static bool          getDoingBulkNotification();

    /// Returns whether multi-inputs on this particular op might have different
    /// names for each of the inputs, or if the name will always be the same for
    /// all the inputs.
    virtual bool         hasDifferentMultiInputs() const;


    virtual bool         canCreateNewOpType() const;
    static bool          createNewOpType
                            (OP_Node *node,
                             UT_String &errors,
                             const char *typeName=NULL,
                             const char *typeLabel=NULL,
                             const char *otlFile=NULL,
                             const char *metaSource=NULL,
                             const char *comment=NULL,
                             const char *version=NULL,
                             const char *newName=NULL,
                             int         minimumInputs=-1,
                             int         maximumInputs=-1,
                             bool ignoreExternalReferences=false, 
                             bool compressContents=false,
                             bool force=false,
                             int *newNodeId=NULL);


    virtual UT_String   *getMaterialIconFilename() { return 0; }
    virtual void         setMaterialIconFilename(const char * /*icon_file*/) {}
    virtual IMG_Raster  *getMaterialIconImage() { return 0; }
    virtual bool         getMaterialIconAllowRegenerateFlag() { return true; }
    virtual void         setMaterialIconAllowRegenerateFlag(bool) {}

    /// A special string which acts as a separator in node MMB info popups.
    static const char    *OP_INFO_SEPARATOR_STRING;

    /// If we're in the UI "small" or "compact" modes, someone needs to call
    /// OP_Node::setSmallMode() to ensure that the correct node sizes are
    /// used by getFlagWidth, getNodeHeight, getNodeButtonWidth, and
    /// getConnectorHeight.
    static void          setSmallMode();

    static bool          getSmallMode();

    // Call these functions when making a lot of calls to opChanged on a
    // list of nodes. These functions make sure that VOP Networks only get
    // one change notification no matter how many child nodes are about
    // to send any number of change events.
    static void                  startBulkNotifications(
                                                const OP_NodeList &changed);
    static void                  endBulkNotifications(
                                                const OP_NodeList &changed);

    /// Sets the node button width in terms of the flag widths multiplier.
    static void          setNodeButtonWidthFlagMult(int new_mult);

    /// This is overriden in VOPs. It returns true if the input at input_idx
    /// will need *and* can perform autoconversion of its input type to the
    /// type it needs. If autoconversion is not needed, or is impossible,
    /// this will return false.
    virtual bool         willAutoconvertInputType(int input_idx);

    bool isDependentOn(OP_Node* other_node, PRM_Parm* parm);

    /// Recursively exposes or unexposes all of this node's inputs or
    /// outputs, starting with exposing/unexposing self.
    void setExposeRecursive(bool expose, bool do_inputs, int level = 0);
    
    // Gets whether the input at idx is collapsed.  Currently this is only used
    // in VOPs.  
    virtual bool    getIsVisible(int idx);

    // Debugging function to confirm that all PRM_Template's are consistent
    // with their parameters.
    bool                 verifyTemplatesWithParameters() const;

protected:
             OP_Node(OP_Network *parent, const char *name, OP_Operator *entry);
    virtual ~OP_Node();

    void                 setNewParent( OP_Network *new_parent );

    static void          bumpNameSerialIndex();

    // All external references must be removed by the time this function
    // returns!
    virtual void         clearAndDestroy(void);

    // invalidate any cached data
    virtual void         clearCache();

    //
    //  Protected virtuals:
    //

    // "cookMe" is where the actual work is done.
    // The error is returned (OP_ERR_NONE on success).
    virtual OP_ERROR     cookMe(OP_Context &context) = 0;

    // "bypassMe" is used to cook the op when the bypass flag is set. 
    // The copied_input parameter should be set to indicate which input was
    // copied. Use -1 if no input was copied.
    // The error is returned (OP_ERR_NONE on success).
    virtual OP_ERROR     bypassMe(OP_Context &context, int &copied_input) = 0;

    // The following two functions are called from evaluateAllParms() so that
    // subclasses may hook into it to do some work before and after evaluating
    // all the parameters.
    virtual void         doOverridePreCook()    { }
    virtual void         doOverridePostCook()   { }

    // These "serial" numbers are used for keeping track of how many sources
    // are accessing us. Only call getSourceCount() when locked inside
    // getCookLock()!
    int                  getSourceCount(void) const;
    virtual int          bumpSourceCount(int d);

    // This is what you should override to do your own OP specific cooking.
    // This should not be called other than from pubCookInputGroups.
    virtual OP_ERROR     cookInputGroups(OP_Context &context, int alone = 0);

    // deleteNodeData is called from the deleteDataCallback function.
    // This is usually called from OP_Cache when cached OP data is
    // deleted. This method should return 1 if you want change events
    // to be propagated to the extra inputs when data is deleted from
    // the cache.
    virtual int          deleteNodeData(void *);
    virtual void        *copyNodeData(void *);

    //  I/O methods
    virtual OP_ERROR     saveIntrinsic(ostream &os, const OP_SaveFlags &flags);
    virtual OP_ERROR     save(ostream &os, const OP_SaveFlags &flags,
                              const char *path_prefix = "");

    bool                 loadIntrinsic(UT_IStream &is, const char *path=0);
    virtual bool         loadPacket(UT_IStream &is, short class_id,
                                    short sig, const char *path=0);
    virtual bool         loadPacket(UT_IStream &is, const char *token,
                                    const char *path=0);
    virtual bool         load(UT_IStream &is, const char *ext="",
                                              const char *path=0);

    // this called when the entire network is done loading
    virtual void         loadStart();
    virtual void         loadFinished();

    // Loads the OTL_CONTENTS_SECTION for our OTL definition, if it exists,
    // using the syncContents method.
    void                 loadContentsSection();

    // This is a dummy virtual that just exists to be overridden by
    // OP_Network. See that class for more description.
    virtual bool         syncContents(UT_IStream &is);

    /// Sets the flag idicating if the node is synced (matched) to the HDA.
    void                 setMatchesOTLDefinition(int matches);

    virtual const char  *getFileExtension(int binary) const = 0;
    virtual const char  *getDataFileExtension(int binary) const;

    //  Here's a useful method which will return the string "Source %d", where
    //  %d is the idx passed.
    const char          *inputLabelNum(unsigned idx) const;
    const char          *outputLabelNum(unsigned idx) const;

    //  This will set the time dependent flag based on parms, inputs and/or
    //  extra (non-graph) inputs.
    virtual void         checkTimeDependencies( int do_parms=1,
                                                int do_inputs=1,
                                                int do_extras=1 );
    unsigned             isInput(unsigned idx)
                         { return idx < myInputs.entries(); }

    //  To allow our sub-classes to send events, we make this protected.
    void                 sendEvent(OP_EventType type, void *data=0);

    // haveSeenDataModification() can be used by sub-classes to decide if they
    // need to respond to a particular modification notice.
    int                  haveSeenDataModification(long modification_id);

    // If you sub-class propagateModification, then be sure to call this
    // OP_Node base class method *last*.
    //
    // This routine will return TRUE if the modification is a new one for this
    // node.  FALSE will be returned if the modification has been seen before.
    //
    // Note that "by_whom" is the immediate input node that caused the
    // propagation to "this" node.
    virtual int          propagateModification(OP_Node *by_whom,
                                               OP_EventType reason,
                                               int parm_index,
                                               OP_PropagateData &prop_data);
    virtual void         propagateParmChange(OP_Node *node,
                                             OP_PropagateData &prop_data,
                                             bool &data_changed);
    void                 propagateParmChangeFromSource(OP_Node *source,
                                                       OP_PropagateData &data);

    OP_VERSION           getVersionCache();
    void                 setVersionCache(OP_VERSION);

    // Use this to obtain the cook cache.
    // @pre The caller has locked myCookLock if it is currently being cooked.
    OP_Cache *           getCookCache() { return &myCache; }


    static void          deleteDataCallback(void *, void *);
    static void         *copyDataCallback(void *, void *);

    static void          cmd_locate(CMD_Args &);

    virtual void         saveFlagsForUndo();
    void                 saveForUndoLayout();
    void                 saveForUndoColor();

    static void          saveForUndoDelete(OP_NodeList &nodes);

    // clears cook dependencies (i.e., items that may cause it to cook)
    void                 clearDependency(bool include_parm);
    void                 clearExtraInputs();
    void                 clearParmInterests()
                         {      
                             myParmInterestCount = 0;
                             mySelfParmInterestCount = 0; 
                             mySelfParmDataInterest = false; 
                         }

    // clone dependencies from the proxy. proxy is no longer valid
    // after the clone!
    virtual void         cloneFromProxyRefNode( OP_Network *proxy );
    // clone a new proxy node. this node is no longer valid after this!
    virtual OP_Network * cloneToProxyRefNode();
    void                 stealDependents( OP_Node *other );

    int                  hasOpDependents()
                            { return myOpDependents.entries(); }
    virtual int          hasProxyRefNodes() const
                            { return 0; }
    virtual void         moveProxyRefNodes( OP_Network * /*dest */ ) { }
    void                 clearOpReferences();
    virtual void         rebuildOpDependents( bool proxy_only );

    /// removeOpDependent() returns the number of dependents removed
    virtual int          removeOpDependent(
                            int op_id, const PRM_RefId &ref_id,
                            OP_InterestType mask = OP_INTEREST_ALL );
    virtual int          removeOpDependent(
                            int op_id, OP_InterestType mask = OP_INTEREST_ALL );

    // new method for dependencies: use the PRM_TYPE_OP_REF_*
    //  in your parm template to add your dependency.
    // override this to do special cases, make sure you call the base class
    // first before adding your own dependencies!
    virtual void         buildOpDependencies();
    virtual void         checkChannelDependencies( CH_Channel *ch,
                                                   CH_CHANGE_TYPE reason );

    void                 notifyOpDependents( OP_InterestType interest,
                                             bool recurse );
    virtual void         moveDependencies( OP_Node *from_node );
    // Two functions for notifying dependent nodes of name changes. The
    // non-virtual function is the one that should be called to do the
    // update. It calls the virtual function to do the actual updating,
    // and generate a list of dependent nodes that were changed. Then it
    // forces a recook on the changed nodes.
    void                 notifyRenameDependents( const UT_String &full_from );
    virtual void         notifyRenameDependents( const UT_String &full_from,
                                                 OP_NodeList &cook_nodes );
    // Two functions for notifying referencing nodes of name changes. The
    // non-virtual function is the one that should be called to do the
    // update. It calls the virtual function to do the actual updating,
    // and generate a list of dependent nodes that were changed. Then it
    // forces a recook on the changed nodes.
    void                 notifyRenameReferences( const UT_String &full_from );
    virtual void         notifyRenameReferences( const UT_String &full_from,
                                                 OP_NodeList &cook_nodes );
    void                 notifyExtraNameOutputs( const char *old_name );
    // this method is called to alert this op that its dependency has
    // changed. if it's a name interest, then the old full path is given
    virtual void         handleOpDependency( int referenced_op_id,
                                             const OP_Dependency &op_dep,
                                             OP_InterestType interest_type,
                                             bool &need_cook,
                                             const char *old_fullpath,
                                             const char *old_cwd,
                                             const char *old_chan_name );
    virtual void         buildParmDependency( int parm_index );

    void                 addOpNameReference(
                            const PRM_RefId &ref_id, const UT_String &op_path,
                            OP_InterestType type );
    // chan_name must be real channel name not an alias
    void                 addChannelNameReference(
                            const PRM_RefId &ref_id, const UT_String &op_path,
                            const UT_String &chan_name, OP_InterestType type );

    OP_Node             *getNodeOrCreateProxy(const UT_String &op_path);

    void                 addOpReference( const PRM_RefId &ref_id, OP_Node *node,
                                         const PRM_RefId &source_ref_id,
                                         OP_InterestType type );

    /// This function takes the given parm string value containing an op path
    /// and does a search and replace given the old and new op paths.
    ///
    /// value_str           - the old parm value to modify
    /// new_fullpath        - the new path value to change to
    /// old_fullpath        - the old path that needs changing
    /// old_cwd     - the old path that the parm value was relative to
    /// new_cwd     - the new path that the parm value is to be relative to
    ///
    /// The reason for old_cwd & new_cwd is when collapsing a node into a
    /// subnet.  We need to figure out the new path references of the collapsed
    /// subnet since it has changed location. We match using the old_cwd but
    /// take the new path relative to new_cwd. Note that in this situation,
    /// old_fullpath is the same as new_fullpath.
    bool                 changeOpPathRef( UT_String &value_str,
                                          const char *new_fullpath,
                                          const char *old_fullpath,
                                          const char *old_cwd,
                                          const char *new_cwd );

    // handy functions for dealing with string parms that can have the
    // op:/path[frame] syntax
    static bool          getStringParmOpPath(
                                PRM_Parm &parm, int vi, UT_String &oppath,
                                int thread );
    void                 handleStringParmOpPathDependency(
                                int parm_index, int vi,
                                const char *new_fullpath,
                                const char *old_fullpath, const char *old_cwd );

    //  Only the OP network should use the following method...
    //  nodeDeleted()           - gets called every time a node is deleted
    virtual void         nodeDeleted(OP_Node *op, int propagate=1);

    void                 startCookTimer(const OP_Context &context);
    void                 stopCookTimer(const OP_Context &context);

    virtual const char  *getCookTimerLabel(const OP_Context &context) const;

    // Overrides permission errors so that we don't have problems when cooking.
    virtual void         permissionError(const char *chname = 0);

    // Add an error for the invalid input given by input_idx
    void                 addInputError(unsigned input_idx);

    /// This function is currently only used by VOPs. It checks if an input 
    /// on the subnet is connected inside the subnet. The default implementation
    /// here simply returns false to preserve existing behaviour for all other
    /// contexts.
    virtual bool         isInputConnectedInsideSubnet(int input_idx) const;

    // notifier when this node is unlocked
    virtual void         nodeUnlocked() { ; }

    // These functions must be used with care!
    virtual void         setUniqueId(int id);
    void                 changeOpDependentUniqueId( int old_id, int new_id );
    void                 changeOpReferenceUniqueId( int old_id, int new_id );
    virtual void         clearUniqueId();

    void                 setAllowBuildDependencies( int yesno )
                            { myAllowBuildDependencies = yesno; }
    int                  allowBuildDependencies() const
                            { return myAllowBuildDependencies; }

    // Evaluate all parameters for this operator. This is used for scripted
    // Ops to make sure that our dependencies get set up properly.
    void                 evaluateAllParms(double t);

    // Override and assign any external (file) references to the reflist,
    // and if nodelist is non-null, the full pathname of the node with the
    // reference.
    virtual void         getMyExternalReferences(UT_StringArray &reflist,
                                                 UT_StringArray *nodelist =0,
                                                 bool collapse = false,
                                                 bool check_missing = false,
                                                 bool show_missing_only=false);

    void                 getExternalFiles(UT_StringArray &files,
                                          const char *stringparm,
                                          int framestart, int frameend,
                                          bool collapse,
                                          bool check_missing,
                                          bool show_only_missing,
                                          UT_KnownPath path);

    // Return true if it is safe at this time to destroy this node.
    virtual bool         canDestroyNode();

    // Returns true if we are allowed to destroy the specified nodes. If
    // nodes is non-null, we test those nodes. If nodes is null, we test
    // the picked nodes of the src_net. The return value assumes that all
    // specified nodes will be destroyed, which is important because it
    // may be safe to delete node A iff node B is also going to be deleted.
    static bool          canDestroyNodes(OP_Network *src_net,
                                         OP_NodeList *nodes);

    // Override this to return true in an operator type that wants its
    // cooked data to rely on all its parameter values but doesn't actually
    // evaluate any parameters in its cook function (the prototypical
    // example of this is SHOPs).
    virtual bool         cookedDataUsesAllParameters() const
                         { return false; }
    // If the cook method relies on the base class cook to evaluate parameters
    // (like in SHOPs), we need to trap the errors during this evaluation.
    virtual bool         cookedDataNeedsErrors() const
                         { return false; }

    // Returns true if we are running our creation script, or any parent
    // node of us is running its creation script.
    bool                 getIsRunningInCreateScript() const;

    // This method is called whenever something in the network changes
    // that may have an impact on the representative node this network may
    // have.  It is used at this level to notify parents, and at the OBJ level
    // to actually refresh the representative object.
    virtual void         refreshRepresentativeNode(OP_Node &changed_child);

    // appends a chop to a list for cooking after all propagate modifications
    // calls are finished
    void                 appendExportingChopToCook( int id );

    // Converts opdef and oplib format paths from opdef:nodepath to
    // opdef:tablename/optype.
    void                 convertOpdefToAbsolutePath(UT_String &str) const;

    bool                 isCookedTime(double t) const
                            { return SYSequalZero(t - myCookTime); }


    UT_TokenString                myHashCode;           // Generates a unique
    UT_TokenString                myParmHashCode;       // parameters & inputs.
    int                           myLastGroupMask;
    OP_VERSION                    myHashVersion;
    float                         myHashTime;
    int                           myParmLastGroupMask;
    OP_VERSION                    myParmHashVersion;
    float                         myParmHashTime;
    UT_String                     mySyncErrors;
    OP_ERROR                      mySyncErrorLevel;
    int                           mySyncDepth;

    /// The following methods and booleans are to be used to implement getW()
    /// and getH() in sub-classes. They're not of general utility.
    /// All of these are in absolute, pan-and-scale independent UI units.

    /// Get the width of flags depending on whether we're currently in "small
    /// mode" or not. 
    static fpreal        getFlagWidth();

    /// Get the default node height based on the current flag width.
    static fpreal        getNodeHeight();

    /// Get the default width of the "node button" (the part of the node 
    /// that you can drag and click on that isn't flags).
    static fpreal        getNodeButtonWidth();

    /// Get the default connector (e.g., the thing into which inputs and
    /// outputs are drawn) height.
    static fpreal        getConnectorHeight();

    static bool          theSmallMode;

    /// Deletes an input completely if it is disconnected. If the input is connected,
    /// does nothing.
    void deleteInput(int idx);

    /// Update the error severity of this node.
    void                 updateErrorSeverity();

    /// Overriden in VOPs.
    virtual void onInputAllocated(OP_Input* new_input, int index) { }

private:
#ifdef INTEL_COMPILER
                         OP_Node(const OP_Node& );
#endif
        
    void                 createCollection( OP_Operator *entry );

    // these are extra private. only to be called from saveIntrinsic and save
    // respectively
    OP_ERROR             saveIntrinsicError();
    OP_ERROR             saveError();
    OP_ERROR             saveGroupMemberships(ostream &os,
                                              const OP_SaveFlags &flags,
                                              const char *path_prefix);
    bool                 loadGroupMemberships(UT_IStream &is,const char*path=0);

    ///Make a note of which network box we're in
    OP_ERROR             saveNetworkBox(ostream &os,
                                        const OP_SaveFlags &flags,
                                        const char *path_prefix);

    ///Put ourselves into a network box if we saved ourselves as being in one
    bool                 loadNetworkBox(UT_IStream &is, const char *path=0);

    bool                 loadNodeFlags(UT_IStream &is, const char *path);

    void                 saveForUndoComment();
    void                 saveForUndoDelScript();

    UT_BitArray         &getGroups()       { return myGroups; }
    const UT_BitArray   &getGroups() const { return myGroups; }
    // Only OP_Input should call setOutput() and delOutput().
    bool                 setOutput(OP_Node *node, int outputIdx);
    bool                 delOutput(OP_Node *node, int outputIdx);
       
    void                 setInterrupted();

    void                 setExtraOutput(OP_Node *);
    void                 delExtraOutput(OP_Node *);
    int                  hasExtraInput(const OP_Node *match_node,
                                       OP_InterestType type);

    int                  findAncestor(const OP_Node *node) const;
    int                  findDataAncestor(const OP_Node *node) const;
    void                 clearRecursionBit() const;

    void                 initializeExpressions() const;
    void                 clearInputs();

    // new method: dependencies get created from parm template and only
    //         gets updated when necessary. only buildOpDependencies()
    //         needs to call this
    void                 removeOpReference(
                            const PRM_RefId &ref_id,
                            OP_InterestType mask = OP_INTEREST_ALL );
    void                 removeOpReference(
                            const PRM_RefId &ref_id,
                            int op_id,
                            OP_InterestType mask = OP_INTEREST_ALL );
    // ref_chan_name must be the real channel name and not an alias
    int                  addOpDependent( int op_id, 
                                         const PRM_RefId &source_ref,
                                         const PRM_RefId &ref_id,
                                         OP_InterestType type );

    void                 updateRenameDependent( OP_Node *dependent,
                                                const char *old_cwd,
                                                OP_NodeList &cook_nodes );

    void                 buildScriptOpDependencies();
    void                 changeScriptOpRef( const char *new_fullpath,
                                            const char *old_path,
                                            const char *old_cwd );
    static void          changeScriptCB( UT_String &str,
                                         const char *token_start,
                                         const char *&ch, void *userdata );

    //  If channels are modified by an outside entity (e.g. jive) then
    //  we must scan our OPs to determine which ones may require recooking.
    //  Call this method to perform the scan and set the dirty bit on all
    //  modified OPs.
    //
    // void              findModifiedChannels();


    // Go through and find all nodes which have time interest and requires
    // cooking.  If the update_cook flag is true, then we will call force
    // recook on the node as long as node != this. 'interests' if non-null,
    // stores the path of nodes that has time interest and will set the time
    // interest cook flag on those nodes.
    bool                 findTimeInterests(OP_Context &context, OP_Node *node,
                                           bool update_cook,
                                           OP_NodeCycleDetect &cycle,
                                           OP_NodeList *interests = NULL);

    /// Helper method for 'completePath()'
    bool                 attemptPrefixMatch(const OP_NetworkBoxItem *item, 
                                            char *childpref, int childpreflen, 
                                            UT_String &maxprefix) const;
        
    /// Helper for propagateModification()
    void                 findUsedDataInterests(OP_NodeList &nodes, OP_Node *op);
    void                 propagateSelfParmInterest(int src_index,
                                                   const UT_HashTable &dag,
                                                   bool expr_change,
                                                   UT_BitArray &visited,
                                                   bool &data_changed);

    /// Helper function for the setGlobal*Param functions. This function
    /// interprets the return value from CH_Manager::setGlobal*Param.
    bool                 internalSetGlobalParam(const char *param,
                                                int setreturned,
                                                bool *warned);

    int                  internalSetPicked(int on_off,
                                           bool propagate_parent_event,
                                           bool edit);

    OP_ERROR             internalCookInput(OP_Context &context, int input_idx,
                                           OP_Node &input_node);

    /// Helper function to skip until the next closing brace in a stream
    /// (including the brace itself).
    void                 skipUntilClosingBrace(UT_IStream &is);

private:
    OP_Cache                     myCache;

    OP_ERROR                     myLastErrorSeverity;
    OP_Network                  *myParent;
    UT_PtrArray<OP_Input *>      myInputs;
    mutable UT_BitArray          myUsedInputs;
    OP_ExtraInputList            myExtraInputsList;
    mutable OP_Lock              myExtraInputsLock;
    UT_RefArray<OP_NodeList>     myOutputs;
    OP_NodeList                  myExtraOutputsList;
    mutable OP_Lock              myExtraOutputsLock;
    UT_PtrArray<OP_ParmInterest *> myParmInterests;
    int                          myParmInterestCount;
    int                          mySelfParmInterestCount;
    UT_String                    myComment;
    UT_String                    myDelScript;
    UT_String                    myCreatorState;
    UT_Color                     myColor;               // worksheet node color
    UT_BitArray                  myGroups;
    OP_Value                     myEventValue;
    double                       myCookTime;
    fpreal                       myPosX;
    fpreal                       myPosY;
    long                         myCookCount;
    SYS_AtomicInt32              mySourceCount;
    int                          myBlockModify;
    int                          myUniqueId;
    unsigned                     myActiveInputIndex;
    OP_VERSION                   myVersionParms;        // Bumped everytime the
                                                        // node gets dirty.
    OP_VERSION                   myVersionCache;        // Current version of
                                                        // the entire cache
    bool                         myAutoscope;

                                 // Remembers the ID of the last forward
                                 // _data_ propagation that was seen.
    long                         myLastDataModification;

                

    float                        myCookDuration;        // time spent cooking
    unsigned int                 myRenameConflict               : 1,
                                 myCookedForRender              : 1,
                                 myModifyWaiting                : 1,
                                 myBuiltExplicitly              : 1,
                                 myAllowBuildDependencies       : 1,
                                 myBeingDeleted                 : 1,
                                 myRunningCreateScript          : 1,
                                 myRunningDelScript             : 1,
                                 myAlreadyRunDelScript          : 1,
                                 myMatchesOTLDefinition         : 1,
                                 myLoadCookedDataError          : 1,
                                 myBuiltHashCode                : 1,
                                 myIsProxyRefNode               : 1,
                                 mySelfParmDataInterest         : 1;

    mutable bool                 myStartedTraverseInputs;
    mutable bool                 myRecursionFlag;

    // Used to generate unique ID numbers for each forward propagation
    static long                  theModificationCounter;
    // Tracks the nesting level of the modification propagation chains
    static int                   thePropagateLevel;
    // Array of chop IDs that need to recook after proagations is done
    static UT_IntArray           theChopExportsToCook;

    // ops that we have a reference to
    UT_RefArray<OP_Reference>     myOpReferences;
    // ops that depend on us
    UT_RefArray<OP_Dependency>    myOpDependents;

    // bundles that we have a reference to
    OP_BundleReferences           myBundleRefs;

    // Locking for cooking and adding extra inputs
    mutable OP_CookLock           myCookLock;
    OP_TaskState                  myTaskState;

    // Arbitrary data that users can attach to nodes that gets saved with the
    // hip file.
    UT_Options                    myUserData;

    static int                    myNumSpaces;          // Indent level.
    // Node width, in terms of the multiplier of flag width. Defaults to 4.
    static int                    myNodeButtonWidthFlagMult; 

    // Callback mechanism for modififying overridden parameters.
    static OP_EditCallback       theEditCallback;
    static void                 *theEditCallbackData;

    // Maintenance of node id's
    static int                   makeUniqueId(OP_Node *node);

    static int                   theUniqueId;
    static int                   theUniqueSize;
    static OP_Node             **theUniqueNodes;
    static bool                  theDoingBulkNotification;

    friend class                 OP_Network;
    friend class                 OP_Group;
    friend class                 OP_Input;
    friend class                 OP_ExtraInput;
    friend class                 OP_InputIndirect;
    friend class                 OP_UndoDelete;
    friend class                 OP_UndoInput;
    friend class                 OP_UndoCreate;
    friend class                 OP_UndoSpareParm;
};

// helper function
// should always return a valid pointer
OP_API OP_Node * OPgetNodeFromChannel( const CH_Channel *chp );

#define CAST_INSTANTIATE(PREFIX)                                        \
inline static PREFIX##_Node *CAST_##PREFIX##NODE(OP_Node *op)           \
{                                                                       \
    return ((op) ? (op)->castTo##PREFIX##Node() : 0);                   \
}                                                                       \
                                                                        \
inline static const PREFIX##_Node *CAST_##PREFIX##NODE(const OP_Node *op) \
{                                                                       \
    return ((op) ? (op)->castTo##PREFIX##Node() : 0);                   \
}                                                                       \

/// @anchor OP_Node_CAST_FOONODE
/// These convenience functions let you do the cast without worrying if the
/// underlying pointer is null or not. They aren't macros because this way we
/// avoid double evaluating the op.
//@{
INSTANTIATE_FOR_ALL_NODE_TYPES(CAST_INSTANTIATE)
//@}

#undef CAST_INSTANTIATE

// We don't want anyone to conflict with this..
#undef INSTANTIATE_FINDNODE_FUNCTIONS
#undef INSTANTIATE_CASTNODE_FUNCTIONS
#undef INSTANTIATE_FOR_ALL_NODE_TYPES

#endif

---