HOM/HOM_Module.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Side Effects Software Inc
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * COMMENTS:
 *     This class is not directly wrapped by swig.  However, when creating
 *     the swig wrapper modules we wrap each of the methods of this class
 *     in functions.  This way, the methods of this class appear as the
 *     top-level parts of the hou module.
 */

#ifndef __HOM_Module_h__
#define __HOM_Module_h__

#include "HOM_API.h"
#include "HOM_Defines.h"
#include "HOM_Errors.h"
#include "HOM_ElemPtr.h"
#include <PY/PY_InterpreterAutoLock.h>
#include <UT/UT_Lock.h>
#include <UT/UT_NonCopyable.h>
#include <UT/UT_TaskLock.h>
#include <UT/UT_Thread.h>
#include <typeinfo>
#include <string>
#include <vector>
#include <map>
#include <boost/shared_ptr.hpp>
#include <boost/any.hpp>

class OP_Node;
class UI_Value;
class HOM_EnumValue;
class HOM_FloatParmTemplate;
class HOM_HDAModule;
class HOM_HDAOptions;
class HOM_IntParmTemplate;
class HOM_InterruptableOperation;
class HOM_Keyframe;
class HOM_StringKeyframe;
class HOM_NodeType;
class HOM_NodeTypeCategory;
class HOM_Node;
class HOM_NodeBundle;
class HOM_Parm;
class HOM_ParmTuple;
class HOM_EvaluationCache;
class HOM_ParmTemplate;
class HOM_StringParmTemplate;
class HOM_ToggleParmTemplate;
class HOM_MenuParmTemplate;
class HOM_ButtonParmTemplate;
class HOM_LabelParmTemplate;
class HOM_SeparatorParmTemplate;
class HOM_FolderSetParmTemplate;
class HOM_FolderParmTemplate;
class HOM_RampParmTemplate;
class HOM_ParmTemplateGroup;
class HOM_VexContext;
class HOM_galleries;
class HOM_playbar;
class HOM_hda;
class HOM_hipFile;
class HOM_hmath;
class HOM_dop;
class HOM_shelves;
class HOM_ui;
class HOM_audio;

#define HOM_SESSION_MODULE_NAME         "hou.session"
#define HOM_SESSION_MODULE_CPIO_NAME    "." HOM_SESSION_MODULE_NAME

// Use this function to access the HOM module from C++ in Houdini.  This
// is equivalent to writing "hou" in python.  It will only throw an exception
// if the python module could not be imported, which should not happen.
class HOM_Module;
HOM_API HOM_Module& HOM() throw(HOM_Error);


class HOM_API HOM_Module
{
public:
    virtual ~HOM_Module() {}

    virtual std::vector<std::string> _getArgumentAutoComplete(
            const char *method_name, const char *arguments)
        throw(HOM_Error) = 0;

    // This method is called by the expression editor to force autocompletion
    // to be relative to the node containing the expression.  It is not
    // wrapped by swig.
    virtual void setRelativeNodeForAutoComplete(OP_Node *node) = 0;


    virtual HOM_ui& ui() throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual HOM_audio& audio() throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual bool isUIAvailable() throw(HOM_Error) = 0;

    virtual HOM_galleries& galleries() throw(HOM_Error) = 0;
    virtual HOM_hda& hda() throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual HOM_hipFile& hipFile() throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual HOM_playbar& playbar() throw(HOM_Error) = 0;
    virtual HOM_hmath& hmath() throw(HOM_Error) = 0;
    virtual HOM_dop& dop() throw(HOM_Error) = 0;
    virtual HOM_shelves& shelves() throw(HOM_Error) = 0;


    virtual void exit(int exit_code=0, bool suppress_save_prompt=false)
        throw(HOM_SystemExit, HOM_Error) = 0;

    // isExiting() will return true if the program is actually Houdini (not
    // mplay) and the UI queue is closed.  This method is wrapped by swig, but
    // only so houdiniInterpreter can call it.
    virtual bool isExiting() throw(HOM_Error) = 0;


    virtual std::string applicationName() throw(HOM_Error) = 0;
    virtual std::vector<int> applicationVersion() throw(HOM_Error) = 0;
    virtual std::string applicationVersionString() throw(HOM_Error) = 0;
    virtual std::string applicationCompilationDate() throw(HOM_Error) = 0;
    virtual HOM_EnumValue &licenseCategory() throw(HOM_Error) = 0;
    virtual bool isApprentice() throw(HOM_Error) = 0;
    virtual void releaseLicense() throw(HOM_OperationFailed, HOM_Error) = 0;


