OP/OP_Network.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:
 *      Paul Breslin
 *      Side Effects Software Inc.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        OP Library (C++)
 *
 * COMMENTS:
 *
 */

#ifndef __OP_Network_h__
#define __OP_Network_h__

#include "OP_API.h"
#include <iostream.h>
#include <UT/UT_String.h>
#include <UT/UT_PtrArray.h>
#include <UT/UT_SymbolTable.h>

#include "OP_Operator.h"
#include "OP_GroupList.h"
#include "OP_NetworkBox.h"
#include "OP_NetworkBoxList.h"
#include "OP_PostIt.h"
#include "OP_PostItNoteList.h"
#include "OP_Node.h"

class UT_CPIO;
class UT_Pointers;
class UT_WorkBuffer;
class UT_StringArray;
class UT_HashTable;
class OP_InputIndirect;
class OP_OperatorTable;
class OP_Director;
class OP_Group;
class OP_UndoLoad;
class OP_ProxyRefNode;
class OP_NetworkBoxItem;
class OP_PostIt;

// The tile type is used to distinguish between the various types of
// nodes that the networks are starting to contain.
enum OP_TileType
{
    OP_TILE_ALL = 0xFF,
    OP_TILE_NODE = 0x01,        // The regular op nodes
    OP_TILE_PARENT = 0x02,      // The parent inputs for subnets
    OP_TILE_GROUP = 0x04,       // The op groups

    // These are for convenience
    OP_TILE_NOT_NODE = (OP_TILE_ALL & ~OP_TILE_NODE),
    OP_TILE_NOT_PARENT = (OP_TILE_ALL & ~OP_TILE_PARENT),
    OP_TILE_NOT_GROUP = (OP_TILE_ALL & ~OP_TILE_GROUP)
};

// If you are looking for the OBJ_TABLE_NAME, SOP_SCRIPT_NAME, and 
// POP_OPTYPE_NAME style #defines that used to be here, they have been moved up
// to OP_Node.h.

enum OP_RenameAction
{
    OP_RENAME_NO_PROPAGATE          = 0x00, // does no propagation
    OP_RENAME_NORMAL                = 0x01, // does all propagation
    OP_RENAME_NO_EVENTS             = 0x02, // does not send op events AND
                                            // does not re-export chops
    OP_RENAME_NO_DEPENDENCIES       = 0x04, // does not notify dependencies

    OP_RENAME_NUM_ACTIONS                   // sentinel
};

struct OP_FixNameParms
{
    OP_FixNameParms()
    {
        replacePrefix        = 0;
        replaceSuffix        = 0;
        removeTrailingDigits = 0;
    }

    int             replacePrefix;
    UT_String       prefixReplaceStr;
    UT_String       prefixStr;
    int             replaceSuffix;
    UT_String       suffixReplaceStr;
    UT_String       suffixStr;
    int             removeTrailingDigits;
private:
    // copy constructors are not implemented yet
    OP_FixNameParms( const OP_FixNameParms &copy );
    OP_FixNameParms &operator =( const OP_FixNameParms &copy );
};

// This class is used to filter OP_Operators from being instantiated.
// allowOperatorAsChild returns whether or not an operator type can be
// created as a child.
class OP_API OP_OperatorFilter
{
    public:
        OP_OperatorFilter()             { }
        virtual ~OP_OperatorFilter()    { }

        virtual bool allowOperatorAsChild(OP_Operator *)    { return true; }
};

typedef void *(OP_Network::*OP_FindItemFunc) (const char *);

class OP_API OP_Network : public OP_Node
{
public:
    static const char   *getScriptFromTable(const char *table);
    static const char   *getOpTypeFromTable(const char *table);

    // Primary node access methods. Only take OP_Node's into consideration
    virtual int          getNchildren() const;
    virtual OP_Node     *getChild(const char *name=0, int *hint=0) const;
    virtual OP_Node     *getChild(int index) const;
    virtual int          getChildIndex(const OP_Node *) const;

    ///Convenience method, there's often the need to get a list of all children 
    ///which are either 1) picked or 2) not picked but in a picked netbox
    void                 getPickedOrInPickedNetboxChildren(OP_NodeList &list);
    void                 getPickedOrInPicketNetboxPostIts(UT_PtrArray<OP_PostIt*> &list);
   
    int                  getNitems() const;
    OP_NetworkBoxItem   *getItem(int index) const;
    int                  getItemIndex(const OP_NetworkBoxItem *item) const;
 
    // isNetwork returns if the node can have children.  This is true
    // if the node has an operator table or has any children.
    // This does NOT tell you if it is derived from OP_Network.
    virtual int          isNetwork() const;
    
    virtual int          getDandROpsEqual();
    virtual int          updateDandROpsEqual(int check_inputs = 1);

