HDK: HOM/HOM_Defines.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_Defines_h__
00017 #define __HOM_Defines_h__
00018 
00019 #include <UT/UT_Assert.h>
00020 
00021 // Unfortunately, we can't compare against UT_ASSERT_LEVEL_PARANOID here,
00022 // otherwise the comparison sometimes succeeds under swig when it shouldn't.
00023 // So, we instead compare against the numeric value itself.
00024 #if UT_ASSERT_LEVEL >= 2
00025 #define HOM_DEBUG
00026 #endif
00027 
00028 #ifdef SWIG
00029 #define SWIGOUT(x) x
00030 #else
00031 #define SWIGOUT(x)
00032 #endif
00033 
00034 #if defined(SWIG) && defined(SWIGPYTHON)
00035 #define SWIGPYTHONOUT(x) x
00036 #else
00037 #define SWIGPYTHONOUT(x)
00038 #endif
00039 
00040 #ifdef SWIG
00041 
00042 //----------------------------------------------------------------------------
00043 
00044 // Since there's no way for a C++ function to have varying return types,
00045 // we need to add special methods and functions that are only known
00046 // to swig.  For python, there's a typemap for PyObject* so that when
00047 // swig encounters a function returning that type it won't try to wrap
00048 // the return value, and will instead send it directly to the interpreter.
00049 // We create a typemap for this type so our code can use it instead of
00050 // PyObject* directly so it's easier to use more than just python in the
00051 // future.
00052 
00053 // The swig code we output directly to the swig wrapper below (using %{%})
00054 // uses InterpreterObject, so we need to say what it is.
00055 %{
00056 #ifdef SWIGPYTHON
00057 typedef PyObject *InterpreterObject;
00058 #endif
00059 %}
00060 
00061 // We need to tell swig what InterpreterObject is so it applies the PyObject*
00062 // typemap properly.
00063 typedef PyObject *InterpreterObject;
00064 
00065 //----------------------------------------------------------------------------
00066 
00067 %{
00068 // These helper functions convert from C++ objects to corresponding
00069 // interpreter objects (PyObject*'s in python).  They're roughly the same
00070 // as swig::from(), but swig::from() does a slow lookup on the name of the
00071 // type.  These functions know the type at compile-time so they're faster.
00072 // Unfortunately, we need to explicitly specialize all the types supported by
00073 // the functions.  Specifically, since HOM_IterableList calls these functions,
00074 // objects that can be inside HOM_IterableList need to be specialized below.
00075 
00076 // The general case is left unimplemented so we get compiler errors if
00077 // we call the function with an unspecialized type.
00078 template <typename T> InterpreterObject
00079 HOMconvertValueForInterpreter(const T &value, int own);
00080 
00081 // These functions specialize the native data types.
00082 template <> InterpreterObject
00083 HOMconvertValueForInterpreter<int>(const int& value, int /*own*/)
00084 { return SWIG_From_int(value); }
00085 
00086 template <> InterpreterObject
00087 HOMconvertValueForInterpreter<float>(const float& value, int /*own*/)
00088 { return SWIG_From_float(value); }
00089 
00090 template <> InterpreterObject
00091 HOMconvertValueForInterpreter<double>(const double& value, int /*own*/)
00092 { return SWIG_From_double(value); }
00093 
00094 template <> InterpreterObject
00095 HOMconvertValueForInterpreter<std::string>(
00096     const std::string& value, int /*own*/)
00097 { return SWIG_From_std_string(value); }
00098 
00099 // These functions specialize base classes to return interpreter instances
00100 // of the proper subclass.
00101 template <> InterpreterObject
00102 HOMconvertValueForInterpreter<HOM_Node*>(HOM_Node *const &node, int own)
00103 {
00104     OBJ_OBJECT_TYPE      objtype;
00105     OP_OpTypeId          optypeid;
00106 
00107     if (!node)
00108         return SWIG_NewPointerObj(node, SWIGTYPE_p_HOM_Node, own);
00109 
00110     optypeid = (OP_OpTypeId)node->opTypeIdAsInt();
00111     switch (optypeid)
00112     {
00113     case OBJ_OPTYPE_ID:
00114         // Because of multiple inheritance, it's extremely important that
00115         // we explicitly cast the pointer to a HOM_ObjNode so we
00116         // pass the right address to SWIG_NewPointerObject, since it takes
00117         // a void*.
00118         objtype = (OBJ_OBJECT_TYPE)node->objTypeAsInt();
00119         if( (objtype & OBJ_DOPNET) != 0 )
00120             return SWIG_NewPointerObj(
00121                 (void*)dynamic_cast<const HOM_DopNetNode* const>(node),
00122                 SWIGTYPE_p_HOM_DopNetNode, own);
00123         else
00124             return SWIG_NewPointerObj(
00125                 (void*)dynamic_cast<const HOM_ObjNode* const>(node),
00126                 SWIGTYPE_p_HOM_ObjNode, own);
00127 
00128     case SOP_OPTYPE_ID:
00129         // Because of multiple inheritance, it's extremely important that
00130         // we explicitly cast the pointer to a HOM_SopNode so we
00131         // pass the right address to SWIG_NewPointerObject, since it takes
00132         // a void*.
00133         return SWIG_NewPointerObj(
00134             (void*)dynamic_cast<const HOM_SopNode* const>(node),
00135             SWIGTYPE_p_HOM_SopNode, own);
00136 
00137     case CHOP_OPTYPE_ID:
00138         // Because of multiple inheritance, it's extremely important that
00139         // we explicitly cast the pointer to a HOM_ChopNode so we
00140         // pass the right address to SWIG_NewPointerObject, since it takes
00141         // a void*.
00142         return SWIG_NewPointerObj(
00143             (void*)dynamic_cast<const HOM_ChopNode* const>(node),
00144             SWIGTYPE_p_HOM_ChopNode, own);
00145 
00146     case COP2_OPTYPE_ID:
00147         // Because of multiple inheritance, it's extremely important that
00148         // we explicitly cast the pointer to a HOM_CopNode so we
00149         // pass the right address to SWIG_NewPointerObject, since it takes
00150         // a void*.
00151         return SWIG_NewPointerObj(
00152             (void*)dynamic_cast<const HOM_CopNode* const>(node),
00153             SWIGTYPE_p_HOM_CopNode, own);
00154 
00155     case DOP_OPTYPE_ID:
00156         // Because of multiple inheritance, it's extremely important that
00157         // we explicitly cast the pointer to a HOM_DopNode so we
00158         // pass the right address to SWIG_NewPointerObject, since it takes
00159         // a void*.
00160         return SWIG_NewPointerObj(
00161             (void*)dynamic_cast<const HOM_DopNode* const>(node),
00162             SWIGTYPE_p_HOM_DopNode, own);
00163 
00164     case POP_OPTYPE_ID:
00165         // Because of multiple inheritance, it's extremely important that
00166         // we explicitly cast the pointer to a HOM_PopNode so we
00167         // pass the right address to SWIG_NewPointerObject, since it takes
00168         // a void*.
00169         return SWIG_NewPointerObj(
00170             (void*)dynamic_cast<const HOM_PopNode* const>(node),
00171             SWIGTYPE_p_HOM_PopNode, own);
00172 
00173     case POPNET_OPTYPE_ID:
00174         // Because of multiple inheritance, it's extremely important that
00175         // we explicitly cast the pointer to a HOM_PopNetNode so we
00176         // pass the right address to SWIG_NewPointerObject, since it takes
00177         // a void*.
00178         return SWIG_NewPointerObj(
00179             (void*)dynamic_cast<const HOM_PopNetNode* const>(node),
00180             SWIGTYPE_p_HOM_PopNetNode, own);
00181 
00182     case SHOP_OPTYPE_ID:
00183         // Because of multiple inheritance, it's extremely important that
00184         // we explicitly cast the pointer to a HOM_ShopNode so we
00185         // pass the right address to SWIG_NewPointerObject, since it takes
00186         // a void*.
00187         return SWIG_NewPointerObj(
00188             (void*)dynamic_cast<const HOM_ShopNode* const>(node),
00189             SWIGTYPE_p_HOM_ShopNode, own);
00190 
00191     case VOPNET_OPTYPE_ID:
00192         // Because of multiple inheritance, it's extremely important that
00193         // we explicitly cast the pointer to a HOM_VopNetNode so we
00194         // pass the right address to SWIG_NewPointerObject, since it takes
00195         // a void*.
00196         return SWIG_NewPointerObj(
00197             (void*)dynamic_cast<const HOM_VopNetNode* const>(node),
00198             SWIGTYPE_p_HOM_VopNetNode, own);
00199 
00200     case ROP_OPTYPE_ID:
00201         // Because of multiple inheritance, it's extremely important that
00202         // we explicitly cast the pointer to a HOM_RopNode so we
00203         // pass the right address to SWIG_NewPointerObject, since it takes
00204         // a void*.
00205         return SWIG_NewPointerObj(
00206             (void*)dynamic_cast<const HOM_RopNode* const>(node),
00207             SWIGTYPE_p_HOM_RopNode, own);
00208 
00209     default:
00210         break;
00211     };
00212 
00213     return SWIG_NewPointerObj(node, SWIGTYPE_p_HOM_Node, own);
00214 }
00215 
00216 template <> InterpreterObject
00217 HOMconvertValueForInterpreter<HOM_NodeType*>(
00218     HOM_NodeType *const &nodetype, int own)
00219 {
00220     OP_OpTypeId          optypeid;
00221         
00222     if (!nodetype)
00223         return SWIG_NewPointerObj(nodetype, SWIGTYPE_p_HOM_NodeType, own);
00224 
00225     if( !nodetype->managerFlag() )
00226     {
00227         optypeid = (OP_OpTypeId)nodetype->opTypeIdAsInt();
00228         switch (optypeid)
00229         {
00230         case SOP_OPTYPE_ID:
00231             // Because of multiple inheritance, it's extremely important that
00232             // we explicitly cast the pointer to a HOM_SopNodeType so we
00233             // pass the right address to SWIG_NewPointerObject, since it takes
00234             // a void*.
00235             return SWIG_NewPointerObj(
00236                 (void*)dynamic_cast<const HOM_SopNodeType* const>(nodetype),
00237                 SWIGTYPE_p_HOM_SopNodeType, own);
00238 
00239         case SHOP_OPTYPE_ID:
00240             // Because of multiple inheritance, it's extremely important that
00241             // we explicitly cast the pointer to a HOM_ShopNodeType so we
00242             // pass the right address to SWIG_NewPointerObject, since it takes
00243             // a void*.
00244             return SWIG_NewPointerObj(
00245                 (void*)dynamic_cast<const HOM_ShopNodeType* const>(nodetype),
00246                 SWIGTYPE_p_HOM_ShopNodeType, own);
00247 
00248         default:
00249             break;
00250         }
00251     }
00252 
00253     return SWIG_NewPointerObj(nodetype, SWIGTYPE_p_HOM_NodeType, own);
00254 }
00255 
00256 template <> InterpreterObject
00257 HOMconvertValueForInterpreter<HOM_BaseKeyframe*>(
00258     HOM_BaseKeyframe *const &keyframe, int own)
00259 {
00260     if (!keyframe)
00261         return SWIG_NewPointerObj(keyframe, SWIGTYPE_p_HOM_BaseKeyframe, own);
00262 
00263     if (keyframe->evaluatedType() == HOM_parmData::Float)
00264     {
00265         // Because of multiple inheritance, it's extremely important that
00266         // we explicitly cast the pointer to a HOM_Keyframe so we
00267         // pass the right address to SWIG_NewPointerObject, since it takes
00268         // a void*.
00269         return SWIG_NewPointerObj(
00270             (void*)dynamic_cast<const HOM_Keyframe* const>(keyframe),
00271             SWIGTYPE_p_HOM_Keyframe, own);
00272     };
00273 
00274     return SWIG_NewPointerObj(keyframe, SWIGTYPE_p_HOM_BaseKeyframe, own);
00275 }
00276 
00277 template <> InterpreterObject
00278 HOMconvertValueForInterpreter<HOM_Prim*>(HOM_Prim *const &prim, int own)
00279 {
00280     if (!prim)
00281         return SWIG_NewPointerObj(prim, SWIGTYPE_p_HOM_Prim, own);
00282 
00283     // Because of multiple inheritance, it's extremely important that
00284     // we explicitly cast the pointer to the right HOM type so we
00285     // pass the right address to SWIG_NewPointerObject, since it takes
00286     // a void*.
00287 
00288     switch (prim->type().id())
00289     {
00290     case HOM_primType::Polygon_Id:
00291         return SWIG_NewPointerObj(
00292             (void*)dynamic_cast<const HOM_Polygon* const>(prim),
00293             SWIGTYPE_p_HOM_Polygon, own);
00294 
00295     case HOM_primType::NURBSCurve_Id:
00296     case HOM_primType::BezierCurve_Id:
00297         return SWIG_NewPointerObj(
00298             (void*)dynamic_cast<const HOM_Face* const>(prim),
00299             SWIGTYPE_p_HOM_Face, own);
00300 
00301     case HOM_primType::Mesh_Id:
00302     case HOM_primType::NURBSSurface_Id:
00303     case HOM_primType::BezierSurface_Id:
00304         return SWIG_NewPointerObj(
00305             (void*)dynamic_cast<const HOM_Surface* const>(prim),
00306             SWIGTYPE_p_HOM_Surface, own);
00307 
00308     case HOM_primType::Circle_Id:
00309     case HOM_primType::Sphere_Id:
00310     case HOM_primType::Tube_Id:
00311         return SWIG_NewPointerObj(
00312             (void*)dynamic_cast<const HOM_Quadric* const>(prim),
00313             SWIGTYPE_p_HOM_Quadric, own);
00314 
00315     case HOM_primType::Volume_Id:
00316         return SWIG_NewPointerObj(
00317             (void*)dynamic_cast<const HOM_Volume* const>(prim),
00318             SWIGTYPE_p_HOM_Volume, own);
00319 
00320     // TODO: Support more primitive types.
00321     }
00322 
00323     return SWIG_NewPointerObj(prim, SWIGTYPE_p_HOM_Prim, own);
00324 }
00325 
00326 template <> InterpreterObject
00327 HOMconvertValueForInterpreter<HOM_ParmTemplate*>(
00328     HOM_ParmTemplate *const &parm_template, int own)
00329 {
00330     if (!parm_template)
00331         return SWIG_NewPointerObj(
00332             parm_template, SWIGTYPE_p_HOM_ParmTemplate, own);
00333 
00334     // Because of multiple inheritance, it's extremely important that we
00335     // explicitly cast to a pointer to the subclass so we pass the right
00336     // address to SWIG_NewPointerObject, since it takes a void*.
00337     switch (parm_template->type().id())
00338     {
00339     case HOM_parmTemplateType::Int_Id:
00340         return SWIG_NewPointerObj(
00341             (void*)dynamic_cast<const HOM_IntParmTemplate* const>(
00342                 parm_template),
00343             SWIGTYPE_p_HOM_IntParmTemplate, own);
00344 
00345     case HOM_parmTemplateType::Float_Id:
00346         return SWIG_NewPointerObj(
00347             (void*)dynamic_cast<const HOM_FloatParmTemplate* const>(
00348                 parm_template),
00349             SWIGTYPE_p_HOM_FloatParmTemplate, own);
00350 
00351     case HOM_parmTemplateType::String_Id:
00352         return SWIG_NewPointerObj(
00353             (void*)dynamic_cast<const HOM_StringParmTemplate* const>(
00354                 parm_template),
00355             SWIGTYPE_p_HOM_StringParmTemplate, own);
00356 
00357     case HOM_parmTemplateType::Toggle_Id:
00358         return SWIG_NewPointerObj(
00359             (void*)dynamic_cast<const HOM_ToggleParmTemplate* const>(
00360                 parm_template),
00361             SWIGTYPE_p_HOM_ToggleParmTemplate, own);
00362 
00363     case HOM_parmTemplateType::Menu_Id:
00364         return SWIG_NewPointerObj(
00365             (void*)dynamic_cast<const HOM_MenuParmTemplate* const>(
00366                 parm_template),
00367             SWIGTYPE_p_HOM_MenuParmTemplate, own);
00368 
00369     case HOM_parmTemplateType::Button_Id:
00370         return SWIG_NewPointerObj(
00371             (void*)dynamic_cast<const HOM_ButtonParmTemplate* const>(
00372                 parm_template),
00373             SWIGTYPE_p_HOM_ButtonParmTemplate, own);
00374 
00375     case HOM_parmTemplateType::Label_Id:
00376         return SWIG_NewPointerObj(
00377             (void*)dynamic_cast<const HOM_LabelParmTemplate* const>(
00378                 parm_template),
00379             SWIGTYPE_p_HOM_LabelParmTemplate, own);
00380 
00381     case HOM_parmTemplateType::Separator_Id:
00382         return SWIG_NewPointerObj(
00383             (void*)dynamic_cast<const HOM_SeparatorParmTemplate* const>(
00384                 parm_template),
00385             SWIGTYPE_p_HOM_SeparatorParmTemplate, own);
00386 
00387     case HOM_parmTemplateType::FolderSet_Id:
00388         return SWIG_NewPointerObj(
00389             (void*)dynamic_cast<const HOM_FolderSetParmTemplate* const>(
00390                 parm_template),
00391             SWIGTYPE_p_HOM_FolderSetParmTemplate, own);
00392 
00393     case HOM_parmTemplateType::Ramp_Id:
00394         return SWIG_NewPointerObj(
00395             (void*)dynamic_cast<const HOM_RampParmTemplate* const>(
00396                 parm_template),
00397             SWIGTYPE_p_HOM_RampParmTemplate, own);
00398 
00399     case HOM_parmTemplateType::MultiParm_Id:
00400         return SWIG_NewPointerObj(
00401             (void*)dynamic_cast<const HOM_MultiParmTemplate* const>(
00402                 parm_template),
00403             SWIGTYPE_p_HOM_MultiParmTemplate, own);
00404     };
00405 
00406     UT_ASSERT(!"Unknown parm template type");
00407     return SWIG_NewPointerObj(parm_template, SWIGTYPE_p_HOM_ParmTemplate, own);
00408 }
00409 
00410 template <> InterpreterObject
00411 HOMconvertValueForInterpreter<HOM_PaneTab*>(
00412     HOM_PaneTab *const &pane_tab, int own)
00413 {
00414     if (!pane_tab)
00415         return SWIG_NewPointerObj(pane_tab, SWIGTYPE_p_HOM_PaneTab, own);
00416 
00417     // Because of multiple inheritance, it's extremely important that
00418     // we explicitly cast the pointer to the HOM type so we pass the right
00419     // address to SWIG_NewPointerObject, since it takes a void*.
00420 
00421     switch (pane_tab->type().id())
00422     {
00423     case HOM_paneTabType::ContextViewer_Id:
00424         return SWIG_NewPointerObj(
00425             (void*)dynamic_cast<const HOM_ContextViewer* const>(pane_tab),
00426             SWIGTYPE_p_HOM_ContextViewer, own);
00427 
00428     case HOM_paneTabType::SceneViewer_Id:
00429         return SWIG_NewPointerObj(
00430             (void*)dynamic_cast<const HOM_SceneViewer* const>(pane_tab),
00431             SWIGTYPE_p_HOM_SceneViewer, own);
00432 
00433     case HOM_paneTabType::CompositorViewer_Id:
00434         return SWIG_NewPointerObj(
00435             (void*)dynamic_cast<const HOM_CompositorViewer* const>(pane_tab),
00436             SWIGTYPE_p_HOM_CompositorViewer, own);
00437 
00438     case HOM_paneTabType::ParticleViewer_Id:
00439         return SWIG_NewPointerObj(
00440             (void*)dynamic_cast<const HOM_ParticleViewer* const>(pane_tab),
00441             SWIGTYPE_p_HOM_ParticleViewer, own);
00442 
00443     case HOM_paneTabType::NetworkEditor_Id:
00444         return SWIG_NewPointerObj(
00445             (void*)dynamic_cast<const HOM_NetworkEditor* const>(pane_tab),
00446             SWIGTYPE_p_HOM_NetworkEditor, own);
00447             
00448     case HOM_paneTabType::HelpBrowser_Id:
00449         return SWIG_NewPointerObj(
00450             (void*)dynamic_cast<const HOM_HelpBrowser* const>(pane_tab),
00451             SWIGTYPE_p_HOM_HelpBrowser, own);
00452 
00453     case HOM_paneTabType::IPRViewer_Id:
00454         return SWIG_NewPointerObj(
00455             (void*)dynamic_cast<const HOM_IPRViewer* const>(pane_tab),
00456             SWIGTYPE_p_HOM_IPRViewer, own);
00457 
00458     case HOM_paneTabType::ChannelViewer_Id:
00459     case HOM_paneTabType::OutputViewer_Id:
00460     case HOM_paneTabType::ShaderViewer_Id:
00461     case HOM_paneTabType::Parm_Id:
00462     case HOM_paneTabType::DetailsView_Id:
00463     case HOM_paneTabType::TreeView_Id:
00464         return SWIG_NewPointerObj(
00465             (void*)dynamic_cast<const HOM_PathBasedPaneTab* const>(pane_tab),
00466             SWIGTYPE_p_HOM_PathBasedPaneTab, own);
00467 
00468     case HOM_paneTabType::ChannelEditor_Id:
00469     case HOM_paneTabType::ChannelList_Id:
00470     case HOM_paneTabType::Textport_Id:
00471     case HOM_paneTabType::PythonShell_Id:
00472     case HOM_paneTabType::HandleList_Id:
00473     case HOM_paneTabType::BundleList_Id:
00474     case HOM_paneTabType::TakeList_Id:
00475     case HOM_paneTabType::ParmSpreadsheet_Id:
00476     case HOM_paneTabType::LightLinker_Id:
00477     case HOM_paneTabType::MaterialPalette_Id:
00478         return SWIG_NewPointerObj(pane_tab, SWIGTYPE_p_HOM_PaneTab, own);
00479     };
00480 
00481     UT_ASSERT(!"Unknown pane tab type");
00482     return SWIG_NewPointerObj(pane_tab, SWIGTYPE_p_HOM_PaneTab, own);
00483 }
00484 
00485 template <> InterpreterObject
00486 HOMconvertValueForInterpreter<
00487     std::vector<HOM_ElemPtr<HOM_NodeConnection> >*>(
00488         std::vector<HOM_ElemPtr<HOM_NodeConnection> > *const &list,
00489         int own)
00490 {
00491     return swig::from(*list);
00492 }
00493 
00494 template <> InterpreterObject
00495 HOMconvertValueForInterpreter<HOM_DopData*>(HOM_DopData *const &data, int own)
00496 {
00497     const HOM_DopObject *const dop_object =
00498         dynamic_cast<const HOM_DopObject *const>(data);
00499     if (dop_object)
00500         return SWIG_NewPointerObj(
00501             (void *)dop_object, SWIGTYPE_p_HOM_DopObject, own);
00502 
00503     const HOM_DopRelationship *const dop_relationship =
00504         dynamic_cast<const HOM_DopRelationship *const>(data);
00505     if (dop_relationship)
00506         return SWIG_NewPointerObj(
00507             (void *)dop_relationship, SWIGTYPE_p_HOM_DopRelationship, own);
00508 
00509     return SWIG_NewPointerObj(data, SWIGTYPE_p_HOM_DopData, own);
00510 }
00511 
00512 // These functions specialize pointers to other classes.  If a class is
00513 // used inside HOM_IterableList or HOM_ElemPtr, it must be listed here.
00514 #define HOM_PROVIDE_SWIG_LOOKUP(type) \
00515     template <> InterpreterObject HOMconvertValueForInterpreter<type*>( \
00516         type* const& value, int own) \
00517     { return SWIG_NewPointerObj(SWIG_as_voidptr(value), \
00518             SWIGTYPE_p_ ## type, own); }
00519 
00520 HOM_PROVIDE_SWIG_LOOKUP(HOM_Attrib)
00521 HOM_PROVIDE_SWIG_LOOKUP(HOM_Desktop)
00522 HOM_PROVIDE_SWIG_LOOKUP(HOM_Dialog)
00523 HOM_PROVIDE_SWIG_LOOKUP(HOM_DopRecord)
00524 HOM_PROVIDE_SWIG_LOOKUP(HOM_FloatingPanel)
00525 HOM_PROVIDE_SWIG_LOOKUP(HOM_Gallery)
00526 HOM_PROVIDE_SWIG_LOOKUP(HOM_GalleryEntry)
00527 HOM_PROVIDE_SWIG_LOOKUP(HOM_GeometrySelection)
00528 HOM_PROVIDE_SWIG_LOOKUP(HOM_GeometryViewport)
00529 HOM_PROVIDE_SWIG_LOOKUP(HOM_HDADefinition)
00530 HOM_PROVIDE_SWIG_LOOKUP(HOM_HDASection)
00531 HOM_PROVIDE_SWIG_LOOKUP(HOM_Matrix3)
00532 HOM_PROVIDE_SWIG_LOOKUP(HOM_Matrix4)
00533 HOM_PROVIDE_SWIG_LOOKUP(HOM_NetworkBox)
00534 HOM_PROVIDE_SWIG_LOOKUP(HOM_NodeBundle)
00535 HOM_PROVIDE_SWIG_LOOKUP(HOM_NodeConnection)
00536 HOM_PROVIDE_SWIG_LOOKUP(HOM_NodeGroup)
00537 HOM_PROVIDE_SWIG_LOOKUP(HOM_Pane)
00538 HOM_PROVIDE_SWIG_LOOKUP(HOM_Parm)
00539 HOM_PROVIDE_SWIG_LOOKUP(HOM_ParmTuple)
00540 HOM_PROVIDE_SWIG_LOOKUP(HOM_Point)
00541 HOM_PROVIDE_SWIG_LOOKUP(HOM_Quaternion)
00542 HOM_PROVIDE_SWIG_LOOKUP(HOM_Ramp)
00543 HOM_PROVIDE_SWIG_LOOKUP(HOM_Selector)
00544 HOM_PROVIDE_SWIG_LOOKUP(HOM_Shelf)
00545 HOM_PROVIDE_SWIG_LOOKUP(HOM_ShelfSet)
00546 HOM_PROVIDE_SWIG_LOOKUP(HOM_StickyNote)
00547 HOM_PROVIDE_SWIG_LOOKUP(HOM_SubnetIndirectInput)
00548 HOM_PROVIDE_SWIG_LOOKUP(HOM_Tool)
00549 HOM_PROVIDE_SWIG_LOOKUP(HOM_Track)
00550 HOM_PROVIDE_SWIG_LOOKUP(HOM_Vector2)
00551 HOM_PROVIDE_SWIG_LOOKUP(HOM_Vector3)
00552 HOM_PROVIDE_SWIG_LOOKUP(HOM_Vector4)
00553 HOM_PROVIDE_SWIG_LOOKUP(HOM_Vertex)
00554 HOM_PROVIDE_SWIG_LOOKUP(HOM_VexContext)
00555 HOM_PROVIDE_SWIG_LOOKUP(HOM_ViewerState)
00556 
00557 %}
00558 
00559 //----------------------------------------------------------------------------
00560 
00561 // We create typemaps for base classes that appear as return types to make
00562 // sure swig instances the proper subclasses in the interpreter.
00563 %typemap(out) HOM_Prim* {
00564     $result = HOMconvertValueForInterpreter($1, $owner);
00565 }
00566 
00567 %typemap(out) HOM_Node* {
00568     $result = HOMconvertValueForInterpreter($1, $owner);
00569 }
00570 
00571 %typemap(out) HOM_NodeType* {
00572     $result = HOMconvertValueForInterpreter($1, $owner);
00573 }
00574 
00575 %typemap(out) HOM_BaseKeyframe* {
00576     $result = HOMconvertValueForInterpreter($1, $owner);
00577 }
00578 
00579 %typemap(out) HOM_ParmTemplate* {
00580     $result = HOMconvertValueForInterpreter($1, $owner);
00581 }
00582 
00583 %typemap(out) HOM_Pane* {
00584     $result = HOMconvertValueForInterpreter($1, $owner);
00585 }
00586 
00587 %typemap(out) HOM_PaneTab* {
00588     $result = HOMconvertValueForInterpreter($1, $owner);
00589 }
00590 
00591 %typemap(out) HOM_DopData* {
00592     $result = HOMconvertValueForInterpreter($1, $owner);
00593 }
00594 
00595 %typemap(out) std::vector<HOM_ElemPtr<HOM_NodeConnection> > * {
00596     $result = HOMconvertValueForInterpreter($1, $owner);
00597 }
00598 
00599 //----------------------------------------------------------------------------
00600 
00601 // These typemaps convert HOM exceptions into corresponding python standard
00602 // exceptions.
00603 %typemap(throws) HOM_TypeError %{
00604     SWIG_exception_fail(SWIG_TypeError, $1.instanceMessage().c_str());
00605 %}
00606 
00607 %typemap(throws) HOM_ValueError %{
00608     SWIG_exception_fail(SWIG_ValueError, $1.instanceMessage().c_str());
00609 %}
00610 
00611 #ifdef SWIGPYTHON
00612 %typemap(throws) HOM_SystemExit %{
00613     PyErr_SetObject(PyExc_SystemExit, SWIG_From_int($1.code()));
00614     SWIG_fail;
00615 %}
00616 #endif
00617 
00618 //----------------------------------------------------------------------------
00619 
00620 // This typemap lets you declare a boost::any parameter and swig will convert
00621 // the interpreter (Python) object to a boost::any that wraps the C++ data
00622 // type.
00623 %typemap(in) boost::any {
00624     // Note that if we can't convert to a boost::any, we leave the boost::any
00625     // as empty (i.e. its empty() method returns true).
00626     HOMinterpreterObjectToBoostAny($input, $1);
00627 }
00628 
00629 %{
00630 
00631 //----------------------------------------------------------------------------
00632 
00633 // This helper function takes an interpreter (Python) object and converts it
00634 // into a boost::any object.  It returns whether or not the conversion was
00635 // possible, and leaves the boost::any unchanged if a conversion wasn't
00636 // possible.
00637 bool
00638 HOMinterpreterObjectToBoostAny(InterpreterObject input, boost::any &result)
00639 {
00640 #ifdef SWIGPYTHON
00641     if (input == Py_None)
00642     {
00643         result = (void *)NULL;
00644         return true;
00645     }
00646 
00647     // SWIG_AsVal_bool is too permissive, and treats thinks that an integer
00648     // is a bool.  So, we explicitly check against True and False.
00649     if (input == Py_True)
00650     {
00651         result = true;
00652         return true;
00653     }
00654 
00655     if (input == Py_False)
00656     {
00657         result = false;
00658         return true;
00659     }
00660 #endif
00661 
00662     int int_result;
00663     if (SWIG_IsOK(SWIG_AsVal_int(input, &int_result)))
00664     {
00665         result = int_result;
00666         return true;
00667     }
00668 
00669     double double_result;
00670     if (SWIG_IsOK(SWIG_AsVal_double(input, &double_result)))
00671     {
00672         result = double_result;
00673         return true;
00674     }
00675 
00676     std::string string_result;
00677     if (SWIG_IsOK(SWIG_AsVal_std_string(input, &string_result)))
00678     {
00679         result = string_result;
00680         return true;
00681     }
00682 
00683     std::vector<int> *int_vector_ptr = NULL;
00684     if (SWIG_IsOK(swig::asptr(input, (std::vector<int> **)NULL)) &&
00685         SWIG_IsOK(swig::asptr(input, &int_vector_ptr)))
00686     {
00687         result = *int_vector_ptr;
00688         delete int_vector_ptr;
00689         return true;
00690     }
00691 
00692     std::vector<double> *double_vector_ptr = NULL;
00693     if (SWIG_IsOK(swig::asptr(input, (std::vector<double> **)NULL)) &&
00694         SWIG_IsOK(swig::asptr(input, &double_vector_ptr)))
00695     {
00696         result = *double_vector_ptr;
00697         delete double_vector_ptr;
00698         return true;
00699     }
00700 
00701     return false;
00702 }
00703 
00704 // This helper function takes a variable wrapped inside a boost::any object
00705 // and creates a new instance of the corresponding InterpreterObject.
00706 static InterpreterObject
00707 HOMboostAnyToInterpreterObject(const boost::any &result)
00708 {
00709     if (result.empty())
00710         return SWIG_Py_Void();
00711 
00712     if (result.type() == typeid(int))
00713         return SWIG_From_int(boost::any_cast<int>(result));
00714 
00715     if (result.type() == typeid(float))
00716         return SWIG_From_float(boost::any_cast<float>(result));
00717 
00718     if (result.type() == typeid(std::string))
00719         return SWIG_From_std_string(boost::any_cast<std::string>(result));
00720 
00721     if (result.type() == typeid(std::vector<float>))
00722         return swig::from(boost::any_cast<std::vector<float> >(result));
00723 
00724     if (result.type() == typeid(std::vector<std::vector<float> >))
00725         return swig::from(
00726             boost::any_cast<std::vector<std::vector<float> > >(result));
00727 
00728     UT_ASSERT(!"Unknown data type");
00729     return Py_None;
00730 }
00731 
00732 static InterpreterObject
00733 HOMoptionEntryToInterpreterObject(const UT_OptionEntry &option_entry)
00734 {
00735     InterpreterObject result = NULL;
00736 
00737     switch (option_entry.getType())
00738     {
00739         case UT_OPTION_INT:
00740             return SWIG_From_int(
00741                 ((const UT_OptionInt &)option_entry).getValue());
00742 
00743         case UT_OPTION_BOOL:
00744             return SWIG_From_bool(
00745                 ((const UT_OptionBool &)option_entry).getValue());
00746 
00747         case UT_OPTION_FPREAL:
00748             return SWIG_From_float(
00749                 ((const UT_OptionFpreal &)option_entry).getValue());
00750 
00751         case UT_OPTION_STRING:
00752         case UT_OPTION_STRINGRAW:
00753             return SWIG_From_std_string(
00754                  ((const UT_OptionString &)option_entry).getValue().
00755                      toStdString());
00756 
00757         case UT_OPTION_VECTOR2:
00758             return HOMconvertValueForInterpreter(
00759                  new HOM_Vector2(
00760                      ((const UT_OptionVector2 &)option_entry).getValue()),
00761                  SWIG_POINTER_OWN);
00762 
00763         case UT_OPTION_VECTOR3:
00764             return HOMconvertValueForInterpreter(
00765                  new HOM_Vector3(
00766                     ((const UT_OptionVector3 &)option_entry).getValue()),
00767                  SWIG_POINTER_OWN);
00768 
00769         case UT_OPTION_VECTOR4:
00770             return HOMconvertValueForInterpreter(
00771                  new HOM_Vector4(
00772                     ((const UT_OptionVector4 &)option_entry).getValue()),
00773                  SWIG_POINTER_OWN);
00774 
00775         case UT_OPTION_QUATERNION:
00776             return HOMconvertValueForInterpreter(
00777                  new HOM_Quaternion(
00778                      ((const UT_OptionQuaternion &)option_entry).getValue()),
00779                  SWIG_POINTER_OWN);
00780 
00781         case UT_OPTION_MATRIX3:
00782             return HOMconvertValueForInterpreter(
00783                  new HOM_Matrix3(UT_DMatrix3(
00784                     ((const UT_OptionMatrix3 &)option_entry).getValue())),
00785                  SWIG_POINTER_OWN);
00786 
00787         case UT_OPTION_MATRIX4:
00788             return HOMconvertValueForInterpreter(
00789                  new HOM_Matrix4(UT_DMatrix4(
00790                     ((const UT_OptionMatrix4 &)option_entry).getValue())),
00791                  SWIG_POINTER_OWN);
00792 
00793         case UT_OPTION_UV:
00794             return HOMconvertValueForInterpreter(
00795                  new HOM_Vector2(
00796                     ((const UT_OptionUV &)option_entry).getValue()),
00797                  SWIG_POINTER_OWN);
00798 
00799         case UT_OPTION_UVW:
00800             return HOMconvertValueForInterpreter(
00801                  new HOM_Vector3(
00802                      ((const UT_OptionUVW &)option_entry).getValue()),
00803                  SWIG_POINTER_OWN);
00804 
00805         case UT_OPTION_INVALID:
00806         case UT_OPTION_NUM_TYPES:
00807             // Just exit the switch with no result.
00808             break;
00809     }
00810 
00811     return result ? result : Py_None;
00812 }
00813 
00814 #ifdef SWIGPYTHON
00815 static InterpreterObject
00816 HOMoptionsToInterpreterObject(UT_Options &options)
00817 {
00818     InterpreterObject result = PyDict_New();
00819 
00820     for (int i=0; i < options.getNumOptions(); ++i)
00821     {
00822         // The Python dictionary object will increment the reference count
00823         // on the value, so we decrement it since we just allocated it.
00824         InterpreterObject value = HOMoptionEntryToInterpreterObject(
00825             *options.getOptionEntry(i));
00826         PyDict_SetItemString(result, options.getOptionName(i), value);
00827         Py_DECREF(value);
00828     }
00829 
00830     return result;
00831 }
00832 #endif
00833 
00834 //----------------------------------------------------------------------------
00835 
00836 // These helper functions are used to implement the attrib() methods of
00837 // Points, Prims, and Vertices.  We need to do extra work for these methods
00838 // because the return type can vary.
00839 template <typename T>
00840 InterpreterObject
00841 HOMattribValue(T &geo_element, HOM_Attrib &hom_attrib)
00842     throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error)
00843 {
00844     InterpreterObject result = NULL;
00845     switch (hom_attrib.dataType().id())
00846     {
00847     case HOM_attribData::Int_Id:
00848         if (hom_attrib.size() == 1)
00849             result = SWIG_From_int(geo_element.intAttribValue(hom_attrib));
00850         else
00851             result = swig::from(geo_element.intListAttribValue(hom_attrib));
00852         break;
00853 
00854     case HOM_attribData::Float_Id:
00855         if (hom_attrib.size() == 1)
00856             result = SWIG_From_float(geo_element.floatAttribValue(hom_attrib));
00857         else
00858             result = swig::from(geo_element.floatListAttribValue(hom_attrib));
00859         break;
00860 
00861     case HOM_attribData::String_Id:
00862         result = SWIG_From_std_string(
00863                                     geo_element.stringAttribValue(hom_attrib));
00864         break;
00865     }
00866     UT_ASSERT(result);
00867     return result;
00868 }
00869 
00870 
00871 // Note that the caller is responsible for deleting the HOM_Attrib object
00872 // that's returned.
00873 template <typename T> HOM_Attrib*
00874 HOMlookUpAttrib(T &geo_element, const char *name)
00875     throw(HOM_ObjectWasDeleted, HOM_Error);
00876 
00877 template <> HOM_Attrib*
00878 HOMlookUpAttrib(HOM_Point &point, const char *name)
00879     throw(HOM_ObjectWasDeleted, HOM_Error)
00880 { return HOMdel(point.geometry())->findPointAttrib(name); }
00881 
00882 template <> HOM_Attrib*
00883 HOMlookUpAttrib(HOM_Prim &prim, const char *name)
00884     throw(HOM_ObjectWasDeleted, HOM_Error)
00885 { return HOMdel(prim.geometry())->findPrimAttrib(name); }
00886 
00887 template <> HOM_Attrib*
00888 HOMlookUpAttrib(HOM_Vertex &vertex, const char *name)
00889     throw(HOM_ObjectWasDeleted, HOM_Error)
00890 { return HOMdel(vertex.geometry())->findVertexAttrib(name); }
00891 
00892 template <> HOM_Attrib*
00893 HOMlookUpAttrib(HOM_Geometry &geometry, const char *name)
00894     throw(HOM_ObjectWasDeleted, HOM_Error)
00895 { return geometry.findGlobalAttrib(name); }
00896 
00897 template <typename T>
00898 InterpreterObject
00899 HOMattribValue(T &geo_element, const char *name)
00900     throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error)
00901 {
00902     HOM_Attrib *hom_attrib = HOMlookUpAttrib(geo_element, name);
00903     if (!hom_attrib)
00904         throw HOM_OperationFailed();
00905 
00906     InterpreterObject result = HOMattribValue(geo_element, *hom_attrib);
00907     delete hom_attrib;
00908     return result;
00909 }
00910 %}
00911 
00912 //----------------------------------------------------------------------------
00913 
00914 %{
00915 // These helper functions are used to implement parm evaluation.
00916 static InterpreterObject
00917 HOMevalParm(HOM_Parm &parm) throw(HOM_ObjectWasDeleted, HOM_Error)
00918 {
00919     switch (parm.parmDataTypeEnumId())
00920     {
00921     case HOM_parmData::Int_Id:
00922         return SWIG_From_int(parm.evalAsInt());
00923     case HOM_parmData::Float_Id:
00924         return SWIG_From_float(parm.evalAsFloat());
00925     case HOM_parmData::String_Id:
00926         return SWIG_From_std_string(parm.evalAsString());
00927     case HOM_parmData::Ramp_Id:
00928         return SWIG_NewPointerObj(
00929             (void*)parm.evalAsRamp(), SWIGTYPE_p_HOM_Ramp, SWIG_POINTER_OWN);
00930     }
00931 
00932     UT_ASSERT(!"Unknown parm data type");
00933     return Py_None;
00934 }
00935 
00936 static InterpreterObject
00937 HOMevalParmAtFrame(HOM_Parm &parm, float frame)
00938     throw(HOM_ObjectWasDeleted, HOM_Error)
00939 {
00940     switch (parm.parmDataTypeEnumId())
00941     {
00942     case HOM_parmData::Int_Id:
00943         return SWIG_From_int(parm.evalAsIntAtFrame(frame));
00944     case HOM_parmData::Float_Id:
00945         return SWIG_From_float(parm.evalAsFloatAtFrame(frame));
00946     case HOM_parmData::String_Id:
00947         return SWIG_From_std_string(parm.evalAsStringAtFrame(frame));
00948     case HOM_parmData::Ramp_Id:
00949         return SWIG_NewPointerObj(
00950             (void*)parm.evalAsRampAtFrame(frame),
00951             SWIGTYPE_p_HOM_Ramp, SWIG_POINTER_OWN);
00952     }
00953 
00954     UT_ASSERT(!"Unknown parm data type");
00955     return Py_None;
00956 }
00957 
00958 static InterpreterObject
00959 HOMevalParmTuple(HOM_ParmTuple &parm_tuple)
00960     throw(HOM_ObjectWasDeleted, HOM_Error)
00961 {
00962     switch (parm_tuple.parmDataTypeEnumId())
00963     {
00964     case HOM_parmData::Int_Id:
00965         return swig::from(parm_tuple.evalAsInts());
00966     case HOM_parmData::Float_Id:
00967         return swig::from(parm_tuple.evalAsFloats());
00968     case HOM_parmData::String_Id:
00969         return swig::from(parm_tuple.evalAsStrings());
00970     case HOM_parmData::Ramp_Id:
00971         return swig::from(parm_tuple.evalAsRamps());
00972     }
00973 
00974     UT_ASSERT(!"Unknown parm data type");
00975     return Py_None;
00976 }
00977 
00978 static InterpreterObject
00979 HOMevalParmTupleAtFrame(HOM_ParmTuple &parm_tuple, float frame)
00980     throw(HOM_ObjectWasDeleted, HOM_Error)
00981 {
00982     switch (parm_tuple.parmDataTypeEnumId())
00983     {
00984     case HOM_parmData::Int_Id:
00985         return swig::from(parm_tuple.evalAsIntsAtFrame(frame));
00986     case HOM_parmData::Float_Id:
00987         return swig::from(parm_tuple.evalAsFloatsAtFrame(frame));
00988     case HOM_parmData::String_Id:
00989         return swig::from(parm_tuple.evalAsStringsAtFrame(frame));
00990     case HOM_parmData::Ramp_Id:
00991         return swig::from(parm_tuple.evalAsRampsAtFrame(frame));
00992     }
00993 
00994     UT_ASSERT(!"Unknown parm data type");
00995     return Py_None;
00996 }
00997 
00998 //----------------------------------------------------------------------------
00999 
01000 %}
01001 #endif
01002 
01003 #endif