    // These methods return a new HOM_Node object.
    virtual HOM_Node* root() throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual HOM_Node* pwd() throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual HOM_Node* parent() throw(HOM_NotAvailable, HOM_Error) = 0;

    virtual void setPwd(HOM_Node &newpwd)
        throw(HOM_ObjectWasDeleted, HOM_NotAvailable, HOM_Error) = 0;
    virtual void cd(const char *path)
        throw(HOM_OperationFailed, HOM_NotAvailable, HOM_Error) = 0;

    // Calling phm() is a shortcut for calling pwd().hdaModule().
    virtual HOM_HDAModule* phm() throw(HOM_NotAvailable, HOM_Error) = 0;

    // This method returns a new HOM_DopNetNode object or None.
    virtual HOM_Node* currentDopNet()
        throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual void setCurrentDopNet(HOM_Node &dopnet)
        throw(HOM_NotAvailable, HOM_ObjectWasDeleted, HOM_Error) = 0;

    // Gets or sets the simulation enabled state.
    virtual bool simulationEnabled()
        throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual void setSimulationEnabled(bool enabled)
        throw(HOM_NotAvailable, HOM_Error) = 0;

    // These methods return a new HOM_Node object or null if the node couldn't
    // be found.
    virtual HOM_Node *node(const char *path)
        throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual HOM_Node *nodeBySessionId(int session_id)
        throw(HOM_NotAvailable, HOM_Error) = 0;

    // Return HOM_Nodes for all selected nodes in the session.
    virtual std::vector<HOM_ElemPtr<HOM_Node> > selectedNodes(
            bool include_hidden = false)
        throw(HOM_NotAvailable, HOM_Error) = 0;

    // These methods return new HOM_Parm/HOM_ParmTuple objects or null if the
    // parm couldn't be found.
    virtual HOM_Parm* parm(const char *path)
        throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual HOM_ParmTuple* parmTuple(const char *path)
        throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual HOM_Parm *evaluatingParm()
        throw(HOM_NotAvailable, HOM_Error) = 0;

    // Access to the contents of the parm clipboard
    virtual std::vector< std::map<std::string, std::string> >
                            parmClipboardContents() = 0;

    // This method returns a new HOM_NodeType object or null if it couldn't
    // be found.
    virtual HOM_NodeType *nodeType(
            HOM_NodeTypeCategory &category, const char *name)
        throw(HOM_NotAvailable, HOM_Error) = 0;

    virtual HOM_NodeTypeCategory &objNodeTypeCategory() = 0;
    virtual HOM_NodeTypeCategory &sopNodeTypeCategory() = 0;
    virtual HOM_NodeTypeCategory &popNodeTypeCategory() = 0;
    virtual HOM_NodeTypeCategory &dopNodeTypeCategory() = 0;
    virtual HOM_NodeTypeCategory &cop2NodeTypeCategory() = 0;
    virtual HOM_NodeTypeCategory &shopNodeTypeCategory() = 0;
    virtual HOM_NodeTypeCategory &vopNodeTypeCategory() = 0;
    virtual HOM_NodeTypeCategory &ropNodeTypeCategory() = 0;
    virtual HOM_NodeTypeCategory &chopNodeTypeCategory() = 0;
    virtual HOM_NodeTypeCategory &popNetNodeTypeCategory() = 0;
    virtual HOM_NodeTypeCategory &cop2NetNodeTypeCategory() = 0;
    virtual HOM_NodeTypeCategory &vopNetNodeTypeCategory() = 0;
    virtual HOM_NodeTypeCategory &chopNetNodeTypeCategory() = 0;
    virtual HOM_NodeTypeCategory &managerNodeTypeCategory() = 0;
    virtual HOM_NodeTypeCategory &rootNodeTypeCategory() = 0;
    virtual std::map<std::string, HOM_NodeTypeCategory *>
            nodeTypeCategories() = 0;

    virtual std::vector<HOM_ElemPtr<HOM_Node> > copyNodesTo(
            const std::vector<HOM_Node *> &nodes, 
            HOM_Node &destination_node)
        throw(HOM_ObjectWasDeleted, HOM_OperationFailed, HOM_TypeError, 
            HOM_Error) = 0;
    virtual std::vector<HOM_ElemPtr<HOM_Node> > moveNodesTo(
            const std::vector<HOM_Node *> &nodes, 
            HOM_Node &destination_node)
        throw(HOM_ObjectWasDeleted, HOM_OperationFailed, HOM_TypeError, 
            HOM_Error) = 0;