    // This method a node within the network's UT_PtrArray of children
    // dstindex can be any number between 0 and childcount + 1.
    // dstindex refers to the index of the child before which the
    // src node should be moved. Right now, it is only used by OPUI_OpList.
    // As soon as it is used elsewhere, we'll have to add OP_Events for it.
    virtual void         moveChildIndex(int srcindex, int dstindex);

    // These work the same as getOpType* but return what sort of ops
    // this network usually has as children.  Of course, there's
    // always the chance of heterogenous ops skulking around in there
    // so treat it as a guideline rather than an assertion.
    virtual const char  *getChildType() const;
    virtual OP_OpTypeId  getChildTypeID() const = 0;

    int                  getTemplateOps(UT_PtrArray<OP_Node *> &list);

    // obtains the children that match a given operator name.
    // INPUTS:
    //  op_name - the name of a operator to look for (e.g., "object_merge")
    // OUTPUTS:
    //  list - the list of children that are instances of an operator
    //         that is identified by op_name
    // RETURNS:
    //   number of children in the output list
    int                  getOpsByName(const char *op_name,
                                      UT_PtrArray<OP_Node *> &list);

    OP_Node             *peekCurrentNodePtr();
    OP_Node             *getCurrentNodePtr();

    void                 stashCurrentNodePtr(const OP_Node *child);
    OP_Node *            getStashedCurrentNodePtr() const;

    virtual OP_Node     *getDisplayNodePtr();
    virtual OP_Node     *getRenderNodePtr();
    virtual CHOP_Node   *getAudioNodePtr();

    virtual void         childDeleted(OP_Node *);
    virtual void         childUIChange(OP_Node *);
    virtual void         childFlagChange(OP_Node *);

    float                getChildrenScale() const { return myChildScale; }
    void                 setChildrenScale(float scale);

    // Returns the OP_OperatorFilter object for this network. Used to
    // filter out some OP_Operator types. See OP_OperatorFilter above.
    virtual OP_OperatorFilter   *getOperatorFilter();

    /// Adds a new OP_Node of the specified type as a child of this node.
    /// If 'name' is not given, then it will use 'type' suffixed with a unique
    /// numeric suffix. In either case, if the 'name' collides with a
    /// pre-existing node, then the actual node will be created with a unique
    /// name created by numeric suffixing.
    OP_Node             *createNode(const char *type, const char *name = 0,
                                    int notify = 1, int explicitly = 1,
                                    int loadcontents = 1,
                                    int *aliasedScriptedOp = 0,
                                    char *matIconFilename = 0);

    // Create dummy reference proxy nodes for dangling references
    // This should only be called from OP_Node!
    virtual OP_Network  *createProxyRefNode( const char *path );

    OP_Node             *copyNode(const OP_Node *srcnode,
                                  const char *toname = 0,
                                  int reference_parameters = 0);
    
    ///Copy 'srcnetbox' and its contents to this network. 'toname' specifies the
    ///name you'd like the copy to have. If this name has already been taken in 
    ///this network, we'll use a slightly altered unique version of it.
    ///'nodes' may only be non-null when 'save_type' is 
    ///OP_NETWORKBOX_SAVE_SPECIFIED_CONTENTS, in which case it must be a valid
    ///ptr array of nodes in 'netbox'.
    OP_NetworkBox       *copyNetworkBox(OP_NetworkBox *srcnetbox,
                                        OP_NetworkBoxSaveType save_type,
                                        OP_NodeList *nodes = NULL, 
                                        const char *toname = 0,
                                        int reference_parameters = 0);

    OP_PostIt           *copyPostItNote(OP_PostIt *src_note,
                                        const char *toname = 0);
    
    void                 copyPickedNodes(const OP_Network *srcnet, 
                                  OP_Group *newnodes=0, 
                                  const OP_FixNameParms *fix_name_parms=0);

    // Moves the picked nodes from srcnet into this network.
    // If src_nodes_ptr and dest_nodes_ptr are not null, they will be set
    // to the original node pointers and the new node pointers.  (The nodes
    // in src_nodes_ptr will have been deleted.)
    virtual bool         movePickedNodes(OP_Network *src_net,
                                         OP_NodeList *src_nodes_ptr=NULL,
                                         OP_NodeList *dest_nodes_ptr=NULL);

    int                  destroyNode(OP_Node *node);
    int                  destroyNodes(const OP_NodeList &nodes);

    virtual int          renameNode(OP_Node *node, const char *name,
                                    OP_RenameAction action = OP_RENAME_NORMAL);

    /// Obtains the CHOP network to store motion effects. If create is true,
    /// then it will be created if it doesn't exist yet.
    OP_Network *         findOrCreateMotionEffectsNetwork(bool create=true);

