PRM/PRM_ParmOwner.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 Tucker
 *      Side Effects Software Inc.
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        PRM_ParmOwner.h (Parameter Library)
 *
 * COMMENTS:
 *              This class is the base class of OP_Parameters. It provides
 *              a method for a PRM_Instance to communicate with its owner
 *              OP_Node through virtual functions.
 */

#ifndef __PRM_ParmOwner__
#define __PRM_ParmOwner__

#include "PRM_API.h"
#include <UT/UT_String.h>
#include <UT/UT_PtrArray.h>
#include <PY/PY_Result.h>
#include <CH/CH_ExprLanguage.h>

class UT_StringArray;
class PY_CompiledCode;
class PRM_Instance;
class PRM_ParmList;
class PRM_Parm;
class PRM_ParmNameMap;

class PRM_API PRM_ParmOwner
{
public:
    virtual void                 getFullPath(UT_String &str) const = 0;
    virtual PRM_ParmList        *getParmList() = 0;
    virtual const PRM_ParmList  *getParmList() const = 0;

    virtual bool                 createSpareParametersForLoad(
                                            UT_StringArray &,
                                            PRM_ParmNameMap &,
                                            UT_String &);

    virtual PRM_ParmList        *createObsoleteParmList() = 0;
    virtual void                 resolveAndDeleteObsoleteParmList(
                                            PRM_ParmList *&obsolete_parms) = 0;

    // Runs a command using the OPgetDirector()->getCommandManager()
    // at the OP level. The cwd is set to the current node before
    // executing the command.
    virtual void                 executeCommand(const char *command,
                                                ostream *out,
                                                ostream *err) const = 0;

    // Run some Python code, but set the cwd before running it and restore it
    // after running it.
    virtual void         pushAsPwdAndRunPython(
                            PY_CompiledCode &compiled_code,
                            PY_Result::Type desired_result_type,
                            PY_Result &result) const = 0;

    // Pending overrides are strings giving a list of op nodes which
    // will be overridden.  These are used higher up at the OP_Node level.
    bool                 isPendingOverride() const
                         {
                            return myOverridePending.isstring();
                         }
    // This returns true if the given parm is listed as overridden.
    // vecidx of -1 signifies it will be true if any of the parms vectors
    // is overridden.
    bool                 isPendingOverride(const char *parmname,
                                           int vecidx) const;
    const char          *getPendingOverrideString() const
                         {
                            return (const char *) myOverridePending;
                         }
    void                 setPendingOverrideString(const char *s);
    virtual int          prmCookOverrides(float /* t */) { return 0; }

    // Activates the parm for the take if it should be automatically
    // activated based on its current state and the current take state.
    virtual void         takeAutoActivateParm(PRM_Parm *) = 0;

    // Rebuild the node dependency information for a particular parm on
    // a node. This allows the PRM library to force nodes to update their
    // dependency information.
    virtual void         rebuildParmDependency(int parmidx) = 0;

    // Clear all parm dependency information
    virtual void         clearParmDependency(int parmidx) = 0;

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

    // This function is called when a spare parameter is being removed
    // from our parm list. This is called from PRM_ParmList::updateSpareParms,
    // and provides a way for the OP library to respond to individual parm
    // removals without understanding the internals of the whole operation.
    virtual void         spareParmRemoved(const char *parmname) = 0;

    // This function is caled when any multiparm has a new instance added.
    // It gives the parm owner a chance to initialize the multiparm values.
    virtual void         initMultiparmInstance(UT_PtrArray<PRM_Parm *> &p) = 0;

    // This function is called when a multiparm instance is added or removed.
    virtual void         addOrRemoveMultiparmInstance() = 0;

    virtual bool         savePresetContents(ostream &os) = 0;
    virtual bool         loadPresetContents(const char *token,
                                            UT_IStream &is) = 0;

    virtual CH_ExprLanguage      getExprLanguage() const = 0;

protected:
                 PRM_ParmOwner()
                 { }
    virtual     ~PRM_ParmOwner()
                 { }

    UT_String            myOverridePending;
};

#endif

---