    virtual HOM_NodeBundle *addNodeBundle(const char *name)
        throw(HOM_OperationFailed, HOM_NotAvailable, HOM_TypeError,
            HOM_Error) = 0;
    virtual std::vector<HOM_ElemPtr<HOM_NodeBundle> > nodeBundles()
        throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual std::vector<HOM_ElemPtr<HOM_NodeBundle> > selectedNodeBundles()
        throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual HOM_NodeBundle *nodeBundle(const char *name)
        throw(HOM_NotAvailable, HOM_TypeError, HOM_Error) = 0;

    // Note that getTimeWithoutAddingDependency is not wrapped by swig.
    virtual double getTimeWithoutAddingDependency() = 0;
    virtual double time() throw(HOM_Error) = 0;
    virtual void setTime(double time) throw(HOM_Error) = 0;
    virtual double frame() throw(HOM_Error) = 0;
    virtual int intFrame() throw(HOM_Error) = 0;
    virtual void setFrame(double frame) throw(HOM_Error) = 0;
    virtual double fps() throw(HOM_Error) = 0;
    virtual void setFps(double fps) throw(HOM_Error) = 0;
    virtual double timeToFrame(double time) throw(HOM_Error) = 0;
    virtual double frameToTime(double frame) throw(HOM_Error) = 0;


    virtual double bezier() throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual double constant() throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual double cubic() throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual double cycle(double start_frame, double end_frame)
        throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual double cyclet(double start_time, double end_time)
        throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual double cycleoffset(double start_frame, double end_frame)
        throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual double cycleoffsett(double start_time, double end_time)
        throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual double ease() throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual double easein() throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual double easeinp(double ease_speed)
        throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual double easeout() throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual double easeoutp(double ease_speed)
        throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual double easep(double ease_bias)
        throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual double linear() throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual double match() throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual double matchin() throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual double matchout() throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual double qlinear() throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual double quintic() throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual double repeat(double start_frame, double end_frame)
        throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual double repeatt(double start_time, double end_time)
        throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual double spline() throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual double vmatch() throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual double vmatchin() throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual double vmatchout() throw(HOM_NotAvailable, HOM_Error) = 0;


    virtual std::vector<HOM_ElemPtr<HOM_VexContext> >
        vexContexts() throw(HOM_Error) = 0;

    virtual HOM_VexContext* vexContextForShaderType(HOM_EnumValue &shader_type)
        throw(HOM_TypeError, HOM_Error) = 0;

    virtual HOM_VexContext* vexContextForNodeTypeCategory(
            HOM_NodeTypeCategory &node_type_category)
        throw(HOM_TypeError, HOM_Error) = 0;


    virtual std::string hscriptCommandHelp(const char *command_name)
        throw(HOM_Error) = 0;

    // This method returns a pair of strings: one for stdout and one for
    // stderr.
    virtual std::vector<std::string> hscript(const char *command)
        throw(HOM_Error) = 0;

    // Compare if two numbers are almost equal.
    virtual bool almostEqual(double x, double y) throw(HOM_Error) = 0;

    virtual std::vector<std::pair<HOM_ElemPtr<HOM_Parm>, std::string> >
        fileReferences(const char *project_dir_variable="HIP")
            throw(HOM_TypeError, HOM_Error) = 0;

    // Find files in $HOUDINI_PATH.
    virtual std::string findFile(const char *file_name)
        throw(HOM_OperationFailed, HOM_Error) = 0;
    virtual std::vector<std::string> findFiles(
        const char *file_name) throw(HOM_OperationFailed, HOM_Error) = 0;

    // Find directories in $HOUDINI_PATH.
    virtual std::string findDirectory(const char *directory_name)
        throw(HOM_OperationFailed, HOM_Error) = 0;
    virtual std::vector<std::string> findDirectories(
        const char *directory_name) throw(HOM_OperationFailed, HOM_Error) = 0;

    virtual std::vector<std::string> houdiniPath()
        throw(HOM_Error) = 0;

    virtual std::string homeHoudiniDirectory()
        throw(HOM_Error) = 0;