    // Delete implicit ancestors. If included is true delete the initial given
    // node as well.  If a state name is passed in, check that the nodes were
    // created by that state. The node is not deleted if any of its outputs do
    // not match the given state. This function will have no effect on nodes 
    // not belonging to this network, or on subnetworks. The deletion will 
    // stop at the first invalid node (if keep_node points to anything, that
    // node is invalid for deletion).
    OP_Node             *deleteImplicitAncestors(OP_Node &node, 
                                const char *state = 0, OP_Node *keep_node = 0,
                                bool included = true);
    // non-destructive version of deleteImplicitAncestors() that just returns
    // the information.
    OP_Node             *getImplicitAncestors(
                                OP_NodeList &implicit_nodes,
                                OP_NodeList &border_nodes,
                                OP_Node &node, 
                                const char *state = 0, OP_Node *keep_node = 0,
                                bool included = true);

    // Fetch all channel collections from this node down.
    int          getAllCollections(UT_PtrArray<CH_Collection *> &list,
                                   int hide=0);

    /// Build a unique node name or a unique operator name from
    /// the one given. We'll pretend we also have children with the names in
    /// 'fakeChildren' when we do our name-collision checking if 'fakeChildren'
    /// is non-NULL.
    void         uniqueNodeName(UT_String &name,
                                UT_SymbolTable *fakeChildren = 0);
    
    // This function is used to make some extra names invalid. Returns 0
    // by default. Used by the VOPNET manager to prevent a new VOPNET
    // with a name that matches an existing operator type.
    virtual int  isInvalidName(const char *name);

    static void  fixName( const char *name, 
                          const OP_FixNameParms &fix_name_parms, 
                          UT_String &fixed_name );

    // I/O methods - there are also the save & load inherited from the
    //  OP_Node class.
    
    ///Save all picked items of the types specified by 'item_type'. Note that
    ///saving any nodes or netboxes implicitly always saves indirect inputs if 
    ///they're picked (legacy behaviour). If 'item_type' includes netboxes, you 
    ///can specify the save policy for netboxes regarding how much of their 
    ///contents they should be saved along with themselves. This is the only way
    ///for a node to remember which netbox it was in.
    OP_ERROR     savePickedItems(ostream &os, const OP_SaveFlags &flags, 
                                 OP_ItemTypeMask item_type, 
                                 OP_NetworkBoxSaveType netbox_save_type = 
                                            OP_NETWORKBOX_SAVE_ALL_CONTENTS);
    
    ///Save all items of the types specified by 'item_type'. Note that
    ///saving any nodes or netboxes implicitly always saves indirect inputs if 
    ///they're picked or part of a picked netbox (legacy behaviour).
    OP_ERROR     saveAllItems(ostream &os, const OP_SaveFlags &flags, 
                                 OP_ItemTypeMask item_type);
    
    ///Saves certain items in a network box, depending on what 'save_type'
    ///specifies. 'nodes' may only be non-null when 'save_type' is 
    ///OP_NETWORKBOX_SAVE_SPECIFIED_CONTENTS, in which case it must be a valid
    ///ptr array of nodes in 'netbox'. Method currently only saves nodes, as 
    ///indirects can be saved only when their parent subnets get saved.
    OP_ERROR     saveItemsInNetworkBox(ostream &os, const OP_SaveFlags &flags,
                                       OP_NetworkBox &netbox, 
                                       OP_NetworkBoxSaveType save_type,
                                       OP_NodeList *nodes = NULL,
                                       int *nsaved = NULL);
  
    // Saves a single node with the same save options on the child nodes
    // as on the top level node, with the exception of network box membership
    // for children (which should always be saved)
    OP_ERROR     saveSingle(ostream &os, OP_Node *op,
                            const OP_SaveFlags &flags);
    // Saves a single node with different save options for the child nodes
    // compared to the top level node.
    OP_ERROR     saveSingle(ostream &os, OP_Node *op,
                            const OP_SaveFlags &flags,
                            const OP_SaveFlags &childflags);

    ///Saves a single netbox. 'save_type' lets you specify the save policy 
    ///with regards to how much of its contents the network box saves with it. 
    ///'nodes' may only be non-null when 'save_type' is 
    ///OP_NETWORKBOX_SAVE_SPECIFIED_CONTENTS, in which case it must be a valid
    ///ptr array of nodes in 'netbox'.
    OP_ERROR     saveSingleNetworkBox(ostream &os, OP_NetworkBox &netbox,
                                      const OP_SaveFlags &flags, 
                                      OP_NetworkBoxSaveType save_type,
                                      OP_NodeList *nodes = NULL);

    /// Save a single post it note.
    OP_ERROR     saveSinglePostIt(ostream &os, OP_PostIt &pnote, const OP_SaveFlags &flags);

    ///In order to avoid duplicately saving nodes in 'op_list' that have already
    ///been saved by their netboxes, make sure to mark those netboxes and then
    ///pass in 'skip_nodes_in_marked_netboxes' as true.
    OP_ERROR     saveOpList(ostream &os, const UT_PtrArray<OP_Node *> &op_list,
                            const OP_SaveFlags &save_flags, 
                            bool skip_nodes_in_marked_netboxes = false,
                            int *nsaved = NULL);

