HDK: HOM/HOM_ParmTuple.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_ParmTuple_h__
00017 #define __HOM_ParmTuple_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 #include <stdexcept>
00026 class HOM_ParmTemplate;
00027 class HOM_Parm;
00028 class HOM_Ramp;
00029 
00030 SWIGOUT(%rename(ParmTuple) HOM_ParmTuple;)
00031 
00032 class HOM_API HOM_ParmTuple
00033 {
00034 public:
00035     HOM_ParmTuple()
00036     { HOM_CONSTRUCT_OBJECT(this) }
00037     HOM_ParmTuple(const HOM_ParmTuple &parm_tuple)
00038     { HOM_CONSTRUCT_OBJECT(this) }
00039     virtual ~HOM_ParmTuple()
00040     { HOM_DESTRUCT_OBJECT(this) }
00041 
00042     // We compare against a pointer instead of a reference because we want
00043     // to be able to compare against None.
00044     virtual bool operator==(HOM_ParmTuple *parm_tuple)
00045         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00046     virtual bool operator!=(HOM_ParmTuple *parm_tuple)
00047         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00048 
00049     virtual int __hash__() throw(HOM_Error) = 0;
00050     virtual std::string __repr__() throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00051 
00052     SWIGOUT(%newobject node;)
00053     virtual HOM_Node *node() throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00054 
00055     SWIGOUT(%newobject parmTemplate;)
00056     virtual HOM_ParmTemplate *parmTemplate()
00057         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00058 
00059     virtual std::string name() throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00060     virtual std::string description()
00061         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00062 
00063     // Wrapping a version of set() that takes a vector of floats will
00064     // let you pass a vector of floats or a vector of ints to it.  So,
00065     // we don't bother to provide a version that takes a vector of ints.
00066     virtual void set(const std::vector<float> &float_values)
00067         throw(HOM_TypeError, HOM_InvalidSize, HOM_PermissionError,
00068             HOM_ObjectWasDeleted, HOM_Error) = 0;
00069     virtual void setPending(const std::vector<float> &float_values)
00070         throw(HOM_TypeError, HOM_InvalidSize, HOM_PermissionError,
00071             HOM_ObjectWasDeleted, HOM_Error) = 0;
00072     virtual void set(const std::vector<std::string> &string_values)
00073         throw(HOM_TypeError, HOM_InvalidSize, HOM_PermissionError,
00074             HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00075     virtual void setPending(const std::vector<std::string> &string_values)
00076         throw(HOM_TypeError, HOM_InvalidSize, HOM_PermissionError,
00077             HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00078 
00079     virtual void revertToDefaults()
00080         throw(HOM_PermissionError, HOM_ObjectWasDeleted, HOM_Error) = 0;
00081     virtual void revertToAndRestorePermanentDefaults()
00082         throw(HOM_PermissionError, HOM_ObjectWasDeleted, HOM_Error) = 0;
00083 
00084     SWIGPYTHONOUT(%feature("autodoc",
00085         "evalAsFloats(self) -> tuple of floats") evalAsFloats;)
00086     virtual std::vector<float> evalAsFloats()
00087         throw(HOM_TypeError, HOM_ObjectWasDeleted, HOM_Error) = 0;
00088 
00089     SWIGPYTHONOUT(%feature("autodoc",
00090         "evalAsFloatsAtFrame(self, frame) -> tuple of floats")
00091         evalAsFloatsAtFrame;)
00092     virtual std::vector<float> evalAsFloatsAtFrame(float frame)
00093         throw(HOM_TypeError, HOM_ObjectWasDeleted, HOM_Error) = 0;
00094 
00095     SWIGPYTHONOUT(%feature("autodoc",
00096         "evalAsInts(self) -> tuple of ints") evalAsInts;)
00097     virtual std::vector<int> evalAsInts()
00098         throw(HOM_TypeError, HOM_ObjectWasDeleted, HOM_Error) = 0;
00099 
00100     SWIGPYTHONOUT(%feature("autodoc",
00101         "evalAsIntsAtFrame(self, frame) -> tuple of ints") evalAsIntsAtFrame;)
00102     virtual std::vector<int> evalAsIntsAtFrame(float frame)
00103         throw(HOM_TypeError, HOM_ObjectWasDeleted, HOM_Error) = 0;
00104 
00105     SWIGPYTHONOUT(%feature("autodoc",
00106         "evalAsStrings(self) -> tuple of strings") evalAsStrings;)
00107     virtual std::vector<std::string> evalAsStrings()
00108         throw(HOM_TypeError, HOM_ObjectWasDeleted, HOM_Error) = 0;
00109 
00110     SWIGPYTHONOUT(%feature("autodoc",
00111         "evalAsStringsAtFrame(self, frame) -> tuple of strings")
00112         evalAsStringsAtFrame;)
00113     virtual std::vector<std::string> evalAsStringsAtFrame(float frame)
00114         throw(HOM_TypeError, HOM_ObjectWasDeleted, HOM_Error) = 0;
00115 
00116     SWIGPYTHONOUT(%feature("autodoc",
00117         "evalAsRamps(self) -> tuple of hou.Ramp") evalAsRamps;)
00118     virtual std::vector<HOM_ElemPtr<HOM_Ramp> > evalAsRamps()
00119         throw(HOM_TypeError, HOM_ObjectWasDeleted, HOM_Error) = 0;
00120 
00121     SWIGPYTHONOUT(%feature("autodoc",
00122         "evalAsRampsAtFrame(self, frame) -> tuple of hou.Ramp")
00123         evalAsRampsAtFrame;)
00124     SWIGOUT(%newobject evalAsRampAtFrame;)
00125     virtual std::vector<HOM_ElemPtr<HOM_Ramp> > evalAsRampsAtFrame(float frame)
00126         throw(HOM_TypeError, HOM_ObjectWasDeleted, HOM_Error) = 0;
00127 
00128     virtual void lock(const std::vector<bool> &bool_values)
00129         throw(HOM_ObjectWasDeleted, HOM_InvalidSize, HOM_PermissionError, 
00130               HOM_Error) = 0;
00131     virtual void setAutoscope(const std::vector<bool> &bool_values)
00132         throw(HOM_ObjectWasDeleted, HOM_InvalidSize, HOM_PermissionError, 
00133               HOM_Error) = 0;
00134 
00135     virtual bool isSpare()
00136         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00137 
00138     virtual bool isMultiParmInstance()
00139         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00140 
00141     virtual void deleteAllKeyframes()
00142         throw(HOM_ObjectWasDeleted, HOM_PermissionError, HOM_Error) = 0;
00143 
00144     SWIGOUT(%newobject __getitem__;)
00145     virtual HOM_Parm *__getitem__(int index)
00146         throw(std::out_of_range, HOM_ObjectWasDeleted, HOM_Error) = 0;
00147     virtual int __len__()
00148         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00149 
00150     virtual void hide(bool on)
00151         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_PermissionError,
00152             HOM_Error) = 0;
00153 
00154     SWIGOUT(%kwargs asCode;)
00155     virtual std::string asCode(bool brief=false, bool save_values=true,
00156                                bool save_keyframes=true,
00157                                bool save_keys_in_frames=false,
00158                                bool save_flag_values=true,
00159                                bool save_aliases=true,
00160                                const char *function_name=NULL)
00161         throw(HOM_ObjectWasDeleted, HOM_TypeError, HOM_Error) = 0;
00162 
00163     // You can get the parm data type with parmTemplate().dataType().
00164     // However, we need a way to get the parm data type's enum value
00165     // from C++ code without creating a temporary ParmTemplate object,
00166     // so that's why parmDataTypeEnumId() exists.
00167     SWIGOUT(%ignore parmDataTypeEnumId;)
00168     virtual int parmDataTypeEnumId() throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00169 
00170     SWIGOUT(%newobject createClip;)
00171     virtual HOM_Node *createClip(HOM_Node &parent_node,
00172                                  const char *name,
00173                                  bool create_new,
00174                                  bool apply_immediately,
00175                                  bool current_value_only=false,
00176                                  bool create_locked=false)
00177         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00178 
00179 #ifdef SWIG
00180 %extend
00181 {
00182     SWIGPYTHONOUT(%feature("autodoc",
00183         "eval(self) -> tuple of ints, floats, strings, or ramp") eval;)
00184     InterpreterObject eval() throw(HOM_ObjectWasDeleted, HOM_Error)
00185     {
00186         return HOMevalParmTuple(*self);
00187     }
00188 
00189     SWIGPYTHONOUT(%feature("autodoc",
00190         "evalAtFrame(self, frame) -> tuple of ints, floats, strings, or ramp")
00191         evalAtFrame;)
00192     InterpreterObject evalAtFrame(float frame)
00193         throw(HOM_ObjectWasDeleted, HOM_Error)
00194     {
00195         return HOMevalParmTupleAtFrame(*self, frame);
00196     }
00197 }
00198 #endif
00199 };
00200 
00201 #endif