VOP/VOP_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:        VOP Library (C++)
 *
 * COMMENTS:    The base class for all VOP operators
 *
 */

#ifndef __VOP_Node_h__
#define __VOP_Node_h__

#include <set>
#include <map>

#include "VOP_API.h"
#include <UT/UT_PtrArray.h>
#include <UT/UT_BitArray.h>
#include <OP/OP_Network.h>
#include "VOP_OperatorInfo.h"
#include "VOP_Language.h"
#include "VOP_Error.h"

// The name of the parameter that contains the ordering of the
// VOPNET Parameters.
#define VOP_PARMORDER_NAME              "parmorder"
#define VOP_GLOBAL_NODE_NAME            "global"
#define VOP_ILLUM_NODE_NAME             "illuminance"
#define VOP_PARM_NODE_NAME              "parameter"
#define VOP_CONST_NODE_NAME             "constant"
#define VOP_PARMRAMP_NODE_NAME          "rampparm"
#define VOP_INLINE_CODE_NODE_NAME       "inline"
#define VOP_RSL_PREFIX                  "rsl_"
#define VOP_VARIABLE_INOUT_MAX          2048

class VOP_Node;
class VOP_GlobalVarData;
class VOP_ParmGenerator;
class VOP_AutoConvert;

extern "C" {
    DLLEXPORT extern void       newVopOperator(OP_OperatorTable *table);
};

typedef UT_PtrArray<VOP_Node *>          VOP_NodeList;
typedef UT_PtrArray<VOP_GlobalVarData *> VOP_GlobalVarList;
typedef UT_PtrArray<VOP_ParmGenerator *> VOP_ParmGeneratorList;

struct VOP_AutoConvertInfo
{
    // A pointer to the autoconvert node and a value for the input index.
    VOP_AutoConvert* myACNode;
    int myIndex;
};
typedef vector < VOP_AutoConvertInfo > TAutoConvertInfos;

typedef std::set < int > TIntSet;
struct VOP_MergeNodeInfo
{
    VOP_Node* myNode;
    TIntSet myInputIndices;
};
typedef std::map <VOP_Node*, VOP_MergeNodeInfo> TMergeNodeInfos;

class VOP_API VOP_GlobalVarData
{
public:
    VOP_GlobalVarData()         { }
    ~VOP_GlobalVarData()        { }

    UT_String            myName;
    UT_String            myDescription;
    int                  myVarIndex;
    VOP_Type             myType;
    bool                 myReadable;
    bool                 myWritable;
    bool                 myIlluminanceVar;
};

class VOP_API VOP_OutputNameEditorSource
{
public:
    virtual             ~VOP_OutputNameEditorSource();
    virtual int          getNumInputsFromParent() const = 0;
    virtual void         NAMEFROMPARM(UT_String &str, int idx) const = 0;
    virtual void         LABELFROMPARM(UT_String &str, int idx) const = 0;
    virtual void         setNAMEFROMPARM(UT_String &str, int idx) = 0;
    virtual void         setLABELFROMPARM(UT_String &str, int idx) = 0;
};

class VOP_API VOP_Node : public OP_Network
{
public:
    virtual const char  *getChildType() const;
    virtual const char  *getOpType() const;

    virtual OP_OpTypeId  getChildTypeID() const;
    virtual OP_OpTypeId  getOpTypeID() const;

    //  Nobody should have to override this, but it's public for other people
    virtual OP_DATA_TYPE getCookedDataType() const;

    // Whenever a variable type parm changes, we have to send out an event
    // to get our tile to update.
    virtual void         opChanged(OP_EventType reason, void *data=0);
    virtual void         referencedParmChanged(int pi);
    
    static void          buildOperatorTable(OP_OperatorTable &table);