    ///Same as saveSingleNetworkBox(), except saves out a list of network boxes.
    ///Note that you can't use the OP_NETWORKBOX_SAVE_SPECIFIED_CONTENTS option
    ///for 'save_type' though.
    OP_ERROR     saveNetworkBoxList(ostream &os, 
                                    const UT_PtrArray<OP_NetworkBox *> 
                                                                &netbox_list,
                                    const OP_SaveFlags &flags,
                                    OP_NetworkBoxSaveType save_type, 
                                    int *nsaved = NULL);

    //Use when saving a mixture of different types of items into 1 file
    OP_ERROR     saveItemList(ostream &os,
                              const OP_NetworkBoxItemList &item_list,
                              const OP_SaveFlags &save_flags,
                              const OP_NetworkBoxSaveType save_type);

    const char  *getClipboardFile();

    //Note that although we now have an OP_ItemTypeMask parameter available to
    //us, we still need to keep the OP_TileType parameters to indicate saving
    //of groups *boo*
    int          saveToClipboard(int all, OP_TileType type=OP_TILE_NODE,
                                 int grouplist=0, 
                                 OP_ItemTypeMask item_type = OP_ITEMTYPE_NODE);
    int          loadFromClipboard(float x = 0, float y = 0,
                                   int turn_off_display = 0);

    // loadNetwork will load nodes into the current net.  For example,
    //  if there file is "foo.sops", you would call obj->loadNetwork().
    //  if the file were "foo.obj", you would call obj->getParent()->loadNetwork
    bool         loadNetwork(UT_IStream &is, int merge = 0,
                             const char *pattern = 0, int overwrite = 0,
                             const OP_FixNameParms *fix_name_parms = 0);

    bool         pasteNetworkForMove(UT_IStream &is);

    static bool  isOpWritten(UT_IStream &is);

    virtual void clearUnreferencedInputs();

    ///  Check a stream for collisions for loading...  This will add the
    /// problem nodes to 'node_list' and the problem network boxes to 
    /// 'netbox_list', and also return the total number of collisions found...  
    /// It rewinds the stream to the starting point, thus, it can't be used with
    /// stdin! Remember that a node can collide with a network box, since they
    /// share the same namespace!
    int          getLoadCollisions(UT_IStream &is, OP_NodeList &node_list, 
                                   UT_PtrArray<OP_NetworkBox *> &netbox_list,
                                   UT_PtrArray<OP_PostIt *> &pnote_list,
                                   const char *pattern = "*");

    /// Simulates adding items with the names in 'names' to this network, and
    /// stores the resulting names after name-collisions have been addressed 
    /// back into 'names'. This works for anything sharing the node namespace, 
    /// which currently includes nodes and network boxes.
    void         simulateNameCollisions(UT_StringArray &names);

    // The getTrees method returns a list of all the trunk nodes
    // in the collection, where a "trunk node" is defined as a
    // node whose output is not connected to anyone.
    void         getTrees(UT_Pointers *rootlist);

    // The getSortedList() returns an array of all the child nodes sorted
    // alphabetically.
    const UT_PtrArray<OP_Node *>        *getSortedList();

    // getAnyOutputOf will return the first OP found which is has the
    // given OP as an input. Returns null if no such op exists.
    OP_Node     *getAnyOutputOf(OP_Node *op) const;

    // getAnyOP will return any OP in the collection.
    // Null if there are none.
    OP_Node     *getAnyOP() const;

    // Group manipulation methods:
    char        *findUniqueGroupName(const char *basename=0);
    OP_Group    *   findGroup(const char *name) const;
    OP_Group    * createGroup(const char *name=0);
    int          destroyGroup(const char *name);
    int          destroyGroup(OP_Group *group);

    int          getNgroups() const;
    OP_Group    *getGroup(int index) const;
    int          getGroups(UT_PtrArray<OP_Group *> &list, int internal=0);
    int          getMemberships(const OP_Node *node,
                                UT_PtrArray<OP_Group *> &list,
                                int internal=0);

    char        *findUniqueNetworkBoxName(const char *base = NULL);
    char        *findUniquePostItNoteName(const char *base = NULL);

    ///Pass in NULL as the name if you'd like a default name. Passing in 'items'
    ///will automatically create a network box containing those items with the 
    ///netbox positioned properly around them
    OP_NetworkBox         *createNetworkBox(const char *name, 
                                    OP_NetworkBoxItemList *items = NULL);
    
    bool                   destroyNetworkBox(OP_NetworkBox *box);

    ///Returns the number of successfully deleted netboxes
    int                    destroyNetworkBoxes(
                                    UT_PtrArray<OP_NetworkBox *> &netboxes);

    ///Given a path, find the network box specified by it e.g. /obj/model/box1
    virtual OP_NetworkBox *findNetworkBox(const char *const_path);
    virtual OP_PostIt* findPostItNote(const char *const_path);
    
