OP/OP_ScriptOperator.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
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        OP_ScriptOperator.h ( OP Library, C++)
 *
 * COMMENTS:    Reads an OP definition from a script to generate the parm
 *              template, etc.
 */

#ifndef __OP_ScriptOperator__
#define __OP_ScriptOperator__

#include "OP_API.h"
#include <sys/types.h>
#include <UT/UT_SymbolTable.h>
#include "OP_Operator.h"

class UT_InfoTree;
class PRM_ScriptParm;
class PRM_ScriptPage;
class PRM_ScriptImports;
class PRM_Name;
class DS_Stream;
class OP_Node;

// Function to call for each parameter.  Return 1 if successful, 0 if fail.
typedef int (*OP_ScriptParmFunc)(OP_Node *node, PRM_Template *temp,
                                 int idx, float t, void *data);

class OP_API OP_ScriptOperator : public OP_Operator
{
public:
    virtual ~OP_ScriptOperator();

    static OP_ScriptOperator    *createMantraScriptOp(const char *name,
                                                      const char *english);

    virtual bool                 hasLoadedParmTemplates() const;
    virtual int                  updateParmTemplates();
    virtual PRM_Template        *getParmTemplates();
    virtual PRM_ScriptImports   *getParmTemplateImports();

    void         getScriptName(UT_String &name,
                               bool forvex, bool for_python=false) const;

    void         resetTemplate(OP_TemplatePair *pair);
    void         resetVariables(OP_VariablePair *vars);

    // Build a command line for the script to be called with.  This does all
    // the channel evaluation and string expansion required.  If there is an
    // error, 0 is returned (otherwise 1). This function essentially calls
    // OP_Parameters::buildVexCommand, using the right template list, and
    // prefixing the script name.
    int          buildVexCommand(UT_String &result, OP_Node *node, float now);

    // Build a index entry for our script operator:
    void         buildIndexEntry(UT_String &result, const UT_String &dsloc);

    // This will find all matching files in the correct Houdini path location
    // and build a list of their contents.
    // *NOTE* The caller will be responsible for cleaning up the
    //        definition array elements.
    static int   findScriptOperators(const char *path,
                                     const char *filename,
                                     OP_OTLDefinitionArray &defs);
    // Get the table that lists all index files read by parseIndex.
    static UT_SymbolTable       &getAllIndexFiles();

    // This will traverse the parameters for the script and call traverseFunc
    // for each.  If there is an error, 0 is returned (otherwise 1).
    int          traverseCommand(OP_Node *node, 
                                 OP_ScriptParmFunc traverseFunc, void *data,
                                 float now);

    // Currently, only VEX is supported
    enum {
        OP_SYNTAX_VEX,          // Vex syntax for building command
        OP_SYNTAX_SHELL,        // Shell syntax for building command
        OP_SYNTAX_RMAN          // Renderman syntax for building command
    };

    // If the grammar of the dialog script needs to be changed, then the
    // following routine can be used to handle tokens.
    // It should return 1 if the token is handled, otherwise 0.
    virtual int          handleUnknownToken(DS_Stream &is, UT_String &token);

    UT_String           &getScriptHelp()        { return myHelp; }
    virtual const char  *getOperatorShortHelpString();
    virtual void         getOperatorSpecificInfoText(int verbose,
                                                     UT_WorkBuffer &text);

    /// Fill in this info tree with details about this operator (similar to
    /// getOperatorSpecificInfoText(..)
    virtual void         fillInfoTreeOperatorSpecific(UT_InfoTree &tree);          
    // Edit the script file.  We check the script to see if it has any of the
    // common object code file extensions.  If it does, then we replace it with
    // the extension given.  The common object code extensions are:
    //          .slo, .so, .vex
    // The object code file extensions array must be null terminated.  If the
    // file is not found, the context is used in the funciton declarator.
    void                 editScriptFile(const char *pathprefix,
                                        const char *context = "surface",
                                        const char *extension = ".vfl",
                                        const char *title = "VEX Function",
                                        const char **obj_extensions = 0,
                                        int localdir = 1);

