OP/OP_Director.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:
 *      Mark Elendt
 *      Side Effects Software Inc.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        OP Library (C++)
 *
 * COMMENTS:
 *      The OP_Director class is a collection (network) of managers.
 *      The Managers register themselves with an active OP_Director
 *      when they are created. The active OP_Director is obtained
 *      via the global function (yuch) OPgetDirector().
 *
 */

#ifndef __OP_Director_h__
#define __OP_Director_h__

#include <UT/UT_IntArray.h>
#include <UT/UT_PtrArray.h>
#include <UT/UT_LHSTuple.h>
#include <UT/UT_Thread.h>
#include <UT/UT_ThreadSpecificValue.h>
#include "OP_API.h"
#include "OP_CommandManager.h"
#include "OP_OTLManager.h"
#include "OP_OperatorTable.h"
#include "OP_Node.h"
#include "OP_Network.h"

#define OP_POSTLOAD_SCRIPT      "456.cmd"

class UT_WorkArgs;
class UT_WorkBuffer;
class UT_Args;
class OP_SaveCallback;
class OP_ExprFunc;
class op_ShopClerkInfo;
class OP_BundleList;
class OP_Take;
class OP_GlobContext;
class PI_EditScriptedParms;
class PRM_ScriptPage;

typedef void (*OP_GlobalOpChangedCallback)(OP_Node *node, OP_EventType reason,
                                           void *data, void *cbdata);
typedef UT_PtrArray<OP_GlobalOpChangedCallback> OP_GlobalOpChangedCallbacks;

class OP_API OP_Director : public OP_Network, public OP_OTLManagerSink
{
public:
             OP_Director(const char *name, const float version,
                         int load_dsos = 1);
    virtual ~OP_Director();

    virtual OP_OpTypeId  getOpTypeID() const { return DIR_OPTYPE_ID; }
    virtual const char  *getOpType() const { return DIR_OPTYPE_NAME; }
    virtual OP_DATA_TYPE getCookedDataType() const { return OP_NO_DATA; }
    virtual void        *getCookedData(OP_Context &) { return 0; }
    virtual void         deleteCookedData() { }
    virtual int          saveCookedData(ostream &, OP_Context &,
                                        int = 0) { return 1; }
    virtual bool         loadCookedData(UT_IStream &, const char * /*data*/=0)
                                        { return true; }
    virtual int          saveCookedData(const char *,
                                        OP_Context &) { return 1; }
    virtual OP_OpTypeId  getChildTypeID() const { return MGR_OPTYPE_ID; }
    virtual const char  *getChildType() const { return MGR_OPTYPE_NAME; }

    OP_Network          *getManager(const char *name) const;
    CH_Manager          *getChannelManager() { return &myCommandManager; }
    OP_CommandManager   *getCommandManager() { return &myCommandManager; }
    float                getVersion() const { return myVersion; }

    // NB: clearNetwork() will always reload the channel manager options!
    //     However, the user is responsible as to when we save them
    bool                 loadChannelManagerOptions();
    bool                 saveChannelManagerOptions();

    virtual void         enable(int state);

    OP_ERROR             saveNetwork(ostream &os, const OP_SaveFlags &options);
    bool                 loadNetwork(UT_IStream &is, int merge=0,
                                     const char *mergePattern=0,
                                     int overwrite=0);
    virtual void         clearNetwork( int clear_aliases );

    // This will go through the entire hip file and cook all the CHOPs
    // that have their export flags set and cook them with CookOverride
    // turned on.
    virtual void         opUpdateAllExports();

    void                 setOldCHOPOverrideFlag() 
                         { myOldCHOPOverrideFlag = true; }
    bool                 getOldCHOPOverrideFlag() 
                         { return myOldCHOPOverrideFlag; }
    void                 clearOldCHOPOverrideFlag() 
                         { myOldCHOPOverrideFlag = false; }

    OP_Node             *getCwd()
                            { return getCwd(UTgetSTID()); }
    void                 getCwd(UT_String &str)
                            { getCwd(UTgetSTID(), str); }

    OP_Node             *getCwd(int thread);
    void                 getCwd(int thread, UT_String &str);
    void                 setCwd(int thread, const OP_Node *node,
                                int eval_collection=-1);

    // pushCwd() pushes the current cwd onto a stack that can later be restored
    // using popCwd(). The optional new_cwd parameter sets the cwd to it at
    // the same time.
    void                 pushCwd(int thread, const OP_Node *new_cwd = NULL);
    void                 popCwd(int thread);