    // Read in the contents of the file.
    virtual std::string readFile(const char *file_path)
        throw(HOM_OperationFailed, HOM_Error) = 0;

    // These 3 methods are not wrapped by swig.  They are used to notify
    // interested parties that a change to the module source code was made and
    // that they should forcefully update to match the change.  The third
    // is used to load the session module source from a hip file, even though
    // that source might generate an exception.
    virtual UI_Value *getSessionModuleSourceForceUpdateValue() = 0;
    virtual void forceUpdateFromSessionModuleSource() = 0;
    virtual void forceSetSessionModuleSource(const char *source) throw() = 0;

    virtual void setSessionModuleSource(const char *source)
        throw(HOM_OperationFailed, HOM_Error) = 0;
    virtual void appendSessionModuleSource(const char *source)
        throw(HOM_OperationFailed, HOM_Error) = 0;
    virtual std::string sessionModuleSource() throw(HOM_Error) = 0;
    // This method is not wrapped by swig:
    virtual int sessionModuleSourceChangeCount() = 0;


    // This static method lets you know if the HOM implementation is set,
    // so you can check if it's safe to call the HOM() function.  This method
    // should only be called in rare cases.
    static bool isImplementationSet()
    { return theImplementation != NULL; }


    virtual std::string chsop(const char *path) 
        throw(HOM_ObjectWasDeleted, HOM_OperationFailed, HOM_Error) = 0;


    // hscriptExpression() will return different types, according to
    // the return value of the expression.
    virtual boost::any hscriptExpression(const char *expression)
        throw(HOM_OperationFailed, HOM_Error) = 0;
    virtual double hscriptFloatExpression(const char *expression)
        throw(HOM_OperationFailed, HOM_Error) = 0;
    virtual std::string hscriptStringExpression(const char *expression)
        throw(HOM_OperationFailed, HOM_Error) = 0;
    virtual std::vector<double> hscriptVectorExpression(const char *expression)
        throw(HOM_OperationFailed, HOM_Error) = 0;
    virtual std::vector<std::vector<double> > hscriptMatrixExpression(
            const char *expression)
        throw(HOM_OperationFailed, HOM_Error) = 0;

    virtual std::string expandString(const char *str)
        throw(HOM_OperationFailed, HOM_NotAvailable, HOM_Error) = 0;
    virtual std::string expandStringAtFrame(const char *str, double frame)
        throw(HOM_OperationFailed, HOM_NotAvailable, HOM_Error) = 0;

    virtual double lvar(const char *name)
        throw(HOM_NotAvailable, HOM_OperationFailed, HOM_Error) = 0;

    virtual char *getenv(const char *name, const char *default_value=NULL)
        throw(HOM_TypeError, HOM_Error) = 0;

    virtual void putenv(const char *name, const char *value)
        throw(HOM_TypeError, HOM_Error) = 0;

    virtual void unsetenv(const char *name)
        throw(HOM_TypeError, HOM_Error) = 0;

    virtual void allowEnvironmentToOverwriteVariable(
            const char *name, bool onoff)
        throw(HOM_TypeError, HOM_Error) = 0;

    virtual void *expressionGlobals() throw(HOM_Error) = 0;

    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    // These methods are used to override the return value of hou.time and
    // hou.frame.  They are not wrapped by swig.  Use HOM_AutoOverrideTime
    // instead of calling pushTime() and popTime() directly.
    virtual void pushTime(double t) = 0;
    virtual void popTime() = 0;

    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    // This method is used to interact with the global interrupt object.
    virtual bool updateProgressAndCheckForInterrupt(int percentage=-1)
        throw(HOM_Error) = 0;

    virtual std::map<std::string, boost::any> runVex(
            const char *vex_file,
            const std::map<std::string, boost::any> &inputs)
        throw(HOM_OperationFailed, HOM_TypeError, HOM_Error) = 0;

    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    virtual void saveImageDataToFile(
            const std::vector<float> &color_and_alpha_data,
            int width, int height,
            const char *file_name)
        throw(HOM_OperationFailed, HOM_TypeError, HOM_Error) = 0;