    // Get the parm block information that will go in the dialog script
    // for our VOPNET.
    virtual void         getParameterBlock(UT_String &parmstr);
    virtual void         getParameterDeclaration(UT_String &parmdecl,
                                            const VOP_Language *language);
    virtual void         getPragmas(UT_String &pragmastr);
    virtual void         getOuterCode(UT_String &codestr);
    virtual void         getCode(UT_String &codestr);
    virtual bool         getParmConstantString(const char *parmname,
                                               VOP_Type type,
                                               UT_String &str,
                                               bool expand_string,
                                               const VOP_Language *l=0);

    // Returns true if this VOP is a VOP_ParmGenerator or subclass.
    virtual bool         getIsParmGenerator() const;

    // Returns true when this VOP is a VOP_ParmGenerator and it's also an
    // export parameter.  varname will contain the export parameter name.
    virtual bool         getExportParm(UT_String &varname);

    // Gives the node a chance to initialize itself when it is first created.
    // This is only used for VOP_ParmGenerator nodes.
    virtual void         initializeNode();

    // Make sure that our parmname parameter (if we have one) doesn't
    // conflict with any other parmname parameter values.
    virtual void         ensureParametersAreValid();
    static void          incrementVariableName(UT_String &varname);

    // Functions to get information about our operator outputs.
    // These just call the getOutputXXXSubclass functions.
    void                 getOutputName(UT_String &out, int idx) const;
    int          getOutputFromName(const UT_String &out) const;
    VOP_Type             getOutputType(int idx);

    // Returns the variable name associated with a given input number.
    // These just call the getInputXXXSubclass functions.
    void                 getInputName(UT_String &in, int idx) const;
    int                  getInputFromName(const UT_String &in) const;
    /// will_autoconvert_out, if not null, is set to true if autoconversion
    /// will be needed, to false otherwise.
    VOP_Type             getInputType(int idx);
    /// Returns all allowed input types on a given input, regardless of what
    /// is currently connected to that input. These do not include types
    /// to which autoconversion is possible.
    virtual void         getAllowedInputTypes(unsigned idx,
                                              VOP_VopTypeArray &voptypes);

    // Returns whether or not this op outputs a variable with a specific name.
    // If so, the second function returns the name of this output variable.
    virtual bool         areOutputVariablesFixed();
    virtual void         getOutputVariable(UT_String &var, int idx);

    // Recurse through our inputs and add them in order to the given list.
    // Note this this might create new auto-conversion nodes in this list,
    // and these will have to be deallocated by the caller.
    void                 mergeInputNodeList(VOP_NodeList &nodes, TMergeNodeInfos &merge_infos);
    virtual bool         forceCodeGenerationOfInputs() const;

    // Get or set the table of global or local variables for this context.
    // The global variables are defined solely by the VEX context. The
    // data associated with each entry is the VEX_Type of the variable.
    // The local variables are those defined by Parameter ops. This
    // table provides a common place to look for variable name conflicts.
    const UT_SymbolTable*getGlobalVariables() const;
    const UT_SymbolTable*getLocalVariables() const;
    const UT_SymbolTable*getLocalChannels() const;
    void                 setTables(const UT_SymbolTable *globals,
                                   UT_SymbolTable *locals,
                                   UT_SymbolTable *channels);
    void                 setTablesFromVop(VOP_Node *vop);
    void                 addLocalVariable(const char *varname,
                                          VOP_ParmGenerator *definer);
    void                 deleteLocalVariable(const char *varname);
    void                 getSortedGlobalVariableList(VOP_GlobalVarList &vars,
                                                     bool mustBeReadable,
                                                     bool mustBeWritable);

    // Functions for getting and setting the in/out LOD value, using the
    // OP_NodeFlag mechanism.
    virtual void         setExtraFlag(char flag, int onoff);
    int                  setInOutLOD(int level, int inoff);
    int                  getInOutLOD(int level) const;

    // Override the setInput functions so that we can send notification to
    // the nodes that are our inputs when we disconnect from them.
    virtual OP_ERROR     setInput(unsigned idx, OP_Node *op,
                                  unsigned outputIdx = 0);
    virtual OP_ERROR     setInputReference(unsigned idx, const char *label,
                                           int keeppos, unsigned outputIdx = 0);

