HOM/HOM_HDADefinition.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:
 */

#ifndef __HOM_HDADefinition_h__
#define __HOM_HDADefinition_h__

#include "HOM_API.h"
#include "HOM_Defines.h"
#include "HOM_Errors.h"
#include "HOM_Module.h"
#include <UT/UT_Options.h>
#include <string>
#include <vector>
class HOM_NodeType;
class HOM_HDASection;
class HOM_NodeTypeCategory;
class HOM_HDAOptions;
class HOM_ParmTemplate;

SWIGOUT(%rename(HDADefinition) HOM_HDADefinition;)

class HOM_API HOM_HDADefinition
{
public:
    HOM_HDADefinition()
    { HOM_CONSTRUCT_OBJECT(this) }
    HOM_HDADefinition(const HOM_HDADefinition &)
    { HOM_CONSTRUCT_OBJECT(this) }
    virtual ~HOM_HDADefinition()
    { HOM_DESTRUCT_OBJECT(this) }

    virtual bool operator==(HOM_HDADefinition &hda_definition)
        throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
    virtual bool operator!=(HOM_HDADefinition &hda_definition)
        throw(HOM_ObjectWasDeleted, HOM_Error) = 0;

    virtual int __hash__() throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
    virtual std::string __repr__() throw(HOM_ObjectWasDeleted, HOM_Error) = 0;

    SWIGOUT(%newobject nodeType;)
    virtual HOM_NodeType *nodeType()
        throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;

    virtual HOM_NodeTypeCategory &nodeTypeCategory()
        throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
    virtual std::string nodeTypeName()
        throw(HOM_ObjectWasDeleted, HOM_Error) = 0;

    virtual std::string libraryFilePath()
        throw(HOM_ObjectWasDeleted, HOM_Error) = 0;

    virtual std::string embeddedHelp()
        throw(HOM_ObjectWasDeleted, HOM_Error) = 0;

    // installed() is deprecated in favour of isInstalled().
    virtual bool isInstalled() throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
    bool installed() throw(HOM_ObjectWasDeleted, HOM_Error)
    { return isInstalled(); }

    // current() is deprecated in favour of isCurrent().
    virtual bool isCurrent() throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
    bool current() throw(HOM_ObjectWasDeleted, HOM_Error)
    { return isCurrent(); }

    // preferred() is deprecated in favour of isPreferred().
    virtual bool isPreferred() throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
    bool preferred() throw(HOM_ObjectWasDeleted, HOM_Error)
    { return isPreferred(); }

    // setPreferred() is deprecated in favour of setIsPreferred().
    virtual void setIsPreferred(bool preferred)
        throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
    void setPreferred(bool preferred)
        throw(HOM_ObjectWasDeleted, HOM_Error)
    { setIsPreferred(preferred); }

    SWIGPYTHONOUT(%feature("autodoc",
        "sections(self) -> dict of strings to HDASections") sections;)
    virtual std::map<std::string, HOM_ElemPtr<HOM_HDASection> > sections()
        throw(HOM_ObjectWasDeleted, HOM_Error) = 0;

