HDK: HOM/HOM_Point.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_Point_h__
00017 #define __HOM_Point_h__
00018 
00019 #include "HOM_API.h"
00020 #include "HOM_Defines.h"
00021 #include "HOM_Errors.h"
00022 #include "HOM_Vector3.h"
00023 #include <vector>
00024 class HOM_Geometry;
00025 
00026 SWIGOUT(%rename(Point) HOM_Point;)
00027 
00028 class HOM_API HOM_Point
00029 {
00030 public:
00031     HOM_Point()
00032     { HOM_CONSTRUCT_OBJECT(this) }
00033     HOM_Point(const HOM_Point &)
00034     { HOM_CONSTRUCT_OBJECT(this) }
00035     virtual ~HOM_Point()
00036     { HOM_DESTRUCT_OBJECT(this) }
00037 
00038     virtual bool operator==(HOM_Point &point)
00039         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00040 
00041     virtual bool operator!=(HOM_Point &point)
00042         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00043 
00044 
00045     virtual int __hash__() throw(HOM_Error) = 0;
00046     virtual std::string __repr__() throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00047 
00048     SWIGOUT(%newobject geometry;)
00049     virtual HOM_Geometry *geometry() throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00050 
00051     virtual int number() throw(HOM_Error) = 0;
00052 
00053 
00054     SWIGOUT(%newobject position;)
00055     virtual HOM_Vector3 *position()
00056         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00057     virtual void setPosition(const std::vector<float> &position)
00058         throw(HOM_GeometryPermissionError, HOM_InvalidSize,
00059             HOM_ObjectWasDeleted, HOM_Error) = 0;
00060 
00061     virtual float weight()
00062         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00063     virtual void setWeight(float weight)
00064         throw(HOM_GeometryPermissionError, HOM_ObjectWasDeleted, HOM_Error) = 0;
00065 
00066 
00067     SWIGPYTHONOUT(%feature("autodoc",
00068         "attribType(self) -> hou.attribType enum value") attribType;)
00069     virtual HOM_EnumValue& attribType() throw(HOM_Error) = 0;
00070 
00071 
00072     virtual float floatAttribValue(const char *name)
00073         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00074 
00075     virtual float floatAttribValue(HOM_Attrib &attrib)
00076         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00077 
00078     SWIGPYTHONOUT(%feature("autodoc",
00079         "floatListAttribValue(self, name) -> tuple of floats")
00080         floatListAttribValue(const char *);)
00081     virtual std::vector<float> floatListAttribValue(const char *name)
00082         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00083 
00084     SWIGPYTHONOUT(%feature("autodoc",
00085         "floatListAttribValue(self, attrib) -> tuple of floats")
00086         floatListAttribValue(HOM_Attrib &);)
00087     virtual std::vector<float> floatListAttribValue(HOM_Attrib &attrib)
00088         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00089 
00090     virtual int intAttribValue(const char *name)
00091         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00092 
00093     virtual int intAttribValue(HOM_Attrib &attrib)
00094         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00095 
00096     SWIGPYTHONOUT(%feature("autodoc",
00097         "intListAttribValue(self, name) -> tuple of ints")
00098         intListAttribValue(const char *);)
00099     virtual std::vector<int> intListAttribValue(const char *name)
00100         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00101 
00102     SWIGPYTHONOUT(%feature("autodoc",
00103         "intListAttribValue(self, attrib) -> tuple of ints")
00104         intListAttribValue(HOM_Attrib &);)
00105     virtual std::vector<int> intListAttribValue(HOM_Attrib &attrib)
00106         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00107 
00108     virtual std::string stringAttribValue(const char *name)
00109         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00110 
00111     virtual std::string stringAttribValue(HOM_Attrib &attrib)
00112         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00113 
00114 
00115     virtual void setAttribValue(
00116             HOM_Attrib &attrib, int attrib_value)
00117         throw(HOM_OperationFailed, HOM_GeometryPermissionError,
00118             HOM_ObjectWasDeleted, HOM_Error) = 0;
00119     virtual void setAttribValue(
00120             HOM_Attrib &attrib, float attrib_value)
00121         throw(HOM_OperationFailed, HOM_GeometryPermissionError,
00122             HOM_ObjectWasDeleted, HOM_Error) = 0;
00123     virtual void setAttribValue(
00124             HOM_Attrib &attrib, const char *attrib_value)
00125         throw(HOM_OperationFailed, HOM_GeometryPermissionError,
00126             HOM_ObjectWasDeleted, HOM_Error) = 0;
00127     virtual void setAttribValue(
00128             HOM_Attrib &attrib, const std::vector<int> &attrib_value)
00129         throw(HOM_OperationFailed, HOM_GeometryPermissionError,
00130             HOM_InvalidSize, HOM_ObjectWasDeleted, HOM_Error) = 0;
00131     virtual void setAttribValue(
00132             HOM_Attrib &attrib, const std::vector<float> &attrib_value)
00133         throw(HOM_OperationFailed, HOM_GeometryPermissionError,
00134             HOM_ObjectWasDeleted, HOM_Error) = 0;
00135 
00136     virtual void setAttribValue(
00137             const char *attrib_name, int attrib_value)
00138         throw(HOM_TypeError, HOM_OperationFailed, HOM_GeometryPermissionError,
00139             HOM_ObjectWasDeleted, HOM_Error) = 0;
00140     virtual void setAttribValue(
00141             const char *attrib_name, float attrib_value)
00142         throw(HOM_TypeError, HOM_OperationFailed, HOM_GeometryPermissionError,
00143             HOM_ObjectWasDeleted, HOM_Error) = 0;
00144     virtual void setAttribValue(
00145             const char *attrib_name, const char *attrib_value)
00146         throw(HOM_TypeError, HOM_OperationFailed, HOM_GeometryPermissionError,
00147             HOM_ObjectWasDeleted, HOM_Error) = 0;
00148     // Note that, because of strangess the with way swig works when deciding
00149     // which overloaded method to call, it's very important that we list the
00150     // vector of ints before the vector of floats.  Otherwise, swig will call
00151     // the float version when you pass in a vector of ints.
00152     virtual void setAttribValue(
00153             const char *attrib_name, const std::vector<int> &attrib_value)
00154         throw(HOM_TypeError, HOM_OperationFailed, HOM_GeometryPermissionError,
00155             HOM_ObjectWasDeleted, HOM_Error) = 0;
00156     virtual void setAttribValue(
00157             const char *attrib_name, const std::vector<float> &attrib_value)
00158         throw(HOM_TypeError, HOM_OperationFailed, HOM_GeometryPermissionError,
00159             HOM_InvalidSize, HOM_ObjectWasDeleted, HOM_Error) = 0;
00160 
00161 #ifdef SWIG
00162 %extend
00163 {
00164     SWIGPYTHONOUT(%feature("autodoc",
00165         "attribValue(self, name) -> int, float, string or tuple")
00166         attribValue(const char *);)
00167     InterpreterObject attribValue(const char *name)
00168         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error)
00169     { return HOMattribValue(*self, name); }
00170 
00171     SWIGPYTHONOUT(%feature("autodoc",
00172         "attribValue(self, attrib) -> int, float, string or tuple")
00173         attribValue(HOM_Attrib &);)
00174     InterpreterObject attribValue(HOM_Attrib &attrib)
00175         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error)
00176     { return HOMattribValue(*self, attrib); }
00177 }
00178 #endif
00179 };
00180 
00181 #endif