    bool                 getPickedNodes(OP_NodeList &picked_nodes,
                                        bool include_hidden=false,
                                        bool append_to_list=false) const;
    const UT_IntArray &  getPickedNodeIds() const
                            { return myPickedNodeIds; }
    OP_Node *            getLastPickedNode(OP_Node *parent = NULL) const;

    void                 clearPickedItems();

    // Pick the given item, clearing all other picked items first. This is here
    // so that we can prevent an extra undo if the current state already
    // matches what we want.
    void                 makeOnlyPickedCurrent(OP_NetworkBoxItem &item);

    void                 setEditNetworkUI(OP_Network *net);

    // These next 3 methods should only be called from OP_Node::setPicked()
    // The myPickedNodeIds array can't contain duplicates and maintains the
    // invariant that:
    // - node.getPicked() is TRUE iff it is in the list.
    // - node.getPicked() is FALSE implies that it is NOT in the list.
    void                 addPickedNode(const OP_Node &node, bool edit);
    void                 removePickedNode(const OP_Node &node, bool edit);
    void                 makePickedNodeLast(const OP_Node &node, bool edit);

    // These next 2 methods should only be called from
    // OP_NetworkBox::setPicked() The myPickedNetworkBoxIds array can't contain
    // duplicates and maintains the invariant that:
    // - netbox.getPicked() is TRUE iff it is in the list.
    // - netbox.getPicked() is FALSE implies that it is NOT in the list.
    void                 addPickedNetworkBox(const OP_NetworkBox &netbox);
    void                 removePickedNetworkBox(const OP_NetworkBox &netbox);

    void                 addPickedPostItNote(const OP_PostIt &pnote);
    void                 removePickedPostItNote(const OP_PostIt &pnote);

    void                 setTime(float frame);
    void                 setFPS(float fps);
    void                 setNFrames(float nframes);
    void                 setTimeRange(float tstart, float tend);

    /// The save callback is called when saving .hip files. It is called with
    /// a stream reference to the .hip file so that the callback can insert
    /// hscript commands into the .hip file's .application section. When a
    /// .hip file is loaded, all the commands in the .application section are
    /// executed.
    // @{
    void                 setSaveCallback(OP_ERROR (*cb)(ostream &, void *),
                                         void *callbackData);
    void                 removeSaveCallback(OP_ERROR (*cb)(ostream &, void *),
                                         void *callbackData);
    // @}

    void                 setCustomPanelSaveCallback(
                                OP_ERROR (*cb)(ostream &, void *),
                                void *callbackData);
    void                 setUserDisplayOptionSaveCallback(
                                OP_ERROR (*cb)(ostream &, void *),
                                void *callbackData);
    void                 addBadLoadData(char *str, int len);
    virtual int          isManager() const;

    int                  isLoading() const  { return (myInLoadCount > 0); }
    void                 beginLoading();
    void                 endLoading();
    bool                 getIsLoadingHip() const
                                            { return myIsLoadingHip; }
    bool                 getIsQuitting() const
                                            { return myIsQuitting; }
    void                 setIsDoingExplicitSave(bool value)
                                            { myIsDoingExplicitSave = value; }
    bool                 getIsDoingExplicitSave() const
                                            { return myIsDoingExplicitSave; }

    bool                 getIsMantra() const    { return myIsMantra; }
    void                 setIsMantra(bool v)    { myIsMantra = v; }

    void                 beginTakeSwitch();
    void                 endTakeSwitch();
    bool                 isSwitchingTake() const
                                            { return mySwitchingTake; }

    virtual int          renameNode(OP_Node *, const char *, 
                                    OP_RenameAction);

    // These methods are only called by the network load/save
    void                 saveChannelGroups(ostream &os, int binary);
    bool                 loadChannelGroups(UT_IStream &is, const char *path);
    void                 saveTimeGroups(ostream &os, int binary);
    bool                 loadTimeGroups(UT_IStream &is, const char *path);
    void                 saveScriptedOpLibrary(ostream &os);
    bool                 loadScriptedOpLibrary(UT_IStream &is, int modtime);
    bool                 loadScriptedOpDefs(UT_IStream &is);
    void                 saveInternalOpLibraries(ostream &os);
    bool                 loadInternalOpLibraries(UT_IStream &is);
    void                 saveLibraryPreferences(ostream &os);
    bool                 loadLibraryPreferences(UT_IStream &is);
    bool                 loadHOMSessionModuleSource(UT_IStream &is);
    void                 saveUnselectedFilePatterns(ostream &os);
    bool                 loadUnselectedFilePatterns(UT_IStream &is);

