HDK: OP/OP_Parameters.h Source File

00001 /*
00002  * PROPRIETARY INFORMATION.  This software is proprietary to
00003  * Side Effects Software Inc., and is not to be reproduced,
00004  * transmitted, or disclosed in any way without written permission.
00005  *
00006  * Produced by:
00007  *      Paul Breslin
00008  *      Side Effects Software Inc.
00009  *      20 Maud St.
00010  *      Toronto, Ontario,  M5V 2M5
00011  *      Canada
00012  *      416-366-4607
00013  *
00014  * NAME:        OP Library (C++)
00015  *
00016  * COMMENTS:    OP_Parameters encapsulates the parameter lists used
00017  *              by the OP library.
00018  *
00019  */
00020 
00021 #ifndef __OP_Parameters_h__
00022 #define __OP_Parameters_h__
00023 
00024 #include "OP_API.h"
00025 #include <iostream.h>
00026 #include <SYS/SYS_Types.h>
00027 #include <UT/UT_Assert.h>
00028 #include <UT/UT_Defines.h>
00029 #include <UT/UT_Lock.h>
00030 #include <UT/UT_LockedRawPtr.h>
00031 #include <UT/UT_String.h>
00032 #include <UT/UT_Thread.h>
00033 #include <EXPR/EX_Error.h>
00034 #include <CH/CH_ExprLanguage.h>
00035 #include <PRM/PRM_ChanState.h>
00036 #include <PRM/PRM_ParmList.h>
00037 #include <PRM/PRM_ParmOwner.h>
00038 #include "OP_Value.h"
00039 #include "OP_Error.h"
00040 #include "OP_Stat.h"
00041 
00042 class UT_BitArray;
00043 class UT_Ramp;
00044 class PRM_Parm;
00045 class PRM_ParmList;
00046 class PRM_ScriptPage;
00047 class PRM_ScriptImports;
00048 class PRM_BatchList;
00049 class CH_LocalVariable;
00050 class CMD_Args;
00051 class OP_Channels;
00052 class OP_Context;
00053 class OP_Operator;
00054 class OP_ParmCache;
00055 class OP_PostIt;
00056 class OP_MultiparmInfo;
00057 class OP_PropertyLookupList;
00058 class OP_SpareParms;
00059 
00060 enum OP_ScopeOp {
00061     OP_SCOPE_SET,
00062     OP_SCOPE_ADD,
00063     OP_SCOPE_REMOVE,
00064     OP_SCOPE_NUM_OPS        // sentinel
00065 };
00066 
00067 class OP_API OP_ScopeOptions
00068 {
00069 public:
00070     // allow_nonchannels - determines whether or not we should scope parameters
00071     //                     that don't have CH_Channel pointers associated with
00072     //                     them.
00073     //
00074     // exclude_animated  - determines whether or not to exclude channels that 
00075     //                     are time dependent.
00076     //
00077     // exclude_constant  - determines whether or not to exclude channels that
00078     //                     are not time dependent.
00079     //
00080     // include_only_nonint_keys - deteremines whether or not to include only
00081     //                            those channels that have non integer 
00082     //                            keyframes.
00083     OP_ScopeOptions(bool allow_nonchannels, bool exclude_animated,
00084                     bool exclude_constant,  bool include_only_nonint_keys) :
00085         myAllowNonChannels(allow_nonchannels),
00086         myExcludeAnimated(exclude_animated),
00087         myExcludeConstant(exclude_constant),
00088         myIncludeOnlyNonIntKeys(include_only_nonint_keys) { }
00089 
00090     bool myAllowNonChannels;
00091     bool myExcludeAnimated;
00092     bool myExcludeConstant;
00093     bool myIncludeOnlyNonIntKeys;
00094 };
00095 
00096 class OP_API OP_Parameters : public PRM_ParmOwner
00097 {
00098 public:
00099     const UT_String     &getName()     const { return myName; }
00100     OP_Operator         *getOperator() const { return myTableEntry; }
00101 
00102     virtual void         getFullPath(UT_String &str) const;
00103 
00104     //  Returns zero if no change was made. This function calls the virtual
00105     //  disableParms, as well as going through to disable all spare
00106     //  parameters on this node. This is the function that should be
00107     //  called when trying to update the parms of a node.
00108     unsigned             disableParmsAndSpareParms();
00109     //  Uses the disable when string stored on the PRM_Template for the
00110     //  specified parameter to check whether the specified parm should
00111     //  be enabled. Returns zero if the parm state doesn't change.
00112     unsigned             checkDisableForParm(PRM_Parm &parm,
00113                                              const UT_StringArray *skipparms);
00114     //  Returns zero if no change was made. This function is overridden
00115     //  by subclasses to disable parms specific to those nodes.
00116     virtual unsigned     disableParms();
00117 
00118     //  Clone a parameter by referencing all the parameters of the "from"
00119     //  OP_Parameters.
00120     virtual unsigned    referenceAllParameters(OP_Parameters *from);
00121 
00122     //  Methods for dealing with channels & key frames
00123     void                   animate(unsigned idx);
00124     void                   animate(const char *name);
00125     void                 deAnimate(unsigned idx);
00126     void                 deAnimate(const char *name);
00127     CH_Channel          *addChannel(const char *name);
00128     CH_Channel          *getChannel(const char *name);
00129     const CH_Channel    *getChannel(const char *name) const;
00130     int                  destroyChannel(const char *name);
00131 
00132     bool                 isObsoleteChannel(const char *name) const;
00133 
00134     void                 takeActivateParm(uint idx, bool enable=true);
00135     void                 takeActivateParm(const char *name, bool enable=true);
00136     void                 takeActivateParm(PRM_Parm *parm, bool enable=true);
00137     void                 takeDeactivateParm(uint idx)
00138                              { takeActivateParm(idx, false); }
00139     void                 takeDeactivateParm(const char *name)
00140                              { takeActivateParm(name, false); }
00141     void                 takeDeactivateParm(PRM_Parm *parm)
00142                              { takeActivateParm(parm, false); }
00143 
00144     bool                 takeIsActiveParm(uint idx);
00145     bool                 takeIsActiveParm(const char *name);
00146     bool                 takeIsActiveParm(const PRM_Parm *parm);
00147 
00148     // Activates the parm for the take if it should be automatically
00149     // activated based on its current state and the current take state.
00150     virtual void         takeAutoActivateParm(PRM_Parm *);
00151 
00152     float                findKey(float t, int direction) const;
00153 
00154     PRM_ChanState        getChanState(float t, bool scoped_only) const;
00155     PRM_ChanState        isAtKey(float t) const
00156                          { return getChanState(t, false); }
00157     void                 updatePending(float t);
00158     bool                 isPending( float t );
00159 
00160     OP_Channels         *getChannels(void) const { return myChannels; }
00161 
00162     // This gets the variable value AS as string.  Not the string corresponding
00163     // to the specified index!
00164     virtual void         getVariableString(int index, UT_String &value,
00165                                            int thread);
00166     virtual float        getVariableValue(int index, int thread);
00167 
00168     PRM_Parm            &getParm(int i)
00169                          { return *myParmList->getParmPtr(i); }
00170     const PRM_Parm      &getParm(int i) const
00171                          { return *myParmList->getParmPtr(i); }
00172     PRM_Parm            &getParm(const char *name)     
00173                          { return *myParmList->getParmPtr(name); }
00174     const PRM_Parm      &getParm(const char *name) const 
00175                          { return *myParmList->getParmPtr(name); }
00176     PRM_Parm            *getParmPtrInst(const char *name, const int *inst,
00177                                         int nestlevel = 1);
00178     const PRM_Parm      *getParmPtrInst(const char *name, const int *inst,
00179                                         int nestlevel = 1) const;
00180 
00181     virtual PRM_ParmList        *getParmList()
00182                                  { return myParmList; }
00183     virtual const PRM_ParmList  *getParmList() const
00184                                  { return myParmList; }
00185 
00186     // This function is called when our spare parm definition is changing.
00187     // Parses the supplied dialog script and uses it to update the spare
00188     // parms for this node.
00189     virtual bool         changeSpareParms(UT_IStream &ds, UT_String &errors);
00190     // Returns true if we are in the middle of chaning our spare parm
00191     // definition. Lets us avoid handling certain events (such as multiparm
00192     // change handling in OPUI_Dialog).
00193     bool                 getIsChangingSpareParms() const
00194                          { return myChangingSpareParms; }
00195 
00196     // This is a secondary parm list where all obsolete parameters are
00197     // placed (if any)
00198     virtual PRM_ParmList    *createObsoleteParmList();
00199     virtual void             resolveAndDeleteObsoleteParmList(
00200                                                 PRM_ParmList *&obsolete_parms);
00201     
00202     // After any call which might have loaded something into the ObsoleteList,
00203     // we should call this to resolve those parameters:
00204     virtual void         resolveObsoleteParms(PRM_ParmList * /*obsolete_parms*/)                         { /*nothing at this level*/ }
00205 
00206     // Track down the parameter associated with a given property
00207     virtual bool         getParameterOrProperty(const char *name, fpreal now,
00208                                       OP_Node *&op,
00209                                       PRM_Parm *&parm,
00210                                       PRM_ParmList *obsolete = 0,
00211                                       bool create_missing_multiparms = true);
00212     virtual bool         getParameterOrPropertyByChannel(const char *chname,
00213                                       fpreal now,
00214                                       OP_Node *&op,
00215                                       PRM_Parm *&parm,
00216                                       int &vector_index,
00217                                       PRM_ParmList *obsolete = 0);
00218 
00219     virtual int         findParametersOrProperties(fpreal now,
00220                                         OP_PropertyLookupList &list);
00221 
00222     // Take a PRM_Parm pointer, and look at its value. If it is a simple
00223     // channel reference, return the referenced node, parm, and vecidx.
00224     static bool          followChannelReferencesOneStep(float t,
00225                                                         OP_Node *&newop,
00226                                                         PRM_Parm *&newparm,
00227                                                         int &newvecidx)
00228                             {
00229                                 return followChannelReferencesOneStepT(
00230                                         t, newop, newparm, newvecidx,
00231                                         UTgetSTID());
00232                             }
00233     static bool          followChannelReferencesOneStepT(float t,
00234                                                          OP_Node *&newop,
00235                                                          PRM_Parm *&newparm,
00236                                                          int &newvecidx,
00237                                                          int thread);
00238     static void          followChannelReferences(float t, OP_Node *&newop,
00239                                                  PRM_Parm *&newparm,
00240                                                  int &newvecidx)
00241                             {
00242                                 followChannelReferencesT(
00243                                         t, newop, newparm, newvecidx,
00244                                         UTgetSTID());
00245                             }
00246     static void          followChannelReferencesT(float t, OP_Node *&newop,
00247                                                   PRM_Parm *&newparm,
00248                                                   int &newvecidx,
00249                                                   int thread);
00250     static void          followChannelReferences(float t, CH_ChannelRef &ref)
00251                             {
00252                                 followChannelReferencesT(t, ref, UTgetSTID());
00253                             }
00254     static void          followChannelReferencesT(float t, CH_ChannelRef &ref,
00255                                                   int thread);
00256     
00257     static void          getValueAsProcessedNodePaths(float t, 
00258                                        UT_WorkBuffer &resultbuf, 
00259                                        PRM_Parm *parm, int index,
00260                                        OP_Node *srcnode);
00261     
00262     const OP_Stat       &getStat() const        { return myStats; }
00263     OP_Stat             &getStat()              { return myStats; }
00264 
00265     //  "vi" refers to the vector index. "pi" is the parameter index.
00266     //  "pn" refers to the parmeter name. "v" refers to the vector component.
00267     //  if v == -1, all components are affected.
00268     int                  enableParm(int   pi, int state, int v = -1);
00269     int                  enableParm(const char *pn, int state, int v = -1);
00270     int                  enableParmInst(const char *name, const int *inst,
00271                                         int state, int nestlevel = 1,
00272                                         int v = -1);
00273     unsigned             getEnableState(int pi, int v = -1);
00274     unsigned             getEnableState(const char *pn, int v = -1);
00275     unsigned             getEnableStateInst(const char *name, const int *inst,
00276                                             int nestlevel = 1, int v = -1);
00277 
00278     /// @anchor OP_Node_EvalParameters
00279 
00280     /// @name Parameter evaluation
00281     ///
00282     /// - int pi            @n Parameter index
00283     /// - const char *pn    @n Parameter name token
00284     /// - int *pi           @n Parameter index passed by reference, looked up
00285     ///                        using 'pn'
00286     /// - PRM_Parm *parm    @n Parameter by reference
00287     /// - int vi            @n Component index of a parameter
00288     /// - float t           @n Evaluation time
00289     /// - int thread        @n Thread id (ie. return value from UTgetSTID())
00290     // @{
00291     int                  evalInt(int pi, int vi, float t) const
00292                             { return evalIntT(pi, vi, t, UTgetSTID()); }
00293     int                  evalIntT(int pi, int vi, float t, int thread) const;
00294     int                  evalInt(const char *pn, int vi, float t) const
00295                             { return evalIntT(pn, vi, t, UTgetSTID()); }
00296     int                  evalIntT(const char *pn, int vi, float t,
00297                                   int thread) const;
00298     int                  evalInt(const char *pn, int *pi, int vi, float t) const
00299                             { return evalIntT(pn, pi, vi, t, UTgetSTID()); }
00300     int                  evalIntT(const char *pn, int *pi, int vi, float t,
00301                                   int thread) const;
00302     int                  evalInt(PRM_Parm *parm, int vi, fpreal t) const
00303                             { return evalIntT(parm, vi, t, UTgetSTID()); }
00304     int                  evalIntT(PRM_Parm *parm, int vi, fpreal t,
00305                                   int thread) const;
00306 
00307     float                evalFloat(int pi, int vi, float t) const
00308                             { return evalFloatT(pi, vi, t, UTgetSTID()); }
00309     float                evalFloatT(int pi, int vi, float t, int thread) const;
00310     float                evalFloat(const char *pn, int vi, float t) const
00311                             { return evalFloatT(pn, vi, t, UTgetSTID()); }
00312     float                evalFloatT(const char *pn, int vi, float t,
00313                                     int thread) const;
00314     float                evalFloat(const char *pn, int *pi, int vi,
00315                                    float t) const
00316                             { return evalFloatT(pn, pi, vi, t, UTgetSTID()); }
00317     float                evalFloatT(const char *pn, int *pi, int vi, float t,
00318                                     int thread) const;
00319     float                evalFloat(PRM_Parm *parm, int vi, fpreal t) const
00320                             { return evalFloatT(parm, vi, t, UTgetSTID()); }
00321     float                evalFloatT(PRM_Parm *parm, int vi, fpreal t,
00322                                     int thread) const;
00323 
00324     // Evaluate an array of floats
00325     void                 evalFloats(int pi, float *v, float t) const
00326                             { return evalFloatsT(pi, v, t, UTgetSTID()); }
00327     void                 evalFloatsT(int pi, float *v, float t,
00328                                      int thread) const;
00329     void                 evalFloats(const char *pn, float *v, float t) const
00330                             { return evalFloatsT(pn, v, t, UTgetSTID()); }
00331     void                 evalFloatsT(const char *pn, float *v, float t,
00332                                      int thread) const;
00333     void                 evalFloats(const char *pn, int *pi,float *v,
00334                                     float t) const
00335                             { return evalFloatsT(pn, pi, v, t, UTgetSTID()); }
00336     void                 evalFloatsT(const char *pn, int *pi,float *v, float t,
00337                                      int thread) const;
00338     void                 evalFloats(PRM_Parm *parm, float *v, fpreal t) const
00339                             { return evalFloatsT(parm, v, t, UTgetSTID()); }
00340     void                 evalFloatsT(PRM_Parm *parm, float *v, fpreal t,
00341                                      int thread) const;
00342 
00343     // String evaluation, expanding any inline expressions (backticks) and
00344     // variables
00345     void                 evalString(UT_String &val, int   pi, int vi,
00346                                     float t) const
00347                             { return evalStringT(val, pi, vi, t, UTgetSTID()); }
00348     void                 evalStringT(UT_String &val, int   pi, int vi, float t,
00349                                      int thread) const;
00350     void                 evalString(UT_String &val, const char *pn, int vi,
00351                                     float t) const
00352                             { return evalStringT(val, pn, vi, t, UTgetSTID()); }
00353     void                 evalStringT(UT_String &val, const char *pn, int vi,
00354                                      float t, int thread) const;
00355     void                 evalString(UT_String &val, const char *pn, int *pi,
00356                                     int vi, float t) const
00357                             {
00358                                 return evalStringT(val, pn, pi, vi, t,
00359                                                    UTgetSTID());
00360                             }
00361     void                 evalStringT(UT_String &val, const char *pn, int *pi,
00362                                      int vi, float t, int thread) const;
00363     void                 evalString(UT_String  &val, PRM_Parm *parm, int vi,
00364                                     float t) const
00365                             {
00366                                 return evalStringT(val, parm, vi, t,
00367                                                    UTgetSTID());
00368                             }
00369     void                 evalStringT(UT_String  &val, PRM_Parm *parm, int vi,
00370                                      float t, int thread) const;
00371     
00372     // String evaluation, with no expression or variable expansion
00373     void                 evalStringRaw(UT_String &val, int pi, int vi,
00374                                        float t) const
00375                             {
00376                                 return evalStringRawT(val, pi, vi, t,
00377                                                       UTgetSTID());
00378                             }
00379     void                 evalStringRawT(UT_String &val, int pi, int vi, float t,
00380                                         int thread) const;
00381     void                 evalStringRaw(UT_String &val, const char *pn, int vi,
00382                                        float t) const
00383                             {
00384                                 return evalStringRawT(val, pn, vi, t,
00385                                                       UTgetSTID());
00386                             }
00387     void                 evalStringRawT(UT_String &val, const char *pn, int vi,
00388                                         float t, int thread) const;
00389     void                 evalStringRaw(UT_String &val, const char *pn, int *pi,
00390                                        int vi, float t) const
00391                             {
00392                                 return evalStringRawT(val, pn, pi, vi, t,
00393                                                       UTgetSTID());
00394                             }
00395     void                 evalStringRawT(UT_String &val, const char *pn, int *pi,
00396                                         int vi, float t, int thread) const;
00397     void                 evalStringRaw(UT_String &val, PRM_Parm *parm, int vi,
00398                                        float t) const
00399                             {
00400                                 return evalStringRawT(val, parm, vi, t,
00401                                                       UTgetSTID());
00402                             }
00403     void                 evalStringRawT(UT_String &val, PRM_Parm *parm, int vi,
00404                                         float t, int thread) const;
00405     // @}
00406 
00407     /// @name Multi-Parameter evaluation
00408     ///
00409     /// - name      @n Parameter name token
00410     /// - inst      @n Array of instance indices to evaluate at
00411     /// - vi        @n Component index of a parameter
00412     /// - t         @n Evaluation time
00413     /// - nestlevel @n Number of entries in 'inst'
00414     /// - thread    @n Thread id (ie. return value from UTgetSTID())
00415     // @{
00416     int                  evalIntInst(const char *name, const int *inst, int vi,
00417                                      float t, int nestlevel = 1) const
00418                             {
00419                                 return evalIntInstT(name, inst, vi, t,
00420                                                     UTgetSTID(), nestlevel);
00421                             }
00422     int                  evalIntInstT(const char *name, const int *inst, int vi,
00423                                       float t, int thread,
00424                                       int nestlevel = 1) const;
00425     float                evalFloatInst(const char *name, const int *inst,
00426                                        int vi, float t, int nestlevel = 1) const
00427                             {
00428                                 return evalFloatInstT(name, inst, vi, t,
00429                                         UTgetSTID(), nestlevel);
00430                             }
00431     float                evalFloatInstT(const char *name, const int *inst,
00432                                         int vi, float t, int thread,
00433                                         int nestlevel = 1) const;
00434     void                 evalFloatsInst(const char *name, const int *inst,
00435                                         float *v, float t,
00436                                         int nestlevel = 1) const
00437                             {
00438                                 return evalFloatsInstT(name, inst, v, t,
00439                                         UTgetSTID(), nestlevel);
00440                             }
00441     void                 evalFloatsInstT(const char *name, const int *inst,
00442                                          float *v, float t, int thread,
00443                                          int nestlevel = 1) const;
00444     void                 evalStringInst(const char *name, const int *inst,
00445                                         UT_String &val, int vi, float t,
00446                                         int nestlevel = 1) const
00447                             {
00448                                 return evalStringInstT(name, inst, val, vi,
00449                                         t, UTgetSTID(), nestlevel);
00450                             }
00451     void                 evalStringInstT(const char *name, const int *inst,
00452                                          UT_String &val, int vi, float t,
00453                                          int thread, int nestlevel = 1) const;
00454     void                 evalStringInstRaw(const char *name, const int *inst,
00455                                            UT_String &val, int vi, float t,
00456                                            int nestlevel = 1) const
00457                             {
00458                                 return evalStringInstRawT(name, inst, val, vi,
00459                                         t, UTgetSTID(), nestlevel);
00460                             }
00461     void                 evalStringInstRawT(const char *name, const int *inst,
00462                                             UT_String &val, int vi, float t,
00463                                             int thread,
00464                                             int nestlevel = 1) const;
00465     // @}
00466 
00467     /// @name Property evaluation
00468     /// 
00469     /// Properties will be evaluated if the parameter is not found.
00470     ///
00471     /// - parm_name     @n Parameter name token
00472     /// - vec_index     @n Component index of a parameter
00473     /// - now           @n Evaluation time
00474     /// - thread        @n Thread id (ie. return value from UTgetSTID())
00475     // @{
00476     bool                evalParameterOrProperty(const char *parm_name,
00477                                                 int vec_index,
00478                                                 fpreal now,
00479                                                 int &value)
00480                             {
00481                                 return evalParameterOrPropertyT(parm_name,
00482                                         vec_index, now, value, UTgetSTID());
00483                             }
00484     bool                evalParameterOrPropertyT(const char *parm_name,
00485                                                  int vec_index,
00486                                                  fpreal now,
00487                                                  int &value,
00488                                                  int thread);
00489     bool                evalParameterOrProperty(const char *parm_name,
00490                                                 int vec_index,
00491                                                 fpreal now,
00492                                                 fpreal &values)
00493                             {
00494                                 return evalParameterOrPropertyT(parm_name,
00495                                         vec_index, now, values, UTgetSTID());
00496                             }
00497     bool                evalParameterOrPropertyT(const char *parm_name,
00498                                                 int vec_index,
00499                                                 fpreal now,
00500                                                 fpreal &values, int thread);
00501     bool                evalParameterOrProperty(const char *parm_name,
00502                                                 int vec_index,
00503                                                 fpreal now,
00504                                                 UT_String &value)
00505                             {
00506                                 return evalParameterOrPropertyT(parm_name,
00507                                         vec_index, now, value, UTgetSTID());
00508                             }
00509     bool                evalParameterOrPropertyT(const char *parm_name,
00510                                                  int vec_index,
00511                                                  fpreal now,
00512                                                  UT_String &value,
00513                                                  int thread);
00514     bool                evalParameterOrPropertyRaw(const char *parm_name,
00515                                                    int vec_index,
00516                                                    fpreal now,
00517                                                    UT_String &value)
00518                             {
00519                                 return evalParameterOrPropertyRawT(parm_name,
00520                                         vec_index, now, value, UTgetSTID());
00521                             }
00522     bool                evalParameterOrPropertyRawT(const char *parm_name,
00523                                                     int vec_index,
00524                                                     fpreal now,
00525                                                     UT_String &value,
00526                                                     int thread);
00527     bool                evalParameterOrPropertyExpr(const char *parm_name,
00528                                                     int vec_index,
00529                                                     fpreal now,
00530                                                     UT_String &value)
00531                             {
00532                                 return evalParameterOrPropertyExprT(parm_name,
00533                                         vec_index, now, value, UTgetSTID());
00534                             }
00535     bool                evalParameterOrPropertyExprT(const char *parm_name,
00536                                                      int vec_index,
00537                                                      fpreal now,
00538                                                      UT_String &value,
00539                                                      int thread);
00540 
00541     bool                evalVectorProperty(const char *parm_name,
00542                                            fpreal now,
00543                                            int *values,
00544                                            int vec_size)
00545                             {
00546                                 return evalVectorPropertyT(parm_name,
00547                                         now, values, vec_size, UTgetSTID());
00548                             }
00549     bool                evalVectorPropertyT(const char *parm_name,
00550                                             fpreal now,
00551                                             int *values,
00552                                             int vec_size,
00553                                             int thread);
00554     bool                evalVectorProperty(const char *parm_name,
00555                                            fpreal now,
00556                                            fpreal *values,
00557                                            int vec_size)
00558                             {
00559                                 return evalVectorPropertyT(parm_name,
00560                                         now, values, vec_size, UTgetSTID());
00561                             }
00562     bool                evalVectorPropertyT(const char *parm_name,
00563                                             fpreal now,
00564                                             fpreal *values,
00565                                             int vec_size,
00566                                             int thread);
00567     // @}
00568 
00569     /// @anchor OP_Node_SetParameters
00570 
00571     /// @name Setting parameter values
00572     ///
00573     /// - pi        @n Parameter index
00574     /// - pn        @n Parameter name string
00575     /// - vi        @n Component index of a parameter
00576     /// - t         @n Evaluation time
00577     /// - val       @n Value to set
00578     /// - h         @n If true, it will set a keyframe if the parameter
00579     ///                has a channel. If false, then the value will
00580     ///                need to committed first.
00581     // @{
00582     void                 setInt(int   pi, int vi, float t, int val);
00583     void                 setInt(const char *pn, int vi, float t, int val);
00584     void                 setInt(const char *pn, int &pi, int vi, float t,
00585                                 int val);
00586     void                 setFloat(int pi, int vi, float t, float val, int h=0);
00587     void                 setFloat(const char *pn, int vi,  float t, float val,
00588                                   int h=0);
00589     void                 setFloat(const char *pn, int &pi, int vi,
00590                                   float t, float val, int h=0);
00591     void                 setString(const UT_String &val,
00592                                    CH_StringMeaning meaning,
00593                                    int  pi, int vi,
00594                                    float t);
00595     void                 setString(const UT_String &val,
00596                                    CH_StringMeaning meaning,
00597                                    const char *pn, int vi, float t);
00598     void                 setString(const UT_String &val,
00599                                    CH_StringMeaning meaning,
00600                                    const char *pn,
00601                                    int &pi, int vi, float t);
00602     // @}
00603 
00604     /// @name Setting parameter values, following channel references
00605     ///
00606     /// These functions will follow simple channel references first, and then 
00607     /// set the value on the destination parameter.
00608     ///
00609     /// - pi        @n Parameter index
00610     /// - pn        @n Parameter name string
00611     /// - vi        @n Component index of a parameter
00612     /// - t         @n Time at which to set the value
00613     /// - val       @n Value to set
00614     /// - harden    @n If true, it will set a keyframe if the parameter
00615     ///                has a channel. If false, then the value will
00616     ///                need to committed first.
00617     /// - propagate @n If true, it notify observers
00618     /// - thread    @n Thread id (ie. return value from UTgetSTID())
00619     // @{
00620     void                 setChRefInt(int pi, int vi, float t, int val, 
00621                                          int harden=0, int propagate=1);
00622     void                 setChRefInt(const char *pn, int vi, float t, int val, 
00623                                      int harden=0, int propagate=1);
00624     void                 setChRefFloat(int pi, int vi, float t, float val, 
00625                                          int harden=0, int propagate=1);
00626     void                 setChRefFloat(const char *pn, int vi, float t,
00627                                        float val, int harden=0,
00628                                        int propagate=1);
00629     void                 setChRefString(const UT_String &val,
00630                                         CH_StringMeaning meaning,
00631                                         int pi, int vi, 
00632                                         float t, int harden=0, int propagate=1);
00633     void                 setChRefString(int pi, int vi, 
00634                                         float t,
00635                                         const UT_String &val,
00636                                         CH_StringMeaning meaning,
00637                                         int harden=0, int propagate=1)
00638                             {
00639                                 setChRefString(val, meaning, pi, vi, t,
00640                                                harden, propagate);
00641                             }
00642     void                 setChRefString(const UT_String &val,
00643                                         CH_StringMeaning meaning,
00644                                         const char *pn,
00645                                         int vi, float t,
00646                                         int harden=0, int propagate=1);
00647     void                 setChRefString(const char *pn,
00648                                         int vi, float t,
00649                                         const UT_String &val,
00650                                         CH_StringMeaning meaning,
00651                                         int harden=0, int propagate=1)
00652                             {
00653                                 setChRefString(val, meaning, pn, vi, t,
00654                                                harden, propagate);
00655                             }
00656     // @}
00657 
00658     /// @name Setting property values
00659     ///
00660     /// The setParameterOrProperty methods will track down, not only channel
00661     /// references, but also property parameter references.
00662     /// The bool result indicates whether the parameter was actually set.
00663     /// Some possible causes of failure are:
00664     /// - Parameter or property not found
00665     /// - Permissions error
00666     /// - Locked parameter
00667     /// - Out of bounds vector index
00668     ///
00669     /// Parameters:
00670     /// - parm_name @n Parameter name string
00671     /// - vec_index @n Component index of a parameter
00672     /// - now       @n Time at which to set the value
00673     /// - val       @n Value to set
00674     /// - harden    @n If true, it will set a keyframe if the parameter
00675     ///             has a channel. If false, then the value will
00676     ///             need to committed first.
00677     /// - propagate @n If true, it notify observers
00678     // @{
00679     bool                 setParameterOrProperty(const char *parm_name,
00680                                                 int vec_index,
00681                                                 fpreal now,
00682                                                 int value,
00683                                                 bool harden=false,
00684                                                 bool propagate=true);
00685     bool                 setParameterOrProperty(const char *parm_name,
00686                                                 int vec_index,
00687                                                 fpreal now,
00688                                                 fpreal value,
00689                                                 bool harden=false,
00690                                                 bool propagate=true);
00691     bool                 setParameterOrProperty(const char *parm_name,
00692                                                 int vec_index,
00693                                                 fpreal now,
00694                                                 const char *value,
00695                                                 CH_StringMeaning meaning,
00696                                                 bool harden=false,
00697                                                 bool propagate=true);
00698     // @}
00699 
00700     /// @name Multi-Parameter evaluation
00701     ///
00702     /// - name      @n Parameter name token
00703     /// - inst      @n Array of instance indices to evaluate at
00704     /// - vi        @n Component index of a parameter
00705     /// - t         @n Evaluation time
00706     /// - nestlevel @n Number of entries in 'inst'
00707     /// - val       @n Value to set
00708     // @{
00709     void                 setIntInst(int val, const char *name,
00710                                     const int *inst, int vi, float t,
00711                                     int nestlevel = 1);
00712     void                 setFloatInst(float val, const char *name,
00713                                       const int *inst, int vi, float t,
00714                                       int nestlevel = 1);
00715     void                 setStringInst(const UT_String &val,
00716                                        CH_StringMeaning meaning,
00717                                        const char *name,
00718                                        const int *inst, int vi, float t,
00719                                        int nestlevel = 1);
00720     // @}
00721 
00722     /// @name Setting parameter values silently
00723     ///
00724     /// These methods do not trigger additional events to notify observers
00725     ///
00726     /// - int pi            @n Parameter index
00727     /// - const char *pn    @n Parameter name string
00728     /// - int &pi           @n Parameter index, returned from 'pn' lookup
00729     /// - int vi            @n Component index of a parameter
00730     /// - float t           @n Time at which to set the value
00731     /// - val               @n Value to set
00732     // @{
00733     void                 setSilentInt(int   pi, int vi, float t, int val);
00734     void                 setSilentInt(const char *pn, int vi,
00735                                       float t, int val);
00736     void                 setSilentInt(const char *pn, int &pi,
00737                                       int vi, float t,int val);
00738 
00739     void                 setSilentFloat(int pi, int vi, float t,
00740                                         float val, int h=0);
00741     void                 setSilentFloat(const char *pn, int vi,
00742                                         float t, float val, int h=0);
00743     void                 setSilentFloat(const char *pn, int &pi, int vi,
00744                                         float t, float val, int h=0);
00745 
00746     void                 setSilentString(const UT_String &val,
00747                                          CH_StringMeaning meaning,
00748                                          int pi, int vi,
00749                                          float t);
00750     void                 setSilentString(const UT_String &val,
00751                                          CH_StringMeaning meaning,
00752                                          const char *pn,
00753                                          int vi, float t);
00754     void                 setSilentString(const UT_String &val,
00755                                          CH_StringMeaning meaning,
00756                                          const char *pn,
00757                                          int &pi, int vi, float t);
00758 
00759     void                 setSilentIntInst(int val, const char *name,
00760                                           const int *inst, int vi, float t,
00761                                           int nestlevel = 1);
00762     void                 setSilentFloatInst(float val, const char *name,
00763                                             const int *inst, int vi, float t,
00764                                             int nestlevel = 1);
00765     void                 setSilentStringInst(const UT_String &val,
00766                                              CH_StringMeaning meaning,
00767                                              const char *name,
00768                                              const int *inst, int vi, float t,
00769                                              int nestlevel = 1);
00770 
00771     // @}
00772 
00773 
00774     CH_StringMeaning     getStringMeaning(int pi, int vi, float t);
00775     CH_StringMeaning     getStringMeaning(const char *pn, int vi, float t);
00776     CH_StringMeaning     getStringMeaningInst(const char *name, const int *inst,
00777                                           int vi, float t, int nest_level = 1);
00778 
00779     // Batch setting of parameters.  The value stored in the batch list will be
00780     // assigned to the operator/parameter which the parameter was last
00781     // evaluated from.  This assumes that the parameter list has actually been
00782     // evaluated.  Modifications will be done in block mode.
00783     static void          setBatchParms(PRM_BatchList &list, fpreal now,
00784                                         bool create_key=false,
00785                                         bool create_channels=false);
00786     static bool          canSetBatchParms(PRM_BatchList &list, fpreal now);
00787 
00788     // When a new expression is created it will use the node's expression
00789     // language.
00790     CH_ExprLanguage      getExprLanguage() const;
00791     void                 setExprLanguage(CH_ExprLanguage language);
00792 
00793     // multiparm manipulation
00794     void                 insertMultiParmItem(const char *pn, int i);
00795     void                 removeMultiParmItem(const char *pn, int i);
00796 
00797     void                 updateMultiParmFromRamp(float t, const UT_Ramp &ramp,
00798                                                  PRM_Parm &m, bool add_wrap);
00799     void                 updateRampFromMultiParm(float t, const PRM_Parm &m,
00800                                                  UT_Ramp &ramp,
00801                                                  bool *time_dep = NULL);
00802 
00803     // This method converts an obsolete animated parm to a string parm.  It 
00804     // will create the necessary backticks for expressions.  It does not, 
00805     // however, support keyframed channel data or multiple-segment channels,
00806     // in which case the evaluated value at the given time is returned.
00807     // It also does not support CHOP overrides.
00808     // When reset_obs is true, the obsolete parameter is reset to factory
00809     // defaults after the expression has been extracted.
00810     // Returns true if successful, and false otherwise.  False is returned
00811     // if the obsolete is at the factory default.
00812     bool                 convertObsAnimatedToStringExpression(
00813                                 PRM_ParmList *obsolete_parms,
00814                                 const char *pn, int vi, float t,
00815                                 UT_String &result, bool reset_obs);
00816 
00817 
00818     void                 expandString(UT_String &val, float t);
00819 
00820     virtual int          findString(const char *str, bool fullword,
00821                                     bool usewildcards) const;
00822     virtual int          changeString(const char *from, const char *to,
00823                                       bool fullword);
00824 
00825     // These methods check to see if the current value differs from
00826     // the cached ones.  The time is the time to evaluate the parm at,
00827     // this does NOT support independent dirty flags for multiple times
00828     // (and likely you wouldn't want that anyways)
00829     // cacheParmValues ONLY saves those who had been tested for dirtiness
00830     bool                 isParmDirty(int idx, float t);
00831     bool                 isParmDirty(const char *n, float t);
00832     bool                 isParmDirtyInst(const char *name, const int *inst,
00833                                          float t, int nestlevel=1);
00834     void                 cacheParmValues(const OP_Context &context);
00835     void                 clearParmCache();
00836 
00837     // error stuff
00838     int                  getErrorMessages(UT_String &messages, 
00839                                           UT_ErrorSeverity severity
00840                                           = UT_ERROR_NONE)
00841                          {
00842                              UT_AutoLock lock(myErrorManagerLock);
00843                              stealGlobalErrors();
00844                              return myErrorManager.getErrorMessages(messages,
00845                                                                     severity);
00846                          }
00847 
00848     int                  findError(const char *type, int code) const
00849                          {
00850                              UT_AutoLock lock(myErrorManagerLock);
00851                              return myErrorManager.findError(type, code);
00852                          }
00853 
00854     int                  removeError(int idx)
00855                          {
00856                              UT_AutoLock lock(myErrorManagerLock);
00857                              return myErrorManager.removeError(idx);
00858                          }
00859 
00860     void                 clearDuplicateErrors()
00861                          {
00862                              UT_AutoLock lock(myErrorManagerLock);
00863                              myErrorManager.pruneDuplicates();
00864                          }
00865 
00866     void                 opMessage(int code, const char *m=0) const
00867                          { UTaddMessage("OP",code,m);}
00868     void                 opWarning(int code, const char *m=0) const
00869                          { UTaddWarning("OP",code,m);}
00870     void                 opError(int code, const char *m=0) const
00871                          { UTaddError("OP", code, m);}
00872     void                 opFatal(int code, const char *m=0) const
00873                          { UTaddFatal("OP", code, m);}
00874     void                 appendError(UT_Error *newerror)
00875                          {
00876                              UT_AutoLock lock(myErrorManagerLock);
00877                              myErrorManager.append(newerror);
00878                          }
00879 
00880     void                 clearErrors()
00881                          {
00882                              UT_AutoLock lock(myErrorManagerLock);
00883                              UTgetErrorManager()->clearAndDestroyErrors();
00884                              myErrorManager.clearAndDestroyErrors(); 
00885                          }
00886     virtual OP_ERROR     getErrorSeverity()
00887                          {
00888                              // We intentionally do NOT lock in this case
00889                              return myErrorManager.getSeverity();
00890                          }
00891                         
00892     virtual OP_ERROR     error()
00893                          {
00894                             if( UTgetErrorManager()->getNumErrors() > 0 )
00895                                 stealGlobalErrors();
00896                             return myErrorManager.getSeverity();
00897                          }
00898     void                 stealErrors(UT_ErrorManager &src,
00899                                      bool borrow_only = false);
00900 
00901     // This method should only be called from OP_Channels.
00902     void                 addChannelError(const char *type, int code,
00903                                          const char *msg = 0);
00904 
00905     void                 chChanged(CH_Channel *ch, CH_CHANGE_TYPE reason);
00906 
00907     virtual void         saveParmsForUndo(bool scopedOnly = false,
00908                                           CH_Collection *collection = NULL);
00909     void                 saveSingleParmForUndo(PRM_Parm *parm);
00910     void                 saveParmForUndo(PRM_Parm *);
00911     virtual void         saveKeyFrameForUndo(CH_Channel *chp, float gtime);
00912 
00913     // Clear any undo flags for the node in question
00914     virtual void         clearUndoFlags();
00915     virtual void         setAnyUndoFlag();
00916     int                  getAnyUndoPending() const { return myAnyUndoFlagSet; }
00917 
00918     int                  canAccess(unsigned mask) const;
00919     bool                 canAccess(unsigned mask, const PRM_Parm *parm) const;
00920     bool                 canAccessChannel(uint mask,
00921                                           const CH_Channel *chp) const;
00922     void                 updateUserMask();
00923 
00924     bool                 canModifyFromUI(const PRM_Parm *parm, int vi) const;
00925 
00926     // If an OP references external files, this method should be implemented to
00927     // reload new data which is out of date with the external file.  If data
00928     // was re-loaded, then the method should return 1 (otherwise 0).
00929     virtual int          reloadNewFiles(float time_now);
00930 
00931     void                 parmChanged( int parm_index );
00932     void                 parmExprChanged(int parm_index);
00933 
00934     // This is called when our OP_Operator is deleted before we are.
00935     void                 operatorDeleted();
00936 
00937     // These functions deal with the opparm command.
00938     void                 saveParmCommand(ostream &os, int values = 0,
00939                                          int defaultstoo = 1,
00940                                          bool spareparms = true) const;
00941     int                  loadParmCommand(int argc, char *argv[],
00942                                          int docallbacks, void *data,
00943                                          float now, bool followchrefs,
00944                                          CMD_Args *args);
00945     void                 commandParmCallback(void *data, float now,
00946                                              int argc, char *argv[],
00947                                              CMD_Args *args);
00948     void                 saveMultiParmInstanceCommand(
00949                                          ostream &os,
00950                                          const char *opname,
00951                                          bool spareparms) const;
00952 
00953     // Run the callback function for a particular parm, and the callbacks
00954     // of any parms linked to this parm. This function is implemented in
00955     // OP_Node.
00956     virtual bool         triggerParmCallback(PRM_Parm *parmptr, float now,
00957                                              int value, void *data) = 0;
00958 
00959     virtual int64        getMemUsage(UT_Bool onlythis) const;
00960 
00961     void                 bumpTakeReference(int dir)
00962                              { myTakeReferences += dir; }
00963     int                  getTakeReferences() const
00964                              { return myTakeReferences; }
00965 
00966 
00967     /// This method will create channel groups and populate them with
00968     /// channels from this operator.  The channel groups created will
00969     /// correspond to the folders in this operator's parameters.
00970     /// Unless only_channels is specified, all auto-scoped parms will get 
00971     /// included.
00972     void                 createChannelGroupsFromFolders(CH_Group &parent_group,
00973                                             bool only_channels,
00974                                             bool leaf_channels_only = false);
00975 
00976     // Returns a list of the autoscopeable channels for this node.
00977     void                 getAutoScopedChannels(CH_ChannelRefList &chlist);
00978 
00979     // Returns command to chopscope CHOPed channels for this node.
00980     void                 getChopScopeChannels(UT_WorkBuffer &chopscope_cmd);
00981 
00982     // Returns a pointer to the templates used in constructing dialogs for
00983     // this node.
00984     PRM_Template        *getInterfaceParmTemplates();
00985     // Returns true if the specified parameter is visible in the interface
00986     // templates. This accounts for visiblity of containing parm pages
00987     // as well as the parm itself.
00988     bool                 getParmIsVisible(const char *parmname);
00989 
00990     PRM_Template        *getSpareParmTemplates();
00991     PRM_ScriptImports   *getSpareParmTemplateImports();
00992     PRM_Template        *getSpareParmLayoutTemplates();
00993     int                  getSpareParmTemplatesId();
00994 
00995     // Get our multiparm instance info used by initMultiparmInstance.
00996     bool                 hasMultiparmInfo() const;
00997     OP_MultiparmInfo    &getMultiparmInfo();
00998 
00999     // Build a command line for a VEx script to be called with.  This does all
01000     // the channel evaluation and string expansion required.  If there is an
01001     // error, 0 is returned (otherwise 1).
01002     int                  buildVexCommand(UT_String &result,
01003                                          PRM_Template *templatelist,
01004                                          float now,
01005                                          int start_parm = 0,
01006                                          int end_parm = 10000);
01007 
01008 
01009     // This function is caled when any multiparm has a new instance added.
01010     // It gives the parm owner a chance to initialize the multiparm values.
01011     virtual void         initMultiparmInstance(UT_PtrArray<PRM_Parm *> &parms);
01012     // This function sends an opChanged notification of our multiparm change.
01013     virtual void         addOrRemoveMultiparmInstance();
01014 
01015     virtual bool         savePresetContents(ostream &os);
01016     virtual bool         loadPresetContents(const char *tok, UT_IStream &is);
01017 
01018     static void          buildMParmInst(const PRM_Template *templates,
01019                                         UT_StringArray &mparm_inst,
01020                                         UT_IntArray &mparm_lvl,
01021                                         int level);
01022     static bool          isMParmInstance(const char *chname,
01023                                          const UT_StringArray &mparm_inst,
01024                                          const UT_IntArray &mparm_lvl);
01025 
01026     /// Currently overriden in VOPs. If this function returns false,
01027     /// the given parameter's name will never be placed in a list of
01028     /// reserved parms. Otherwise, it will if it is not a spare parm 
01029     /// in PI_EditScriptedParms::initializeReserveNames().
01030     virtual bool         allowReservingParm(PRM_Parm* parm)
01031                             { return true; }
01032 
01033 protected:
01034     void                 saveMultiParmForUndo(int index);
01035 
01036     void                 stealGlobalErrors();
01037     void                 stealErrors(OP_Parameters &src);
01038     void                 stealErrors(OP_PostIt &src);
01039     
01040     // NOTE: Do not hold onto the ptr object longer than necessary!
01041     UT_LockedRawPtr<UT_ErrorManager> getLockedErrorManager()
01042     {
01043         return UT_LockedRawPtr<UT_ErrorManager>(myErrorManager,
01044                                                 myErrorManagerLock);
01045     }
01046 
01047     virtual void         permissionError(const char *chname = 0);
01048 
01049     // checkExpressionError() is split up into a checking part and an actual
01050     // error handling part, evaluationError() so that the checking part can
01051     // be inlined.
01052     SYS_FORCE_INLINE bool checkExpressionError(PRM_Parm *parm, int thread) const
01053                             {
01054                                 int err = ev_GetErrNo(thread);
01055                                 if (err == EV_NOERROR)
01056                                     return false;
01057                                 evaluationError(parm, err, thread);
01058                                 return true;
01059                             }
01060 
01061     void                 resetParmEventHandler();
01062 
01063     int                 *allocIndirect(int size=64);
01064 
01065              OP_Parameters(const char *name, OP_Operator *entry);
01066              OP_Parameters(const OP_Parameters &source, const char *name);
01067     virtual ~OP_Parameters();
01068 
01069     //
01070     // The "initializeParms" method must be called to provide the channel
01071     // collection and build the parameter list.
01072     //
01073     void                 initializeParms(OP_Channels *channels);
01074 
01075     // op dependencies
01076     virtual void         buildOpDependencies()
01077                          { }
01078     virtual void         checkChannelDependencies(CH_Channel * /*ch*/,
01079                                                   CH_CHANGE_TYPE /*reason*/)
01080                          { }
01081 
01082     int                  rename(const char *newname);
01083     virtual bool         createSpareParameterFromChannel(const char *chname);
01084     virtual bool         createSpareParametersFromChannels(
01085                                 UT_BitArray &selection,
01086                                 const CH_ChannelList &channels);
01087 
01088     CH_LocalVariable    *getVariable(int i) const;
01089     CH_LocalVariable    *getVariable(const char *name) const;
01090 
01091     //
01092     //
01093     OP_ERROR             saveChannels(ostream &os, int binary, bool compiled,
01094                                       int selected);
01095     OP_ERROR             saveParmChannels(int parm_index, ostream &os,
01096                                       int binary, bool compiled);
01097     OP_ERROR             saveParameters(ostream &os, int binary, bool compiled);
01098     OP_ERROR             saveChannelAliases(ostream &os, int binary);
01099 
01100     bool                 loadChannels(UT_IStream &is, const char *path,
01101                                       CH_Collection *obsolete_channels);
01102     bool                 loadParameters(UT_IStream &is, const char *path,
01103                                         PRM_ParmList *obsolete_parms);
01104     bool                 loadChannelAliases(UT_IStream &is, const char *path=0);
01105     bool                 loadOldSpareParms(UT_IStream &is);
01106 
01107     //  Allow our sub-class to be notified when something gets changed
01108     //  Since the parameter only holds the name & the parameters, there
01109     //  are only two types of events generated here...
01110     virtual void         opChanged(OP_EventType type, void *dataptr = 0) = 0;
01111 
01112     /// This is a helper method to the setChannelScope method.  It traverses
01113     /// the node's parameters and sets the scope on them according to the
01114     /// given pattern.
01115     virtual void         traverseScope(const char *pattern, OP_ScopeOp scope_op,
01116                                        const OP_ScopeOptions &scope_options);
01117 
01118     // A virtual method to get access to the associated node flag.  This would
01119     // probably be unnecessary if myTakeReferences were used.
01120     virtual int          getHasTakeData() const { return 0 ;}
01121 
01122 
01123     PRM_ParmList                        *myParmList;
01124     OP_Channels                         *myChannels;
01125     OP_Stat                              myStats;
01126 
01127 private:
01128     // evaluationError() generates the appropriate call to opError() and then
01129     // clears the expression error state.
01130     void                 evaluationError(PRM_Parm *parm, int err,
01131                                          int thread) const;
01132 
01133     // these methods are the actual instantiation of the set... and
01134     // setSilent... methods.
01135     void                 setFullInt(int pi, int vi, float t, int val, bool p);
01136     void                 setFullInt(const char *pn, int vi, float t, int val,
01137                                     bool p);
01138     void                 setFullInt(const char *pn, int &pi, int vi, float t,
01139                                     int val, bool p);
01140 
01141 
01142     void                 setFullFloat(int pi, int vi, float t, float val,
01143                                       int h, bool p);
01144     void                 setFullFloat(const char *pn, int vi,  float t,
01145                                       float val, int h, bool p);
01146     void                 setFullFloat(const char *pn, int &pi, int vi,
01147                                       float t, float val, int h, bool p);
01148 
01149     void                 setFullString(const UT_String &val,
01150                                        CH_StringMeaning meaning, int pi, int vi,
01151                                        float t, bool p);
01152     void                 setFullString(const UT_String &val,
01153                                        CH_StringMeaning meaning,
01154                                        const char *pn,
01155                                        int vi, float t, bool p);
01156     void                 setFullString(const UT_String &val,
01157                                        CH_StringMeaning meaning,
01158                                        const char *pn,
01159                                        int &pi, int vi, float t, bool p);
01160     
01161     void                 setFullIntInst(int val, const char *name,
01162                                         const int *inst, int vi, float t,
01163                                         int nestlevel, bool p);
01164     void                 setFullFloatInst(float val, const char *name,
01165                                           const int *inst, int vi, float t,
01166                                           int nestlevel, bool p);
01167     void                 setFullStringInst(const UT_String &val,
01168                                            CH_StringMeaning meaning,
01169                                            const char *name,
01170                                            const int *inst, int vi, float t,
01171                                            int nestlevel, bool p);
01172 
01173     // Set values given a parameter pointer (rather than a lookup index).
01174     // These all take harden and propagate parameters.
01175     bool                 setFull(PRM_Parm &parm, int vi, fpreal now, int value,
01176                                             bool harden, bool propgate);
01177     bool                 setFull(PRM_Parm &parm, int vi, fpreal now, fpreal val,
01178                                             bool harden, bool propgate);
01179     bool                 setFull(PRM_Parm &parm, int vi, fpreal now,
01180                                             const char *value,
01181                                             CH_StringMeaning meaning,
01182                                             bool harden, bool propgate);
01183     
01184     // Event handler
01185     static void          changeEvent(void *, CH_CHANGE_TYPE, int);
01186 
01187     mutable UT_Lock      myErrorManagerLock;
01188     UT_ErrorManager      myErrorManager;
01189 
01190     UT_String            myName;
01191     OP_Operator         *myTableEntry;
01192     uint                 myTakeReferences;
01193 
01194     unsigned             myUndoAllParmSavedFlag:1,
01195                          myUndoScopedSavedFlag:1,
01196                          myAnyUndoFlagSet:1;
01197 
01198     OP_ParmCache        *myParmCache;
01199 
01200     OP_SpareParms       *mySpareParms;
01201     bool                 myChangingSpareParms;
01202 
01203     OP_MultiparmInfo    *myMultiparmInfo;
01204 
01205     friend class         OP_TakeParm;
01206     friend class         OP_UndoParm;
01207     friend class         OP_UndoSpareParm;
01208 };
01209 
01210 // helper functions
01211 
01212 OP_API PRM_Parm *OPgetParameterFromChannel( CH_Channel *chp, int *vecidx );
01213 OP_API void OPsaveChannelForUndo( CH_Channel *chp );
01214 OP_API void OPsaveChannelsForUndo( const CH_ChannelList &channels );
01215 OP_API void OPtakeAutoActivateChannel( CH_Channel *chp );
01216 
01217 #endif