    virtual void saveImageDataToFile(
            const std::string &color_and_alpha_data,
            int width, int height,
            const char *file_name)
        throw(HOM_OperationFailed, HOM_TypeError, HOM_Error) = 0;

    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    virtual HOM_EnumValue &updateModeSetting()
        throw(HOM_NotAvailable, HOM_Error) = 0;
    virtual void setUpdateMode(HOM_EnumValue &mode)
        throw(HOM_NotAvailable, HOM_TypeError, HOM_Error) = 0;

    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    virtual void *opaqueRunCallbackAndCatchCrashes(void *opaque_callback)
        throw(HOM_TypeError, HOM_Error) = 0;

    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    // These methods are used to grant functions defined in an asset's
    // PythonModule enhanced privileges.  They are not wrapped by swig.
    virtual void pushAccessPrivilege(const char *key) throw(HOM_Error) = 0;
    virtual void popAccessPrivilege(const char *key) throw(HOM_Error) = 0;

    virtual std::string currentPythonModuleKey() throw(HOM_Error) = 0;

    virtual void registerAccessPrivilegePyClient(void *opaque_python_object)
        throw(HOM_Error) = 0;

    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    // These methods are used to instantiate HOMF objects from the HOM
    // library level.  They are not wrapped by swig.
    virtual HOM_FloatParmTemplate *newFloatParmTemplate(
            const char *name,
            const char *label,
            int num_components,
            const std::vector<double> &default_value,
            double min, double max,
            bool min_is_strict, bool max_is_strict,
            HOM_EnumValue &look,
            HOM_EnumValue &naming_scheme,
            const char *disable_when,
            bool is_hidden,
            bool is_label_hidden,
            bool join_with_next,
            const char *help,
            const char *script_callback,
            HOM_EnumValue &script_callback_language,
            const std::map<std::string, std::string> &tags)
        throw(HOM_OperationFailed, HOM_TypeError, HOM_Error) = 0;

    virtual HOM_IntParmTemplate *newIntParmTemplate(
            const char *name,
            const char *label,
            int num_components,
            const std::vector<int> &default_value,
            int min, int max,
            bool min_is_strict, bool max_is_strict,
            HOM_EnumValue &naming_scheme,
            const char *disable_when,
            bool is_hidden,
            bool is_label_hidden,
            bool join_with_next,
            const char *help,
            const char *script_callback,
            HOM_EnumValue &script_callback_language,
            const std::map<std::string, std::string> &tags)
        throw(HOM_OperationFailed, HOM_TypeError, HOM_Error) = 0;

    virtual HOM_StringParmTemplate *newStringParmTemplate(
            const char *name,
            const char *label,
            int num_components,
            const std::vector<std::string> &default_value,
            HOM_EnumValue &naming_scheme,
            HOM_EnumValue &string_type,
            const std::vector<std::string> &menu_items,
            const std::vector<std::string> &menu_labels,
            const std::vector<std::string> &icon_names,
            const std::string &item_generator_script,
            HOM_EnumValue *item_generator_script_language,
            HOM_EnumValue &menu_type,
            const char *disable_when,
            bool is_hidden,
            bool is_label_hidden,
            bool join_with_next,
            const char *help,
            const char *script_callback,
            HOM_EnumValue &script_callback_language,
            const std::map<std::string, std::string> &tags)
        throw(HOM_OperationFailed, HOM_TypeError, HOM_Error) = 0;

    virtual HOM_ToggleParmTemplate *newToggleParmTemplate(
            const char *name,
            const char *label,
            bool default_value,
            const char *disable_when,
            bool is_hidden,
            bool is_label_hidden,
            bool join_with_next,
            const char *help,
            const char *script_callback,
            HOM_EnumValue &script_callback_language,
            const std::map<std::string, std::string> &tags)
        throw(HOM_OperationFailed, HOM_TypeError, HOM_Error) = 0;

    virtual HOM_MenuParmTemplate *newMenuParmTemplate(
            const char *name,
            const char *label,
            const std::vector<std::string> &menu_items,
            const std::vector<std::string> &menu_labels,
            int default_value,
            const std::vector<std::string> &icon_names,
            const std::string &item_generator_script,
            HOM_EnumValue *item_generator_script_language,
            HOM_EnumValue &menu_type,
            const char *disable_when,
            bool is_hidden,
            bool is_label_hidden,
            bool join_with_next,
            const char *help,
            const char *script_callback,
            HOM_EnumValue &script_callback_language,
            const std::map<std::string, std::string> &tags)
        throw(HOM_OperationFailed, HOM_TypeError, HOM_Error) = 0;