    void                 saveOTLBackupInformation(ostream &os);

    OP_ExprFunc         *getExprFunctions();
    void                 saveExprFunctions(ostream &os);
    bool                 loadExprFunctions(UT_IStream &is, const char *path);

    OP_BundleList       *getBundles()   { return myBundles; }

    int                  incrPasteCount() { return ++myPasteCount; }
    void                 resetPasteCount() { myPasteCount = 0; }

    // In core, we store only an id, however, for disk files, we write out the
    // authors name.  When no name is passed in, the current authors ID is
    // returned.
    int                  getAuthorId(const char *name=0);
    const char          *getAuthorName(int id);

    // These track the current update mode: Should an OP recook?
    int                  cookEnabled() const
                         { return myCookEnabled; }
    void                 setCookEnabled(int state)
                         { myCookEnabled = state; }

    // These track the simulation update mode: Should simulations cook?
    int                  simulationEnabled() const
                         { return mySimulationEnabled; }
    void                 setSimulationEnabled(int state)
                         { mySimulationEnabled = state; }

    // These control whether those simulations reset by output drivers should
    // reset based on the global or playback playbar range.
    bool                 skipPlaybarBasedSimulationReset() const
                            { return mySkipPlaybarBasedSimulationReset > 0; }
    void                 bumpSkipPlaybarBasedSimulationReset(int inc)
                            { mySkipPlaybarBasedSimulationReset += inc; }

    // These methods are used by SHOPs to keep track of visible clerks.
    bool                 addShopClerk(const char *type);
    int                  getNShopClerks() const
                         { return myShopInfo.entries(); }
    const char          *getShopClerkName(int clerk) const;
    int                  getShopClerkVisibility(int clerk) const;
    void                 setShopClerkVisibility(int clerk, int onoff);

    // This function does nothing at this level, but it is meant to be
    // overridden to create new OP_OperatorInfos for the given table based
    // on the existance of VOP networks.
    virtual void         findInternalScriptOperators(
                                const char * /* indexPath */,
                                OP_OTLDefinitionArray & /* defs */)
                         { }
    virtual OP_Node     *linkInternalScriptOperator(
                                const char * /* definitionOp */,
                                OP_Operator * /* op */)
                         { return 0; }
    virtual void         getInternalScriptDefinition(
                                OP_Node * /* definitionOp */,
                                UT_String & /* definition */)
                         { }
    // Save the spare parameters section for the specified node. We have
    // to do this through a virtual function that is actually implemented
    // in the MOT library because it requires the PI_EditScriptedParms
    // class.
    virtual OP_ERROR     saveNodeSpareParms(OP_Parameters *,
                                            bool,
                                            ostream &) const
                         { return UT_ERROR_NONE; }
    // Load the spare parms section for a node. Although it doesn't require
    // the PI library, this function is also implemented in the MOT library
    // just to keep the save and load code paths in a similar location.
    virtual bool         loadNodeSpareParms(OP_Parameters *,
                                            UT_IStream &,
                                            UT_String &) const
                         { return true; }
    // Adds a single spare parm to the specified node. This function exists
    // for backward compatibility with spare parms from H8. This function is
    // implemented in the MOT library where we have access to the PI classes
    // for editing parms (PI_EditScriptedParms).
    virtual bool         addNodeSpareParm(OP_Parameters * /*node*/,
                                          PRM_Template * /*parmtemplate*/) const
                         { return false; }
    // Removes a single spare parm to the specified node. This function exists
    // for backward compatibility with spare parms from H8. This function is
    // implemented in the MOT library where we have access to the PI classes
    // for editing parms (PI_EditScriptedParms).
    virtual bool         removeNodeSpareParm(OP_Parameters * /*node*/,
                                             const char * /*parmname*/,
                                             UT_StringArray * /*errs*/ = NULL,
                                             UT_StringArray * /*warn*/ = NULL
                                             ) const
                         { return false; }
    // Updates the spare parms of a node to match the supplied
    // PI_EditScriptedParms. This class isn't defined until the PI
    // library, so this function is actually implemented in MOT_Director.
    virtual void         changeNodeSpareParms(OP_Parameters *,
                                              PI_EditScriptedParms &,
                                              UT_String &) const
                         { }
    // Save a series of hscript commands to a stream to replicate the
    // spare parameters of the specified node.
    virtual void         saveNodeSpareParmCommands(OP_Parameters *,
                                                   ostream &,
                                                   const char *,
                                                   bool) const
                         { }
    // Delete spare parameter/base parameter mixing layout. This puts the
    // spare parameters on their own page.
    virtual void         deleteNodeSpareParmLayout(OP_Parameters *) const
                         { }
    // Delete all spare parameters on a node.
    virtual void         deleteAllNodeSpareParms(OP_Parameters *) const
                         { }