    int                    getNnetworkBoxes() const;
    int                    getNpostItNotes() const;
    
    ///Unlike 'findNetworkBox()', these 2 methods only return netboxes 
    ///contained directly in this network itself (and not those in a child)
    OP_NetworkBox         *getNetworkBox(int index) const;
    OP_NetworkBox         *getNetworkBox(const char *name) const;

    OP_PostIt     *getPostItNote(int index) const;
    OP_PostIt     *getPostItNote(const char *name) const;
    
    void                   getAllNetworkBoxes(UT_PtrArray<OP_NetworkBox *> 
                                                             &netboxes) const;
        
    ///Get all picked network boxes
    void                   getPickedNetworkBoxes(UT_PtrArray<OP_NetworkBox *> 
                                                                       &picked);
    ///Get all picked post it notes
    void                    getPickedPostItNotes(UT_PtrArray<OP_PostIt *> &picked);
    
    /// Return the number of items picked. 'item_type_mask' is a bit field used 
    /// to specify which item types you'd liked to include in the count. Use the
    /// values in OP_ItemType to set the bits in 'item_type_mask'. 
    ///
    /// NOTE: Unlike getPickedItems(), this does NOT check if an item is exposed
    unsigned int nPicked(OP_ItemTypeMask item_type_mask,
                         bool include_hidden_nodes);

    /// Return all picked items of types specified by 'item_type_mask'. 
    /// NOTE: If you want only a single type of item, it's more efficient to use
    /// getPickedChildren(), getPickedNetworkBoxes(), etc...
    void         getPickedItems(OP_ItemTypeMask item_type_mask, 
                                OP_NetworkBoxItemList &picked);

    /// 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.
    /// Does not support indirect parent input searches.
    virtual OP_NetworkBoxItem *findItem(const char *const_path, 
                                        OP_ItemTypeMask item_type = 
                                        OP_ITEMTYPE_ALL);

    /// Returns true if the given node is a child descendent of the same
    /// type with no intervening levels of different type.
    bool         isSubNode(const OP_Node *node) const;

    /// Try to avoid using this method, it only clears the selection for tiles,
    /// not network boxes (network boxes are considered items but not tiles). 
    /// Can use setAllPickFlags() instead. In fact, since there are no group 
    /// tiles in the worksheet any more, this method has become somewhat useless
    void         clearSelection(OP_TileType t=OP_TILE_ALL, int grouplist=0);

    ///Set the pick flags to 'value' for all items of types specified by 
    ///'item_type'
    void         setAllPickFlags(OP_ItemTypeMask item_type, int value = 0);
    void         pickRequest(OP_NetworkBoxItem *item, int shift);
    void         pickRequest(int shift)
                 { OP_Node::pickRequest(shift); }

    ///Set the picked items in the network to be the entries in 'group'
    void         setPickedGroup(const OP_Group *group);
                 
    void         addPicked(const OP_Group *group);      // Pick these nodes
    void         subPicked(const OP_Group *group);      // Removed from picked

    //  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();

    // There are two versions of getOperatorTable. One that takes an
    // operator type and returns the table for that type. The second
    // returns the operator table associated with this network. This
    // latter assumes that "setOperatorTable" has been called. All
    // OP_Network sub-class constructors should do this:
    //
    //      setOperatorTable(getOperatorTable(operatorType));
    //
    // If the script_path is NOT null, this method will create the
    // operator table if it doesn't exist.  Otherwise, it will return
    // null for non-existant table names.
    static OP_OperatorTable     *getOperatorTable(const char *op_type,
                                                  const char *script_path=0);
    OP_OperatorTable            *getOperatorTable() const
                                                  { return myOperatorTable; }
    virtual const char          *getScriptDirectory();

    // this is overridden so that we can clear the group flags
    virtual void                 clearUndoFlags();

    // Sub-networks use parent inputs to connect open inputs in
    // the net to inputs in the parent. A list of the parent connections
    // is the bookeeping required to manage and resolve these connections.
    virtual bool         wantsParentInputs() const;

    ///Get all picked Parent Inputs
    void                 getPickedParentInputs(
                                UT_PtrArray<OP_InputIndirect *> &picked) const;
    
    int                  getNparentInputs() const
                                { return myParentInputs.entries(); }
    OP_InputIndirect    *getParentInput(int index) const;

    // getIndirectString returns a string that can be used to save
    // parent inputs that refer to our parent input table.
    // These are simply saved as a string index into our table.
    // These can be resolved back using resolveIndirectString.
    int                  getIndirectString(OP_InputIndirect *, UT_String &);
    OP_InputIndirect    *resolveIndirectString(const char *);

    virtual void         inputConnectChanged(int which);

    void                 getAllConnectedChildren(
                                    const OP_Node *node,
                                    OP_NodeList &nodes,
                                    bool expandSubnets = true ) const;
    void                 getAllConnectedChildren(
                                    int input_index, OP_NodeList &nodes,
                                    bool expandSubnets = true ) const;