    // For subnet VOPs, when moving an input, we want to go in and
    // reorganize the connections to our subinput and suboutput nodes
    // so that the internal connections remain the same.
    virtual void         moveInput(int srcidx, int dstidx,
                                   bool forcesubnet = false);

    // Return our input node for the give index. If recursive is true and we
    // are in a subnet and the direct input for inputidx is a subnet input
    // node, travel up the parent chain until no longer in a subnet or the
    // input node is not a subnet input node. Basically, we want to know if we
    // are connected to anything meaningful.
    virtual bool         isConnected(int inputidx, bool recursive);

    // Returns a pointer used by OPUI_OutputNameEditor to get and set data.
    virtual VOP_OutputNameEditorSource  *getOutputNameEditorSource()
                         { return 0; }

    // Used by subnet type operators which must always have an output node.
    VOP_Node            *getSubnetOutputNode() const;

    // Create a Parameter or Constant VOP that matches the type, name and
    // value of one of our inputs, and connect it to that input. 'parm'
    // specifies whether to build a Parameter or a Constant.
    VOP_Node            *insertParmGenerator(int inputidx, bool makeparmnode);
    VOP_Node            *insertNode(int inputidx, const char* nodetype, bool connect_to_input, const char* undo_string = NULL);
    
    // Create Parameter or Constant VOPs for all inputs of this node. We
    // don't create nodes for inputs that are already connected.
    void                 insertParmGeneratorsForAllInputs(bool makeparmnodes);

    // The following method is needed to obtain the parameter name to be
    // associated with an input.  It is possible that the parameter name
    // differs from the input name.
    virtual void         getParmNameFromInput(UT_String &parmname,
                                              int inputidx) const;

    // Based on the specified input index, output a parm definition block
    // appropriate for a dialog script. The parm definition provides a
    // default value for the input if it is not connected. If the input is
    // VEX_TYPE_UNDEF, we output nothing and return false. Otherwise we return
    // true.
    bool                 outputDefaultParmDefinition(ostream &os, int idx);

    virtual void         saveDialogScriptExtraInfo(ostream &os);

    // This virtual is overridden by VOP_ParmGenerator so we can find out
    // which VOP defines the actual parameter attributes.
    virtual VOP_Node    *getRealDefinition()
                         { return 0; }

    const VOP_Language  *getLanguage() const
                         { return myLanguage; }

    // Absolute width
    virtual fpreal       getW() const;
    // Absolute height
    virtual fpreal       getH() const;

    // Override clearInterrupted so that we don't recook the whole DOP Network
    // when the user interrupts a cook. The clearInterrupted on the containing
    // VOP Network willb be enough.
    virtual void         clearInterrupted();

    /// Returns EITHER the number of input buttons, or the number of output 
    /// buttons currently displayed on this VOP, which depends on our level of 
    /// detail (LOD). Set 'input_flag' to TRUE to count input buttons, 
    /// false to count output buttons. The value returned does NOT include an 
    /// ellipsis even if one is displayed. If there is an ellipsis, the 
    /// parameter 'ellipsis' will instead be set to true (else set to false).
    void                 getDisplayedButtonCount(bool input_flag,
                                                 int &count,
                                                 bool &ellipsis) const;

    // Calls cacheParmName on all VOP_ParmGenerator nodes under root.
    static void          cacheAllParmNames(OP_Node *root);
    // Calls recalculateParmDefiner on all VOP_ParmGenerator nodes under root.
    static void          recalculateAllParmDefiners(OP_Node *root);

    /// Returns true if the input will be auto-converetd, false otherwise.
    virtual bool         willAutoconvertInputType(int input_idx);

    /// Returns the type to which the input will be auto-convert. This is necessary
    /// because some inputs can take in a range of various types, and we need to know
    /// which one will be converting to. This function assumes that autoconversion is
    /// necessary. If it is not possible, or not needed, it returns VOP_TYPE_UNDEF.
    VOP_Type             getAutoConvertTargetType(int input_idx);