    virtual HOM_ButtonParmTemplate *newButtonParmTemplate(
            const char *name,
            const char *label,
            const char *disable_when,
            bool is_hidden,
            bool is_label_hidden,
            bool join_with_next,
            const char *help,
            const char *script_callback,
            HOM_EnumValue &script_callback_language,
            const std::map<std::string, std::string> &tags)
        throw(HOM_OperationFailed, HOM_TypeError, HOM_Error) = 0;

    virtual HOM_LabelParmTemplate *newLabelParmTemplate(
            const char *name,
            const char *label,
            const std::vector<std::string> &column_labels,
            bool is_hidden,
            bool is_label_hidden,
            bool join_with_next,
            const char *help,
            const std::map<std::string, std::string> &tags)
        throw(HOM_OperationFailed, HOM_TypeError, HOM_Error) = 0;

    virtual HOM_SeparatorParmTemplate *newSeparatorParmTemplate(
            const char *name,
            bool is_hidden,
            const std::map<std::string, std::string> &tags)
        throw(HOM_OperationFailed, HOM_TypeError, HOM_Error) = 0;

    virtual HOM_FolderSetParmTemplate *newFolderSetParmTemplate(
            const char *name,
            const std::vector<std::string> &folder_names,
            HOM_EnumValue &folder_type,
            const std::map<std::string, std::string> &tags)
        throw(HOM_OperationFailed, HOM_TypeError, HOM_Error) = 0;

    virtual HOM_FolderParmTemplate *newFolderParmTemplate(
            const char *name,
            const char *label,
            const std::vector<HOM_ParmTemplate *> &parm_templates,
            HOM_EnumValue &folder_type,
            int default_value,
            bool is_hidden,
            bool ends_tab_group,
            const std::map<std::string, std::string> &tags)
        throw(HOM_OperationFailed, HOM_TypeError, HOM_Error) = 0;

    virtual HOM_RampParmTemplate *newRampParmTemplate(
            const char *name,
            const char *label,
            HOM_EnumValue &ramp_parm_type,
            int default_value,
            HOM_EnumValue *default_basis,
            bool show_controls,
            HOM_EnumValue *color_type,
            const char *disable_when,
            bool is_hidden,
            const char *help,
            const char *script_callback,
            HOM_EnumValue &script_callback_language,
            const std::map<std::string, std::string> &tags)
        throw(HOM_OperationFailed, HOM_TypeError, HOM_Error) = 0;

    virtual HOM_ParmTemplateGroup *newParmTemplateGroup(
            const std::vector<HOM_ParmTemplate *> &parm_templates)
        throw(HOM_OperationFailed, HOM_TypeError, HOM_Error) = 0;


    virtual HOM_Keyframe *newKeyframe() = 0;
    virtual HOM_Keyframe *newKeyframe(double value) = 0;
    virtual HOM_Keyframe *newKeyframe(double value, double time) = 0;
    virtual HOM_Keyframe *newKeyframe(const HOM_Keyframe &keyframe) = 0;

    virtual HOM_StringKeyframe *newStringKeyframe() = 0;
    virtual HOM_StringKeyframe *newStringKeyframe(
        const std::string &value, HOM_EnumValue &language) = 0;
    virtual HOM_StringKeyframe *newStringKeyframe(
        const std::string &value, double time, HOM_EnumValue &language) = 0;
    virtual HOM_StringKeyframe *newStringKeyframe(
        const HOM_StringKeyframe &string_keyframe) = 0;

    virtual HOM_HDAOptions *newHDAOptions() = 0;

    virtual HOM_InterruptableOperation *newInterruptableOperation(
        const char *operation_name, const char *long_operation_name,
        bool open_interrupt_dialog) = 0;

    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    // These methods are used to help debug HOM to make sure no objects
    // get allocated that don't get deallocated.
    virtual void constructObject(void *pointer, const std::type_info &type) = 0;
    virtual void destructObject(void *pointer, const std::type_info &type) = 0;
    virtual std::map<std::string, int> objectCounts() = 0;

private:
    // A subclass of HOM_Module in the HOMF library will define the
    // implementation of HOM.  Importing the python module will set the
    // implementation, so this function should only be called by HOMF_Module::
    // ensureHoudiniInternalsExist().
    friend class HOMF_Module;
    static void setImplementation(HOM_Module* implementation);

    // We could add a static method to access the implementation, but we
    // want to make it easy to access the HOM module from C++.  So, the
    // global function HOM() needs access to the implementation.
    friend HOM_API HOM_Module& HOM() throw(HOM_Error);
    static HOM_Module *theImplementation;
};