    // The ViewSetting functions are used by ICE to store the name
    // of the COP currently being viewed. Put here because COP_SubNets
    // and ICENET_Nodes both need to store this information.
    virtual void         setViewSetting(const char *) {};
    virtual const char  *getViewSetting() const { return ""; }

    virtual void         dumpDependencies();

    virtual void         changeParmTemplate(PRM_Template *new_template);

    int                  getNumChildManagers(OP_OpTypeId type) const;
    void                 addChildManager(OP_OpTypeId type);
    void                 removeChildManager(OP_OpTypeId type);
    virtual bool         getSaveWithVopnets();
    virtual void         runDelScript();
    void                 clearDelScripts(int pickedOnly);

    /// 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);


    // Do global expansion on a pattern - get lists of network boxes
    // If expand is given, concatenated with full list of names
    // If list is given, appended with list of nodes.
    virtual void         globNetworkBoxes(const char *pat, UT_String *expand,
                                          UT_PtrArray<OP_NetworkBox *> *list=0,
                                          OP_GlobContext *context = 0,
                                          const char *prefix = " ");

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

    ///Save out all the netboxes in this network to 'os' in separate packets
    OP_ERROR     saveNetworkBoxes(ostream &os, const OP_SaveFlags &flags, 
                                  const char *path_prefix);
    OP_ERROR     savePostIts(ostream &os, const OP_SaveFlags &flags, 
                                  const char *path_prefix);

    ///Load a network box from 'is'. Can load from both .hip files and the 
    ///clipboard. 'path' is used as the new netbox's name. If 'overwrite' is
    ///specified, the new netbox will overwrite any other netboxes in this
    ///network with the same name, rather than modify its name to be unique.
    ///'created' is used to return a ptr to the new network box.
    bool         loadNetworkBox(UT_IStream &is,
                                  const char *path = "", int overwrite = 0,
                                  OP_NetworkBox **created = NULL);

    /// Load a post-it note from 'is'. Can load from both .hip files and the 
    /// clipboard. 'path' is used as the new post-it's name. If 'overwrite' is
    /// specified, the new post-it will overwrite any other post-its in this
    /// network with the same name, rather than modify its name to be unique.
    /// 'created' is used to return a ptr to the new post-it.
    bool         loadPostIt(UT_IStream &is,
                                  const char *path = "", int overwrite = 0,
                                  OP_PostIt **created = NULL);

    //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 spareparms);

    /// Returns the unique id of the representative operator that this network
    /// may have.  The changed_child parameter and the current_rep_id are used
    /// in order to minimize the number of findSubNode() calls that are made.
    int                  getRepresentativeNodeId(OP_Node *changed_child,
                                                 int current_rep_id);

    // Changes a child node's type from its current type to 'newtype'
    // the keep... parameters will maintain the same name, pararmeter values
    // and network contents if set to true.
    bool                 changeChildNodeType(OP_Node *child,
                                             const char *newtype,
                                             bool keepname,
                                             bool keepparms,
                                             bool keepcontents,
                                             bool quiet,
                                             int *newChildId=NULL);

    // Returns true if the supplied node is specially marked as editable
    // in this locked HDA node.
    bool                 getIsSubNodeEditable(const OP_Node *subnode) const;

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

    // Save a packet containing the fallback library paths for the specified
    // operators.
    static void          saveOTLBackupInformation(ostream &os,
                                        const OP_OperatorList &fallbackops,
                                        const OP_OperatorList &dummyops);

    /// Pass in NULL as the name if you'd like a default name. 
    OP_PostIt     *createPostItNote(const char *name);

    bool          destroyPostItNote(OP_PostIt *pnote);
    int           destroyPostItNotes(UT_PtrArray<OP_PostIt *> &pnotes);

protected:
    // Protected constructor since networks are only created by Operators.
             OP_Network(OP_Network *parent, const char *name, OP_Operator *op);
    virtual ~OP_Network();

    virtual void         clearAndDestroy(void);
            void         clearAndDestroyNodes(void);

    virtual int          propagateModification(OP_Node *by_whom,
                                               OP_EventType reason,
                                               int parm_index,
                                               OP_PropagateData &prop_data);

    // 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
    virtual void         buildOpDependencies();
    virtual void         notifyRenameDependents( const UT_String &full_from,
                                                 OP_NodeList &cook_nodes );
    virtual void         notifyRenameReferences( const UT_String &full_from,
                                                 OP_NodeList &cook_nodes );
    virtual void         rebuildOpDependents( bool proxy_only );

    // 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();
    virtual int          hasProxyRefNodes() const
                            { return myProxyRefNodes.entries() > 0; }
    void                 removeProxyRefNode( OP_Network *proxy );
    virtual void         moveProxyRefNodes( OP_Network *dest );

    virtual void         moveDependencies( OP_Node *from_node );