    SWIGOUT(%newobject addSection;)
    virtual HOM_HDASection *addSection(const char *name,
                                       const std::string &contents = "")
        throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_PermissionError,
              HOM_Error) = 0;
    virtual void removeSection(const char *name)
        throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_PermissionError,
              HOM_Error) = 0;

    virtual std::string icon()
        throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
    virtual void setIcon(const char *icon)
        throw(HOM_ObjectWasDeleted, HOM_OperationFailed, HOM_PermissionError,
              HOM_Error) = 0;
    virtual int minNumInputs()
        throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
    virtual void setMinNumInputs(int min_num_inputs)
        throw(HOM_ObjectWasDeleted, HOM_OperationFailed, HOM_PermissionError,
              HOM_Error) = 0;
    virtual int maxNumInputs()
        throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
    virtual void setMaxNumInputs(int max_num_inputs)
        throw(HOM_ObjectWasDeleted, HOM_OperationFailed, HOM_PermissionError,
              HOM_Error) = 0;

    virtual std::string extraInfo()
        throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
    virtual void setExtraInfo(const char *extra_info)
        throw(HOM_ObjectWasDeleted, HOM_OperationFailed, HOM_PermissionError,
              HOM_Error) = 0;
    virtual bool hideDefaultParameters()
        throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
    virtual std::string representativeNodePath()
        throw(HOM_ObjectWasDeleted, HOM_Error) = 0;

    virtual std::string comment()
        throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
    virtual void setComment(const char *comment)
        throw(HOM_TypeError, HOM_ObjectWasDeleted, HOM_PermissionError,
              HOM_Error) = 0;

    virtual std::string version()
        throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
    virtual void setVersion(const char *version)
        throw(HOM_TypeError, HOM_ObjectWasDeleted, HOM_PermissionError,
              HOM_Error) = 0;

    virtual int modificationTime()
        throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
    virtual void setModificationTime(int time=-1)
        throw(HOM_OperationFailed, HOM_PermissionError, HOM_ObjectWasDeleted,
            HOM_Error) = 0;

    SWIGOUT(%newobject options;)
    virtual HOM_HDAOptions *options()
        throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
    virtual void setOptions(HOM_HDAOptions &options)
        throw(HOM_ObjectWasDeleted, HOM_OperationFailed, HOM_PermissionError,
              HOM_Error) = 0;

    virtual void updateFromNode(HOM_Node &node)
        throw(HOM_ObjectWasDeleted, HOM_OperationFailed, HOM_PermissionError,
              HOM_Error) = 0;

    virtual void save(
            const std::string &file_name,
            HOM_Node *template_node = NULL,
            HOM_HDAOptions *options = NULL)
        throw(HOM_ObjectWasDeleted, HOM_OperationFailed, HOM_PermissionError,
              HOM_Error) = 0;

    virtual void copyToHDAFile(
            const std::string &file_name,
            const char *new_name = NULL,
            const char *new_menu_name = NULL)
        throw(HOM_ObjectWasDeleted, HOM_OperationFailed, HOM_Error) = 0;

    virtual void destroy()
        throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;

    SWIGPYTHONOUT(%feature("autodoc",
        "addParmTuple(self, parm_template, in_folder=(),"
        " create_missing_folders=False)") addParmTuple;)
    SWIGOUT(%kwargs addParmTuple;)
    virtual void addParmTuple(
            HOM_ParmTemplate &parm_template,
            const std::vector<std::string> &in_folder =
                std::vector<std::string>(),
            bool create_missing_folders = false)
        throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_PermissionError,
              HOM_Error) = 0;

    virtual void removeParmTuple(const char *name)
        throw(HOM_TypeError, HOM_OperationFailed, HOM_ObjectWasDeleted,
              HOM_PermissionError, HOM_Error) = 0;

    SWIGPYTHONOUT(%feature("autodoc",
        "addParmFolder(self, folder_name, in_folder=(), parm_name=None,"
        " create_missing_folders=False)") addParmFolder;)
    virtual void addParmFolder(
            const char *folder_name,
            const std::vector<std::string> &in_folder =
                std::vector<std::string>(),
            const char *parm_name = NULL,
            bool create_missing_folders = false)
        throw(HOM_TypeError, HOM_OperationFailed, HOM_ObjectWasDeleted,
              HOM_PermissionError, HOM_Error) = 0;

    virtual void removeParmFolder(const std::vector<std::string> &folder)
        throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_PermissionError,
              HOM_Error) = 0;

    virtual void replaceParmTuple(
            const char *parm_tuple_name,
            HOM_ParmTemplate &parm_template)
        throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_PermissionError,
              HOM_TypeError, HOM_Error) = 0;

    virtual void setExtraFileOption(const char *name, boost::any value)
        throw(HOM_TypeError, HOM_ObjectWasDeleted, HOM_Error) = 0;
    virtual void removeExtraFileOption(const char *name)
        throw(HOM_OperationFailed, HOM_TypeError, HOM_PermissionError,
            HOM_ObjectWasDeleted, HOM_Error) = 0;

    // This is the function that does the real work of fetching the contents of
    // the ExtraFileOptions section as a UT_Options object.  This function is
    // never called directly from Python, and is instead invoked using from
    // extraFileOptions().
    SWIGOUT(%ignore getRawExtraFileOptions;)
    virtual void getRawExtraFileOptions(UT_Options &options)
        throw(HOM_ObjectWasDeleted, HOM_Error) = 0;

#ifdef SWIG
#ifdef SWIGPYTHON
%extend
{
    SWIGPYTHONOUT(%feature("autodoc",
        "extraFileOptions(self) -> dict of str to"
        " int, bool, float, string, Vector2, Vector3, Vector4, "
        " Quaternion, Matrix3, or Matrix4") extraFileOptions;)
    InterpreterObject extraFileOptions()
        throw(HOM_ObjectWasDeleted, HOM_Error)
    {
        UT_Options options;
        self->getRawExtraFileOptions(options);
        return HOMoptionsToInterpreterObject(options);
    }
}
#endif
#endif
};

#endif

---