HDK: HOM/HOM_Parm.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  *      Side Effects Software Inc
00008  *      123 Front Street West, Suite 1401
00009  *      Toronto, Ontario
00010  *      Canada   M5J 2M2
00011  *      416-504-9876
00012  *
00013  * COMMENTS:
00014  */
00015 
00016 #ifndef __HOM_Parm_h__
00017 #define __HOM_Parm_h__
00018 
00019 #include "HOM_API.h"
00020 #include "HOM_Defines.h"
00021 #include "HOM_Errors.h"
00022 #include "HOM_BaseKeyframe.h"
00023 #include <string>
00024 #include <vector>
00025 class HOM_ParmTemplate;
00026 class HOM_ParmTuple;
00027 class HOM_Track;
00028 class HOM_Ramp;
00029 class UT_WorkBuffer;
00030 
00031 SWIGOUT(%rename(Parm) HOM_Parm;)
00032 
00033 class HOM_API HOM_Parm
00034 {
00035 public:
00036     HOM_Parm()
00037     { HOM_CONSTRUCT_OBJECT(this) }
00038     HOM_Parm(const HOM_Parm &parm)
00039     { HOM_CONSTRUCT_OBJECT(this) }
00040     virtual ~HOM_Parm()
00041     { HOM_DESTRUCT_OBJECT(this) }
00042 
00043     // We compare against a pointer instead of a reference because we want
00044     // to be able to compare against None.
00045     virtual bool operator==(HOM_Parm *parm)
00046         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00047     virtual bool operator!=(HOM_Parm *parm)
00048         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00049     SWIGOUT(%ignore operator<(HOM_Parm *parm);)
00050     virtual bool operator<(HOM_Parm *parm)
00051         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00052 
00053     virtual int __hash__() throw(HOM_Error) = 0;
00054     virtual std::string __repr__() throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00055 
00056     SWIGOUT(%newobject node;)
00057     virtual HOM_Node *node() throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00058 
00059     SWIGOUT(%newobject tuple;)
00060     virtual HOM_ParmTuple *tuple() throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00061 
00062     SWIGOUT(%newobject parmTemplate;)
00063     virtual HOM_ParmTemplate *parmTemplate()
00064         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00065 
00066     virtual std::string name() throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00067     virtual std::string path() throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00068     virtual std::string description()
00069         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00070     virtual int componentIndex() throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00071 
00072     SWIGPYTHONOUT(%feature("autodoc",
00073         "menuItems(self) -> tuple of strings") menuItems;)
00074     virtual std::vector<std::string> menuItems()
00075         throw(HOM_OperationFailed, HOM_Error) = 0;
00076 
00077     virtual void pressButton()
00078         throw(HOM_OperationFailed, HOM_PermissionError, HOM_ObjectWasDeleted,
00079             HOM_Error) = 0;
00080 
00081     virtual void set(float float_value) throw(
00082         HOM_TypeError, HOM_PermissionError,
00083         HOM_ObjectWasDeleted, HOM_Error) = 0;
00084     virtual void setPending(float float_value) throw(
00085         HOM_TypeError, HOM_PermissionError,
00086         HOM_ObjectWasDeleted, HOM_Error) = 0;
00087     virtual void set(int int_value) throw(
00088         HOM_TypeError, HOM_PermissionError,
00089         HOM_ObjectWasDeleted, HOM_Error) = 0;
00090     virtual void setPending(int int_value) throw(
00091         HOM_TypeError, HOM_PermissionError,
00092         HOM_ObjectWasDeleted, HOM_Error) = 0;
00093     virtual void set(const char *string_value) throw(
00094         HOM_TypeError, HOM_PermissionError, HOM_OperationFailed,
00095         HOM_ObjectWasDeleted, HOM_Error) = 0;
00096     virtual void setPending(const char *string_value) throw(
00097         HOM_TypeError, HOM_PermissionError, HOM_OperationFailed,
00098         HOM_ObjectWasDeleted, HOM_Error) = 0;
00099     virtual void set(HOM_Parm &parm, HOM_EnumValue *language = NULL) throw(
00100         HOM_TypeError, HOM_PermissionError, HOM_OperationFailed,
00101         HOM_ObjectWasDeleted, HOM_Error) = 0;
00102 
00103     virtual void revertToDefaults()
00104         throw(HOM_PermissionError, HOM_ObjectWasDeleted, HOM_Error) = 0;
00105     virtual void revertToAndRestorePermanentDefaults()
00106         throw(HOM_PermissionError, HOM_ObjectWasDeleted, HOM_Error) = 0;
00107 
00108     SWIGOUT(%kwargs setExpression;)
00109     virtual void setExpression(const char *expression,
00110             HOM_EnumValue *language = NULL,
00111             bool replace_expression=true)
00112         throw(HOM_TypeError, HOM_PermissionError,
00113               HOM_ObjectWasDeleted, HOM_Error) = 0;
00114     virtual std::string expression()
00115         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00116 
00117     SWIGPYTHONOUT(%feature("autodoc",
00118         "expressionLanguage(self) -> hou.exprLanguage enum value")
00119         expressionLanguage;)
00120     virtual HOM_EnumValue *expressionLanguage()
00121         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00122 
00123 
00124     virtual void setKeyframe(HOM_BaseKeyframe &keyframe) throw(HOM_TypeError,
00125         HOM_PermissionError, HOM_ObjectWasDeleted, HOM_Error) = 0;
00126 
00127     SWIGPYTHONOUT(%feature("autodoc",
00128         "keyframes(self) -> tuple of BaseKeyframes") keyframes;)
00129     virtual std::vector<HOM_ElemPtr<HOM_BaseKeyframe> > keyframes()
00130         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00131 
00132     virtual float evalAsFloat()
00133         throw(HOM_TypeError, HOM_ObjectWasDeleted, HOM_Error) = 0;
00134     virtual float evalAsFloatAtFrame(float frame)
00135         throw(HOM_TypeError, HOM_ObjectWasDeleted, HOM_Error) = 0;
00136     virtual int evalAsInt()
00137         throw(HOM_TypeError, HOM_ObjectWasDeleted, HOM_Error) = 0;
00138     virtual int evalAsIntAtFrame(float frame)
00139         throw(HOM_TypeError, HOM_ObjectWasDeleted, HOM_Error) = 0;
00140     virtual std::string evalAsString()
00141         throw(HOM_TypeError, HOM_ObjectWasDeleted, HOM_Error) = 0;
00142     virtual std::string evalAsStringAtFrame(float frame)
00143         throw(HOM_TypeError, HOM_ObjectWasDeleted, HOM_Error) = 0;
00144     SWIGOUT(%newobject evalAsRamp;)
00145     virtual HOM_Ramp *evalAsRamp()
00146         throw(HOM_TypeError, HOM_ObjectWasDeleted, HOM_Error) = 0;
00147     SWIGOUT(%newobject evalAsRampAtFrame;)
00148     virtual HOM_Ramp *evalAsRampAtFrame(float frame)
00149         throw(HOM_TypeError, HOM_ObjectWasDeleted, HOM_Error) = 0;
00150 
00151     virtual std::string unexpandedString()
00152         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00153 
00154     virtual void deleteKeyframeAtFrame(float frame)
00155         throw(HOM_OperationFailed, HOM_PermissionError, HOM_ObjectWasDeleted,
00156             HOM_Error) = 0;
00157 
00158     virtual void deleteAllKeyframes()
00159         throw(HOM_ObjectWasDeleted, HOM_PermissionError, HOM_Error) = 0;
00160 
00161     virtual HOM_Parm *getReferencedParm()
00162         throw(HOM_TypeError, HOM_ObjectWasDeleted, HOM_Error) = 0;
00163 
00164     virtual bool isLocked()
00165         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00166     virtual void lock(bool on)
00167         throw(HOM_ObjectWasDeleted, HOM_PermissionError, HOM_Error) = 0;
00168 
00169     virtual bool isAutoscoped()
00170         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00171     virtual void setAutoscope(bool on)
00172         throw(HOM_ObjectWasDeleted, HOM_PermissionError, HOM_Error) = 0;
00173 
00174     virtual std::string alias()
00175         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00176     virtual void setAlias(const char *alias_name)
00177         throw(HOM_PermissionError, HOM_ObjectWasDeleted, HOM_OperationFailed, 
00178               HOM_Error) = 0;
00179 
00180     virtual bool isSpare()
00181         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00182 
00183     virtual bool isTimeDependent()
00184         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00185 
00186     virtual bool isMultiParmInstance()
00187         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00188 
00189     SWIGPYTHONOUT(%feature("autodoc",
00190         "containingFolders(self) -> tuple of strings") containingFolders;)
00191     virtual std::vector<std::string> containingFolders()
00192         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00193 
00194     SWIGPYTHONOUT(%feature("autodoc",
00195         "containingFolderIndices(self) -> tuple of ints")
00196         containingFolderIndices;)
00197     virtual std::vector<int> containingFolderIndices()
00198         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00199 
00200     SWIGPYTHONOUT(%feature("autodoc",
00201         "containingFolderSetParmTuples(self) -> tuple of ParmTuples")
00202         containingFolderSetParmTuples;)
00203     virtual std::vector<HOM_ElemPtr<HOM_ParmTuple> >
00204             containingFolderSetParmTuples()
00205         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00206 
00207     SWIGOUT(%kwargs asCode;)
00208     virtual std::string asCode(
00209             bool brief = false,
00210             bool save_values = true,
00211             bool save_keyframes = true,
00212             bool save_keys_in_frames=false,
00213             bool save_flag_values=true,
00214             bool save_aliases=true,
00215             const char *function_name = NULL)
00216         throw(HOM_ObjectWasDeleted, HOM_TypeError, HOM_Error) = 0;
00217 
00218     // You can get the parm data type with parmTemplate().dataType().
00219     // However, we need a way to get the parm data type's enum value
00220     // from C++ code without creating a temporary ParmTemplate object,
00221     // so that's why parmDataTypeEnumId() exists.
00222     SWIGOUT(%ignore parmDataTypeEnumId;)
00223     virtual int parmDataTypeEnumId() throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00224 
00225     SWIGOUT(%newobject createClip;)
00226     virtual HOM_Node *createClip(HOM_Node &parent_node,
00227                                   const char *name,
00228                                   bool create_new,
00229                                   bool apply_immediately,
00230                                   bool current_value_only=false,
00231                                   bool create_locked=false)
00232         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00233 
00234     SWIGOUT(%newobject overrideTrack;)
00235     virtual HOM_Track *overrideTrack()
00236         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00237 
00238 #ifdef SWIG
00239 %extend
00240 {
00241     SWIGPYTHONOUT(%feature("autodoc",
00242         "eval(self) -> int, float, or string") eval;)
00243     InterpreterObject eval()
00244         throw(HOM_ObjectWasDeleted, HOM_Error)
00245     {
00246         return HOMevalParm(*self);
00247     }
00248 
00249     SWIGPYTHONOUT(%feature("autodoc",
00250         "evalAtFrame(self, frame) -> int, float, or string") evalAtFrame;)
00251     InterpreterObject evalAtFrame(float frame)
00252         throw(HOM_ObjectWasDeleted, HOM_Error)
00253     {
00254         return HOMevalParmAtFrame(*self, frame);
00255     }
00256 }
00257 #endif
00258 };
00259 
00260 #endif