    // Override of OP_Node::load to handle some network-specific packets.
    virtual bool         load(UT_IStream &is, const char *ext = "",
                                              const char *path = 0);

    // Called at the end of loadChildOrder()
    virtual void         finishedLoadingChildOrder();

    // Called when loadNetwork finishes loading this whole network.
    virtual void         finishedLoadingNetwork();

    // This overrides the OP_Node function.
    // syncContents loads the given stream into this operator.
    // The stream should be in .hip file format, with "this" pointing to
    // the root node in the .hip file. It handles collisions gracefully
    // by updating the existing operators instead of deleting and
    // recreating them. It deletes any existing nodes not in the
    // stream, and creates nodes if necessary.
    virtual bool         syncContents(UT_IStream &is);

    void                 setOperatorTable(OP_OperatorTable *table);

    // The following should only be called by the director, who doesn't have
    // a real choice, does he?
    virtual void         addNode(OP_Node *node, int notify=1, int explicitly=1);

    OP_Node             *findConnectedNode(OP_Node *op) const;

    // Thses functions ensure we have valid current, render, and display nodes.
    void                 resetDisplayNodePtr(OP_Node *skipthisnode=0);
    void                 resetRenderNodePtr(OP_Node *skipthisnode=0);
    // This function calls all of the above, for when we are deleting nodes.
    void                 validateStatusNodePtrs(const OP_NodeList &skipnodes);

    virtual void         updateExtraFlagPtrs();

    virtual void         nodeUnlocked();

    virtual bool         canDestroyNode();
    virtual void         destroySingleNode(OP_Node *node);

    // This function goes recursively through every node below this one and
    // renames it to some unique but meaningless value. This is used for
    // compiling networks.
    void                 modifyAllChildNodeNames(bool renamepickableobjects,
                                                 const char *prefix, int &id);

    /// This is a helper method to the setChannelScope method.  It traverses
    /// the node's parameters and sets the scope on them according to the
    /// given pattern.
    /// This method is also defined in OP_Parameters, it is overridden here
    /// to provide parsing support for network paths.
    virtual void         traverseScope(const char *pattern, 
                                       OP_ScopeOp scope_op,
                                       const OP_ScopeOptions &scope_opts);


    OP_Node     *myRenderNodePtr;
    OP_Node     *myDisplayNodePtr;

    // Implemented in VOPs. Only the new nodes are to be inserted into the out list,
    // not any of the existing ones.
    virtual void        getAdditionalUndoNodes(const OP_NodeList& orig_list, 
                                OP_NodeList& nodes_for_input_undo) { }

private:
    // Some helper functions for loading and saving.
    OP_ERROR     saveNetwork(ostream &os, const OP_SaveFlags &flags,
                        const OP_SaveFlags &childflags,
                        const char *pathPrefix, bool vopnets);
    OP_ERROR     saveChildNodes(ostream &os, const OP_SaveFlags &flags,
                        const char *pathPrefix, bool vopnets,
                        bool forceNoInit = false);
    OP_ERROR     saveOp(ostream &os, OP_Node *node, const OP_SaveFlags &flags,
                        const OP_SaveFlags &childflags, const char *pathPrefix,
                        bool vopnets, bool forceNoInit = false);
    OP_ERROR     savePostIt(ostream &os, OP_PostIt *pnote, const OP_SaveFlags &flags,
                        const OP_SaveFlags &childflags, const char *pathPrefix,
                        bool vopnets, bool forceNoInit = false);
    bool         loadNodeType(UT_IStream &is, OP_Network *net,
                                UT_String &nodeType, int &matches);
    bool         loadOp(UT_IStream &is, int overwrite, const char *path);
    OP_UndoLoad *beginLoadUndo( OP_Node *save_ops[3] );
    void         endLoadUndo( OP_UndoLoad *op_undo, OP_Node *save_ops[3] );

    // Some helper functions for syncContents.
    bool         syncContentsInit(UT_IStream &is,
                                OP_Network *net, OP_Node *node,
                                UT_String &nodeName, OP_Node *&newnode);
    // a private mentod for setting merge flag
    void         setDoMergeFlag( bool flag )    { myDoMerge = flag; }

    // These functions perform operations that are required after loading
    // a number of new operators. Used by loadNetwork and syncContents.
    void         initSpecialNodes(OP_NodeList &loaded_ops);
    void         sendBulkNotifications(const OP_NodeList &loaded_ops,
                                       const OP_NodeList &op_roots,
                                       bool builddependencies);
    void         fixPendingOverride();

    int          savePartialVerify(ostream &os);
    void         clearParentInputs();
    void         createParentInputs();

    // Build a list of item roots from the stream. In English, this means that
    // 'item_roots' will be populated with the paths of all items at the top 
    // level of this load. Initial stream position is unchanged.
    bool         buildItemRoots(UT_IStream &is, const char *mergePattern,
                                UT_StringArray &item_roots);
    