    // If this node type uses Python to cook, this method will return the
    // compiled version of that code.  This method caches its results, so
    // subsequent calls to it will avoid reloading and recompiling the
    // code.  This way, the sop can recook without reading from disk.
    // When the node type is changed, the cache is cleared.
    PY_CompiledCode     *getCachedCompiledPythonCookCode();

    // To force our parm templates to be reloaded, we just reset our parm
    // dialog time stamp, and call updateParmTemplates.
    virtual void         forceUpdateParmTemplates();

    virtual PRM_Template        *getLayoutParmTemplates();
    virtual PRM_ScriptImports   *getLayoutParmTemplateImports();
    virtual const PRM_Template  *getBaseParmTemplates();

protected:
    OP_ScriptOperator(  const char       *name,
                        const char       *english,
                        OP_Constructor    construct,
                        PRM_Template     *templates,
                        unsigned          min_sources,
                        unsigned          max_sources = 9999,
                        CH_LocalVariable *variables = 0,
                        unsigned          flags = 0);

    // Dummy virtuals that aren't implemented at this level.
    virtual void                 removeAllBindings()
                                 { }
    virtual void                 refreshAllBindings()
                                 { }
    virtual PRM_Template        *loadParmTemplates(UT_IStream & /*is*/,
                                            const char * /* filename */,
                                            UT_String & /* scriptName */,
                                            PRM_ScriptImports *& /* imports */)
                                 { return 0; }

    // Use this method to free parm templates.
    static void                  freeParmTemplates(PRM_Template *templates);

    // Use this method to free switcher defaults.
    static void                  freeSwitcherDefaults(PRM_Default *defs);

    UT_String                    myScriptName;
    UT_String                    myHelp;
    PRM_Template                *myBase;
    PRM_ScriptPage              *myPage;
    PRM_ScriptImports           *myImports;
    time_t                       myDialogTimeStamp;
    int                          myStartParm, myEndParm;

    PRM_Template                *myLayoutParmTemplates;
    PRM_ScriptImports           *myLayoutParmImports;

    // The following information (if set) is used to insert a folder into the
    // specified switcher from myBase.  myBaseSwitcherDefaults is allocated
    // using malloc and must not be destroyed before myParmTemplates.
    int                          myBaseControlsSwitcherIndex;
    int                          myBaseControlsSwitcherPageNum;
    int                          myBaseControlsInsertIndex;
    PRM_Default                 *myBaseSwitcherDefaults;

    // Format for generating cmd
    unsigned                     mySyntax;

    // The info text that contains a short help string.
    UT_String                    myInfoText;

    // A table containing all the index files that get read by parseIndex.
    static UT_SymbolTable        theAllIndexFiles;
};


// This class is a small helper class that parses out the extra info from
// the otl definition.
class OP_API OP_ScriptOpExtraInfo
{
public:
                 OP_ScriptOpExtraInfo();
                 OP_ScriptOpExtraInfo(const UT_String &extra_info);
                ~OP_ScriptOpExtraInfo();


    // Call this method to parse the extra info string.  After this call, you
    // can use the query methods below.
    void         parseExtraInfo(const UT_String &extra_info);

    // Call this method to retrieve an extra info string that represents the
    // state of this object.
    void         getExtraInfoString(UT_String &extra_info);

    bool         getHideDefaultParms() const
                 { return myHideDefaultParms; }
    void         setHideDefaultParms(bool hide)
                 { myHideDefaultParms = hide; }

    const char  *getRepresentativeNodePath() const 
                 { return (const char *)myRepresentativeNodePath; }
    void         setRepresentativeNodePath(const char *path)
                 { myRepresentativeNodePath.harden(path); }

    const char  *getGuideNodePath() const
                { return (const char *)myGuideNodePath; }
    void        setGuideNodePath(const char *path)
                { myGuideNodePath.harden(path); }

    const char  *getOpSubType() const
                 { return (const char *)myOpSubType; }
    void         setOpSubType(const char *type)
                 { myOpSubType.harden(type); }

    static void  createSubTypeString(UT_String &result, const char *subtype);

protected:
    // Resets the data in this class, we do this before we parse a new string.
    void        resetSettings();
     
private:
    bool        myHideDefaultParms;
    UT_String   myRepresentativeNodePath;
    UT_String   myGuideNodePath;
    UT_String   myOpSubType;
};

#endif

---