    virtual PRM_ScriptPage      *allocateSpareScriptPage(OP_Operator *)
                         { return 0; }

    // Functions for saving and loading compiled VEX and RSL code for nodes
    // with VOP_CodeGenerators in a compiled hip file.
    virtual void         saveNodeCompiledCode(OP_Node *, ostream &)
                         { }
    virtual bool         loadNodeCompiledCode(OP_Node *, UT_IStream &)
                         { return true; }
    virtual void         saveNodeCompiledDs(OP_Node *, ostream &)
                         { }
    virtual bool         loadNodeCompiledDs(OP_Node *, UT_IStream &)
                         { return true; }

    OP_Take             *getTakeManager()       { return myTakeManager; }

        // deprecated method: interest gets cleared out before every cook
    virtual void         addExtraInput(OP_Node *op, OP_InterestType type);

    // A utility function to glob (pattern expand) all arguments on a command
    // line.
    static int           globAllArguments(OP_Node *node, UT_Args &args,
                                          UT_WorkBuffer &workbuf,
                                          UT_WorkArgs &argv,
                                          OP_ItemTypeMask item_type,
                                          OP_GlobContext *context,
                                          int startitem = 1);

    // This function is similar to the one above, except it takes a string
    // pattern (which may contain spaces) and returns an array of matching
    // nodes and/or netboxes.
    static void          globAllArgumentsAsArray(OP_Node &relative_to_node,
                                    const char *pattern,
                                    OP_ItemTypeMask item_type,
                                    OP_GlobContext &glob_context,
                                    UT_PtrArray<OP_NetworkBoxItem *> &result);

    // These functions are the instantiations of the virtual functions
    // from our OP_OTLManagerSink base class.
    virtual void         definitionsAdded(int libindex,
                                          UT_IntArray &defindex);
    virtual void         definitionsRemoved(int libindex,
                                            UT_IntArray &defindex,
                                            OP_OTLLibrary *&preserve);

    // Given a path of the form "tablename/opname", return the table and
    // operator indicated by the path. The relativetonode parm is used when
    // the path is actualy a node path, and we want the table and operator
    // of the node specified by the path. If it is a relative path, the
    // relativetonode is the starting point. If it is null, the current
    // working node is used, or the director.
    void                 getTableAndOperator(const char *path,
                                             OP_OperatorTable *&table,
                                             OP_Operator *&op,
                                             const OP_Node *relativetonode = 0);
    OP_OTLManager       &getOTLManager()
                         { return myOTLManager; }
    const OP_OTLManager &getOTLManager() const
                         { return myOTLManager; }

    // This function should be called right before exiting. It will go
    // through all OP_Operators with active nodes and run the POSTLASTDELETE
    // event script (though it doesn't actually delete the nodes).
    void                 runDeleteScriptsOnQuit();

    // Add or remove callback functions that get executed whenever we call
    // OP_Node::opChanged.
    void                 addGlobalOpChangedCallback(
                            OP_GlobalOpChangedCallback cb, void *cbdata);
    void                 removeGlobalOpChangedCallback(
                            OP_GlobalOpChangedCallback cb, void *cbdata);
    // This function is called any time OP_Node::opChanged is called. It sends
    // the change information along to any global op change callback functions
    // that have been registered by addGlobalOpChangeCallback.
    void                 globalOpChanged(OP_Node *node,
                                         OP_EventType reason,
                                         void *data);

    // This function creates a backup of the specified file, if the option
    // to save backup files is turned on. The actual file name and file type
    // are irrelevent. It returns true if the backup was successful (or was
    // not required).
    static bool          createBackupFile(const char *filename);
    // This function will rename the current file "filename" to the next
    // filename in the sequence to free up "filename" so that it can be
    // saved over.
    static void          autoIncrementRename(const char *filename,
                                             UT_String &errorstring,
                                             bool movefile,
                                             bool autosave);