// Use this function to automatically delete objects for functions that
// return new objects.  This lets you, for example, write code like
//     HOMdel(HOM().findNode("/obj/geo1"))->setName("geo2")
template <typename T>
boost::shared_ptr<T> HOMdel(T *hom_object)
{ return boost::shared_ptr<T>(hom_object); }


// Instantiate this class to override the time values return by HOM().time()
// and HOM().frame().  Do not call pushTime() and popTime() directly.
class HOM_API HOM_AutoOverrideTime
{
public:
    HOM_AutoOverrideTime(double time)
    { HOM().pushTime(time); }
    ~HOM_AutoOverrideTime()
    { HOM().popTime(); }
};


// This lock is used to synchronize HOM scripts running in a separate
// thread and Houdini.  Houdini's UI queue will give up the lock when it's
// waiting for events and reacquire it when it handles an event.
//
// Note that this lock allows multiple threads in the same thread group to hold
// it at the same time.  By default, a thread started from Houdini is added to
// the group containing the main thread.  This way, since Houdini started the
// thread, we can be confident that it will use other locks to synchronize
// access to Houdini.  This approach allows, for example, a volume SOP to
// cook using multiple threads, evaluating Python in each thread while the
// main thread holds the HOM lock, without deadlocking and without allowing
// non-Houdini threads to acquire the HOM lock.  (Note that the GIL will
// synchronize access to Python's internals.)
HOM_API extern UT_TaskLock HOM_theHOMLock;
inline UT_TaskLock &HOMgetLock()
{
    return HOM_theHOMLock;
}

// The HOM implementation uses the HOM_AutoLock to make sure Houdini isn't busy
// when they make calls into the Houdini libraries.  Note that constructing
// a HOM_AutoLock will release the python global interpreter lock (GIL) if
// it was held before acquiring the HOM lock.  This way, other python threads
// can run if it needs to block waiting for the HOM lock.
class HOM_API HOM_AutoLock : UT_NonCopyable
{
public:
    HOM_AutoLock()
    {
        // It's important that we release the python global interpreter lock
        // (GIL) before we block waiting on the HOM lock.  Otherwise, Houdini
        // code that has the HOM lock that tries to run python may block
        // waiting on the GIL, causing a deadlock.  We'll reacquire the GIL
        // when the auto unlock goes out of scope.
        PY_InterpreterAutoUnlock interp_unlock;
        HOMgetLock().lock();
    }

    ~HOM_AutoLock()
    {
        HOMgetLock().unlock();
    }
};

// The HOM implementation uses HOM_AutoUnlock to allow the main thread to
// run while waiting for something to happen.  Constructing a HOM_AutoUnlock
// instance will release the HOM lock but not the Python GIL.  When it's
// destructed it will reacquire the HOM lock.  Since it releases the HOM lock,
// it's important that a HOM_AutoLock was already created in a containing
// scope.
//
// Use HOM_AutoUnlock in conjunction with PY_InterpreterAutoUnlock to
// also release the Python GIL.  Be sure to create the HOM_AutoUnlock *after*
// the PY_InterpreterAutoUnlock, so that when the auto locks are destructed
// the HOM lock is reacquired before the Python GIL.  Otherwise, it will grab
// the GIL and then try to grab the HOM lock, and if another thread with the
// HOM lock tries to run Python we'll end up with deadlock.
class HOM_API HOM_AutoUnlock : UT_NonCopyable
{
public:
    HOM_AutoUnlock()
    { HOMgetLock().unlock(); }

    ~HOM_AutoUnlock()
    { HOMgetLock().lock(); }
};


// These macros are used to help detect memory leaks when debugging is enabled.
#ifdef HOM_DEBUG
#define HOM_CONSTRUCT_OBJECT(pointer) \
    HOM().constructObject(pointer, typeid(*pointer));
#define HOM_DESTRUCT_OBJECT(pointer) \
    HOM().destructObject(pointer, typeid(*pointer));
#else
#define HOM_CONSTRUCT_OBJECT(pointer)
#define HOM_DESTRUCT_OBJECT(pointer)
#endif

// gcc gets a parse error if we try to give a default map value in the
// signature, and the typedef avoids the error.
typedef std::map<std::string, std::string> HOM_StdMapStringString;

// Houdini will call HOMextendLibrary() in HDK dso's so the user can install
// C++ HOM extensions.
extern "C" {
   SYS_VISIBILITY_EXPORT extern void HOMextendLibrary();
}

#endif

---