    // Destroys all child nodes except those that appear in the supplied
    // list. Traverses into child nodes too.
    void         destroyAllNodesExcept(const OP_NodeList &nodes);
    // Then after the list is made, we go through and rename the original
    // items so there won't be any collisions on loading
    void         prepareCollisionNames(const OP_NetworkBoxItemList &items,
                                       UT_WorkBuffer &prefix);
    // Then, after the load, we go through and rename the items to their
    //  original status (renaming the collisions along the way)
    void         fixLoadInputs();               // Resolves references of nodes
    void         fixLoadNames(const OP_NetworkBoxItemList &items,
                              UT_WorkBuffer &prefix,
                              const OP_FixNameParms *fix_name_parms);
    void         sendCreationEvent();
    void         sendPostItCreationEvent();

    int          groupCount() const;    // Doesn't count internal groups.
    OP_ERROR     saveGroupList(ostream &os, int binary = 0);
    bool         loadGroupList(UT_IStream &is, const char *path="");
    OP_ERROR     saveParentInputs(ostream &os, int binary = 0, int picked= 0);
    bool         loadParentInputs(UT_IStream &is, const char *path = "");
    OP_ERROR     saveNetworkData(ostream &os, int binary = 0, int picked= 0);
    bool         loadNetworkData(UT_IStream &is, const char *path = "");
    OP_ERROR     saveChildOrder(ostream &os);
    bool         loadChildOrder(UT_IStream &is);

    // these should surround saving of ops within a network. 
    void         prepareOpSave(ostream &os, const OP_SaveFlags &flags,
                               int &nsaved, int &writeTrailer, 
                               int &picked_indirects);
    void         cleanupOpSave(ostream &os, const OP_SaveFlags &flags,
                               int &nsaved, int &writeTrailer,
                               int &picked_indirects);

    /// A helper function for findUniqueGroupName and findUniqueNetworkBoxName
    /// which takes the "does this item exist" function as a parameter
    char        *findUniqueName(const char *base, 
                                OP_FindItemFunc find);

    ///Saves nodes that are picked or in picked network boxes, depending on the
    ///value of 'netbox_save_type'. 
    OP_ERROR     savePickedOrInPickedNetboxNodes(ostream &os, 
                                        const OP_SaveFlags &flags, 
                                        OP_NetworkBoxSaveType netbox_save_type =
                                              OP_NETWORKBOX_SAVE_ALL_CONTENTS,
                                        int *nsaved = NULL);

    ///Saves post-its that are picked or in picked network boxes, depending on the
    ///value of 'netbox_save_type'. 
    OP_ERROR     savePickedOrInPickedNetboxPostIts(ostream &os, 
                                        const OP_SaveFlags &flags, 
                                        OP_NetworkBoxSaveType netbox_save_type =
                                              OP_NETWORKBOX_SAVE_ALL_CONTENTS,
                                        int *nsaved = NULL);

    ///Saves all picked network boxes without saving their contents.
    OP_ERROR     savePickedNetworkBoxes(ostream &os, const OP_SaveFlags &flags,
                                        int *nsaved = NULL);
    
    OP_NetworkBoxList                   &getNetworkBoxes();
    OP_PostItNoteList                   &getPostItNotes();

    void         changeNodeIdFromLoad(OP_Node &node, int new_id);
    
private:
    UT_SymbolTable                       mySymbols;
    UT_PtrArray<OP_Node *>               myNodes;
    UT_PtrArray<OP_Network *>            myProxyRefNodes;
    UT_PtrArray<OP_Node *>               mySortedList;
    UT_PtrArray<OP_InputIndirect *>      myParentInputs;
    OP_GroupList                         myGroups;
    OP_NetworkBoxList                    myNetworkBoxes;
    OP_PostItNoteList                    myPostItNotes;
    OP_OperatorTable                    *myOperatorTable;
    OP_Node                             *myLastLoadedOpPtr;
    OP_NetworkBox                       *myLastLoadedNetworkBox;
    OP_PostIt                           *myLastLoadedPostIt;
    OP_Node                             *myCreatedNode;
    OP_NetworkBox                       *myCreatedNetworkBox;
    OP_PostIt                           *myCreatedPostIt;
    UT_IntArray                          myEditableSubNodes;

    float                                myChildScale;
    int                                  myDandRCounter;
    short                                myDandROpsEqual;
    char                                 myNameSortDirty;
    char                                 myOpLoadedFlag;
    bool                                 myDoMerge;
    bool                                 mySkipBadNode;
    
    ///Note: Exists only to provide backwards compatibility for loading of saves
    ///done with the original network box save algorithm. Otherwise deprecated.
    bool                                 myClipboardNetboxLoad;
    
    int                                  myLastInputChanged;

    int                                  myChildManagerCount[NUM_MANAGERS];

    int                                  myStashedCurrentNodeId;

    friend class                         OP_Director;
};

OP_API const UT_SymbolTable *OPgetGlobalOperatorTables();
#endif

---