    /// Similar to the getAutoConvertTargetType(), but takes in an input type instead
    /// of trying to read it from the connected node. This is useful when one needs to 
    /// know what the incoming type will be converted to before it is actually connected.
    VOP_Type             getAutoConvertTypeFromType(int input_idx, VOP_Type source_type);

    /// Do not call this method directly.
    void                 addAutoConvertNodePointer(VOP_AutoConvert* ac_node, int input_index);
    void                 clearAutoConvertInfos(void);
    VOP_AutoConvert*     getAutoConvertNode(int input_idx);
    int                  getNumAutoConvertNodes(void);

    /// We should not reserve the name of the parameter in 
    /// PI_EditScriptedParms::initializeReserveNames()if it 
    /// is one of our inputs. This function implements this 
    /// behaviour.
    virtual bool         allowReservingParm(PRM_Parm* parm);     
    
    void                 getSubOutputAndSubInputs(OP_Node *&outputnode,
                                      OP_NodeList &inputnodes) const;

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

    virtual void         getNodeSpecificInfoText(OP_Context &context,
                                                 int verbose,
                                                 UT_WorkBuffer &text);

    virtual void         deleteCookedData();
    virtual int          saveCookedData(ostream &, OP_Context &,
                                        int binary = 0);
    virtual int          saveCookedData(const char *, OP_Context &);
    virtual const char  *getFileExtension(int) const;

    virtual OP_ERROR     cookMe(OP_Context &);
    virtual OP_ERROR     bypassMe(OP_Context &, int &);

    virtual void         preOpChanged(OP_EventType, void *)
                         { }
    virtual void         postOpChanged(OP_EventType, void *)
                         { }

    // Functions to get information about our operator outputs.
    // These functions are used for variable name replacement and for
    // creating output labels on the op tiles.
    virtual void         getOutputNameSubclass(UT_String &out, int idx) const;
    virtual VOP_Type     getOutputTypeSubclass(int idx);

    // Returns the variable name associated with a given input number.
    // Implementers of this function should also implement the reverse
    // function.
    virtual void         getInputNameSubclass(UT_String &in, int idx) const;
    virtual int          getInputFromNameSubclass(const UT_String &in) const;
    virtual VOP_Type     getInputTypeSubclass(int idx);
    virtual void         getAllowedInputTypesSubclass(unsigned idx,
                                              VOP_VopTypeArray &voptypes);

    void                 addError(VOP_ErrorCodes code, const char *msg=0)
                         { UTaddError("VOP", code, msg); }
    void                 addMessage(VOP_ErrorCodes code, const char *msg=0)
                         { UTaddMessage("VOP", code, msg); }
    void                 addWarning(VOP_ErrorCodes code, const char *msg=0)
                         { UTaddWarning("VOP", code, msg); }
    void                 addFatal(VOP_ErrorCodes code, const char *msg=0)
                         { UTaddFatal("VOP", code, msg); }

    // This function is used to rewire nodes when we do a moveInput.
    static void          rewireInputs(OP_Network *parent, OP_NodeList &inputs,
                                      int srcidx, int dstidx);

    const VOP_Language  *myLanguage;

    virtual void        getAdditionalUndoNodes(const OP_NodeList& orig_list, OP_NodeList& nodes_for_input_undo);

private:
    // Returns true if this node can access illuminance global variables.
    bool                 getIncludeIllumVars() const;

    const UT_SymbolTable*myGlobalVariables;
    UT_SymbolTable      *myLocalVariables;
    UT_SymbolTable      *myLocalChannels;
    long                 myLatestOpChangedId;
    bool                 myMakingInputList;
    mutable UT_BitArray  myGettingInputName;
    mutable UT_BitArray  myGettingInputType;
    mutable UT_BitArray  myGettingAllowedInputTypes;
    mutable UT_BitArray  myGettingOutputName;
    mutable UT_BitArray  myGettingOutputType;
    mutable int          myOutputNodeId;

    static VOP_Node     *theOriginalOpChanged;
    static long          theLatestOpChangedId;

    TAutoConvertInfos   myAutoConvertInfos;
};

#endif

---