    void                    runScript(CMD_Manager *cman, const char *filename);
    boost::tuple<bool, int> runPython(CMD_Manager *cman, const char *filename);
    boost::tuple<bool, int> runPython(CMD_Manager *cman, int argc,
                                      char *argv[]);
    boost::tuple<bool, int> runDefaultStartupScripts(CMD_Manager *cman, 
                                        const char *startup_script,
                                        const char *postload_script);

protected:
    virtual OP_ERROR     cookMe(OP_Context &) { return UT_ERROR_NONE; }
    virtual OP_ERROR     bypassMe(OP_Context &, int &) { return UT_ERROR_NONE; }
    virtual const char  *getFileExtension(int binary) const
                         { return binary ? ".bhip" : ".hip"; }
    void                 clearUnsupportedCommands() const;

    // This function is called when we update our OTL for an operator. It
    // does nothing at this level, but in MOT it will clear out the PI
    // settings that have been saved for the specified operator type.
    virtual void         clearHandleSettings(OP_Operator *) { }

    // We don't allow spare parms on the director, so just ignore this call.
    virtual bool         changeSpareParms(UT_IStream &, UT_String &errors)
                         {
                             errors += "Spare parameters are not alowed on ";
                             errors += "the root node.";
                             return false;
                         }

private:
    // Disallow copying of OP_Director, these methods are not implemented
    // on purpose
    OP_Director(const OP_Director &copy);
    OP_Director &operator =(const OP_Director &copy);

    void                 installCommands();
    void                 installMoreCommands();
    void                 installCHCommands();
    void                 installOTLCommands();
    void                 savePreCommands(ostream &os);
    void                 savePostCommands(ostream &os);

    /// Runs the user-defined post load script when loading
    /// a new network into Houdini.
    void                 runPostLoadScript();


    /// Helper function for runDefaultStartupScripts().
    /// Passes back the full path of the first finding of inputpath
    /// in the script search directories.  The file name of outputpath
    /// may end in any of the acceptable script file extensions
    /// (i.e. .py or .cmd).
    void                 getFirstFoundScriptFile(UT_String &outputpath, 
                                                 const char *inputpath);
    
    int                                  myPasteCount;
    char                                *myBadLoadData;
    int                                  myBadLoadDataLen;
    OP_CommandManager                    myCommandManager;
    float                                myVersion;
    int                                  myInLoadCount;

    struct CwdContext
    {
        CwdContext() : myCwdId(-1)
        {
        }
        int                              myCwdId;
        UT_IntArray                      myCwdStack;
        UT_IntArray                      myEvalCollectionStack;
    };
    UT_ThreadSpecificValue<CwdContext>   myCwdContext;

    UT_IntArray                          myPickedNodeIds;
    UT_IntArray                          myPickedNetworkBoxIds;
    UT_IntArray                          myPickedPostItIds;

    OP_SaveCallback                     *myCallbacks;
    OP_SaveCallback                     *myCustomPanelCallback;
    OP_SaveCallback                     *myUserDisplayOptionCallback;
    OP_BundleList                       *myBundles;
    OP_Take                             *myTakeManager;

    int                                  myCookEnabled;
    int                                  mySimulationEnabled;
    int                                  mySkipPlaybarBasedSimulationReset;
    UT_PtrArray<op_ShopClerkInfo *>      myShopInfo;

    OP_OTLManager                        myOTLManager;
    OP_OperatorTableList                 myTablesToReload;
    UT_SymbolTable                      *myDummyDefinitionActivations;

    OP_GlobalOpChangedCallbacks          myGlobalOpChangedCallbacks;
    UT_PtrArray<void *>                  myGlobalOpChangedCallbackData;

    // This flag tracks whether any OPs that got loaded had the old
    // style override flag.  If so, we know we will have to do a complete
    // update.
    bool                                 myOldCHOPOverrideFlag;
    // This flag tracs whether or not we are inside a call to loadNetwork.
    // This is different from the isLoading flag, which gets set during any
    // network load.
    bool                                 myIsLoadingHip;
    bool                                 mySwitchingTake;
    // This value is temporarily set to true when the user explicitly asks
    // for a hip file save either by executing an mwrite, or choosing Save
    // or Save As from the File menu.
    bool                                 myIsDoingExplicitSave;
    // This flag is set to true while Houdini is exiting.
    bool                                 myIsQuitting;
    
    // This flag is set when the OP director is created for mantra.  There are
    // some OP features which are expensive (i.e. importing the hou python
    // module).  This option disables those features.
    bool                                 myIsMantra;
};

OP_API extern OP_Director       *OPgetDirector();
OP_API extern OP_Director       *OPsetDirector(OP_Director *boss);

#endif

---