HOM_Node.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.
 *
 * COMMENTS:
 */

#ifndef __HOM_Node_h__
#define __HOM_Node_h__

#include "HOM_API.h"
#include "HOM_NetworkMovableItem.h"
#include "HOM_BinaryString.h"
#include "HOM_EnumModules.h"
#include "HOM_IterableList.h"
#include "HOM_PtrOrNull.h"
#include <PY/PY_OpaqueObject.h>
#include <string>
#include <vector>

class HOM_StickyNote;
class HOM_NodeConnection;
class HOM_NodeGroup;
class HOM_NodeType;
class HOM_NodeTypeCategory;
class HOM_Parm;
class HOM_ParmTuple;
class HOM_IndirectInput;
class HOM_SubnetIndirectInput;
class HOM_HDAModule;
class HOM_HDAViewerHandleModule;
class HOM_HDAViewerStateModule;
class HOM_ParmTemplate;
class HOM_DopSimulation;
class HOM_DopObject;
class HOM_ParmTemplateGroup;
class HOM_NodeInfoTree;
class CL_Clip;

SWIGOUT(%rename(Node) HOM_Node;)

class HOM_API HOM_Node : virtual public HOM_NetworkMovableItem
{
public:
    HOM_Node()
        : HOM_NetworkMovableItem(HOM_networkItemType::Node)
    { HOM_CONSTRUCT_OBJECT(this) }
    HOM_Node(const HOM_Node &node)
        : HOM_NetworkMovableItem(node)
    { HOM_CONSTRUCT_OBJECT(this) }
    ~HOM_Node() override
    { HOM_DESTRUCT_OBJECT(this) }

    virtual bool operator==(HOM_PtrOrNull<HOM_Node> node) = 0;
    virtual bool operator!=(HOM_PtrOrNull<HOM_Node> node) = 0;

    int __hash__() override = 0;
    std::string __repr__() override = 0;
    virtual std::string __str__() = 0;

    virtual bool isNetwork() = 0;
    virtual bool isEditable() = 0;

    SWIGOUT(%newobject type;)
    SWIGOUT(%warnfilter(321) type;)
    virtual HOM_NodeType *type() = 0;
    virtual HOM_NodeTypeCategory *childTypeCategory() = 0;

    virtual bool isFlagReadable(HOM_EnumValue &flag) = 0;
    virtual bool isFlagWritable(HOM_EnumValue &flag) = 0;
    virtual bool isGenericFlagSet(HOM_EnumValue &flag) = 0;
    virtual void setGenericFlag(HOM_EnumValue &flag, bool value) = 0;

    virtual bool isDisplayDescriptiveNameFlagSet() = 0;
    virtual void setDisplayDescriptiveNameFlag(bool on) = 0;

    virtual std::vector<std::string> errors() = 0;
    virtual std::vector<std::string> warnings() = 0;
    virtual std::vector<std::string> messages() = 0;

    SWIGOUT(%newobject node;)
    SWIGOUT(%kwargs node;)
    virtual HOM_Node* node(const char* node_path) = 0;

    SWIGOUT(%kwargs nodes;)
    virtual std::vector<HOM_ElemPtr<HOM_Node> > nodes(
        const std::vector<std::string>& node_paths) = 0;

    SWIGOUT(%newobject item;)
    SWIGOUT(%kwargs item;)
    virtual HOM_NetworkMovableItem* item(const char* item_path) = 0;

    SWIGOUT(%kwargs items;)
    virtual std::vector<HOM_ElemPtr<HOM_NetworkMovableItem> > items(
        const std::vector<std::string>& item_paths) = 0;

    SWIGOUT(%kwargs glob;)
    virtual std::vector<HOM_ElemPtr<HOM_Node> > glob(
        const char *pattern, bool ignore_case=false) = 0;

    SWIGOUT(%kwargs recursiveGlob;)
    virtual std::vector<HOM_ElemPtr<HOM_Node> > recursiveGlob(
        const char *pattern,
        HOM_EnumValue &filter = HOM_nodeTypeFilter::NoFilter,
        bool include_subnets = true) = 0;

    SWIGOUT(%newobject createNode;)
    SWIGOUT(%kwargs createNode;)
    virtual HOM_Node* createNode(
        const char* node_type_name,
        const char* node_name=NULL,
        bool run_init_scripts=true,
        bool load_contents=true,
        bool exact_type_name=false,
        bool force_valid_node_name=false) = 0;

    virtual int inputIndex(const char *input_name) = 0;
    virtual int outputIndex(const char *output_name) = 0;

    virtual void setInput(
        int input_index,
        HOM_NetworkMovableItem *item_to_become_input,
        int output_index = 0) = 0;

    virtual void setNamedInput(
        const char *input_name,
        HOM_NetworkMovableItem *item_to_become_input,
        const char *output_name) = 0;

    virtual void setNamedInput(
        const char *input_name,
        HOM_NetworkMovableItem *item_to_become_input,
        int output_index) = 0;

    virtual void setFirstInput(
        HOM_NetworkMovableItem *item_to_become_input,
        int output_index = 0) = 0;

    SWIGOUT(%kwargs setNextInput;)
    virtual void setNextInput(
        HOM_NetworkMovableItem *item_to_become_input,
        int output_index = 0,
        bool unordered_only = false) = 0;

    virtual void insertInput(
        int input_index,
        HOM_NetworkMovableItem *item_to_become_input,
        int output_index = 0) = 0;

    virtual int numOrderedInputs() = 0;

    virtual std::vector<HOM_ElemPtr<HOM_Node> > inputs() = 0;
    virtual std::vector<HOM_ElemPtr<HOM_Node> > inputsFollowingOutputs() = 0;

    SWIGOUT(%warnfilter(321) input;)
    virtual HOM_Node *input(int input_index) = 0;
    virtual HOM_Node *inputFollowingOutputs(int input_index) = 0;

    virtual std::vector<HOM_ElemPtr<HOM_NodeConnection> > inputConnections() = 0;

    SWIGOUT(%newobject inputConnectors;)
    virtual HOM_IterableList<std::vector<HOM_ElemPtr<HOM_NodeConnection> > > *
        inputConnectors() = 0;

    SWIGOUT(%kwargs inputAncestors;)
    virtual std::vector<HOM_ElemPtr<HOM_Node> > inputAncestors(
        bool include_ref_inputs = true,
        bool follow_subnets = false,
        bool only_used_inputs = false) = 0;

    virtual std::vector<std::string> inputNames() = 0;
    virtual std::vector<std::string> inputLabels() = 0;

    virtual std::map<std::string, std::string> editableInputStrings(
            int input_index) = 0;
    virtual std::string editableInputString(int input_index,
            const char *key) = 0;
    virtual void setEditableInputString(int input_index,
            const char *key, const char *value) = 0;

    virtual std::vector<std::string> outputNames() = 0;
    virtual std::vector<std::string> outputLabels() = 0;

    virtual std::vector<HOM_ElemPtr<HOM_Node> > outputs() = 0;

    virtual std::vector<HOM_ElemPtr<HOM_NodeConnection> >
        outputConnections() = 0;

    SWIGOUT(%newobject outputConnectors;)
    virtual HOM_IterableList<std::vector<HOM_ElemPtr<HOM_NodeConnection> > > *
        outputConnectors() = 0;

    // Access things contained in this node (node must be a network).
    virtual std::vector<HOM_ElemPtr<HOM_Node> > children() = 0;
    SWIGOUT(%kwargs allSubChildren;)
    virtual std::vector<HOM_ElemPtr<HOM_Node> > allSubChildren(
        bool top_down = true, 
        bool recurse_in_locked_nodes = true,
        bool sync_delayed_definition = false) = 0;
    SWIGOUT(%kwargs selectedChildren;)
    virtual std::vector<HOM_ElemPtr<HOM_Node> > selectedChildren(
        bool include_hidden = false,
        bool include_hidden_support_nodes = false) = 0;

    virtual std::vector<HOM_ElemPtr<HOM_NetworkMovableItem> > allItems() = 0;
    SWIGOUT(%kwargs allSubItems;)
    virtual std::vector<HOM_ElemPtr<HOM_NetworkMovableItem> > allSubItems(
        bool top_down = true,
        bool recurse_in_locked_nodes = true,
        bool sync_delayed_definition = false) = 0;
    SWIGOUT(%kwargs selectedItems;)
    virtual std::vector<HOM_ElemPtr<HOM_NetworkMovableItem> > selectedItems(
        bool include_hidden = false,
        bool include_hidden_support_nodes = false) = 0;
    SWIGOUT(%kwargs numItems;)
    virtual int numItems(HOM_EnumValue *item_type = NULL,
        bool selected_only = false,
        bool include_hidden = false) = 0;

    // Picked child item copy/paste/delete methods.
    SWIGOUT(%kwargs deleteItems;)
    virtual void deleteItems(
                    const std::vector<HOM_NetworkMovableItem *>&
                        items = std::vector<HOM_NetworkMovableItem *>(),
                    bool disable_safety_checks = false) = 0;
    virtual void copyItemsToClipboard(
        const std::vector<HOM_NetworkMovableItem *> &items =
            std::vector<HOM_NetworkMovableItem *>()) = 0;
    virtual void pasteItemsFromClipboard(HOM_Vector2 *position = NULL) = 0;
    SWIGOUT(%kwargs copyItems;)
    virtual std::vector<HOM_ElemPtr<HOM_NetworkMovableItem> > copyItems(
        const std::vector<HOM_NetworkMovableItem *> &items,
        bool channel_reference_originals=false,
        bool relative_references=true,
        bool connect_outputs_to_multi_inputs=false) = 0;

    SWIGOUT(%newobject creator;)
    virtual HOM_Node *creator() = 0;
    SWIGOUT(%newobject network;)
    HOM_Node *network()
    { return creator(); }

    SWIGOUT(%newobject moveToGoodPosition;)
    SWIGOUT(%kwargs moveToGoodPosition;)
    virtual HOM_Vector2 *moveToGoodPosition(bool relative_to_inputs = true,
            bool move_inputs = true,
            bool move_outputs = true,
            bool move_unconnected = true) = 0;

    // TODO: Have an argument to specify sorting orders once bug 25998 is fixed.
    //       Have an argument equivalent to oplayout -t once bug 26018 is fixed.
    SWIGOUT(%kwargs layoutChildren);
    virtual void layoutChildren
            (const std::vector<HOM_NetworkMovableItem *> &items =
                     std::vector<HOM_NetworkMovableItem *>(),
            double horizontal_spacing=-1,
            double vertical_spacing=-1) = 0;

    virtual bool isCurrent() = 0;
    SWIGOUT(%kwargs setCurrent;)
    virtual void setCurrent(bool on, bool clear_all_selected = false) = 0;

    virtual bool isHidden() = 0;
    virtual void hide(bool on) = 0;

    virtual std::string comment() = 0;
    virtual void setComment(const char *comment) = 0;
    virtual void appendComment(const char *comment) = 0;

    SWIGOUT(%kwargs destroy;)
    virtual void destroy(bool disable_safety_checks=false) = 0;

    virtual std::vector<HOM_ElemPtr<HOM_NetworkBox> > networkBoxes() = 0;
    SWIGOUT(%newobject iterNetworkBoxes;)
    virtual HOM_IterableList<HOM_NetworkBox> *iterNetworkBoxes() = 0;
    SWIGOUT(%newobject createNetworkBox;)
    virtual HOM_NetworkBox *createNetworkBox(const char *name=NULL) = 0;
    SWIGOUT(%newobject copyNetworkBox;)
    virtual HOM_NetworkBox *copyNetworkBox(HOM_NetworkBox &network_box_to_copy,
        const char *new_name=NULL, bool channel_reference_original=false) = 0;
    SWIGOUT(%newobject findNetworkBox;)
    virtual HOM_NetworkBox *findNetworkBox(const char *name) = 0;
    virtual std::vector<HOM_ElemPtr<HOM_NetworkBox> > 
        findNetworkBoxes(const char *pattern) = 0;

    virtual std::vector<HOM_ElemPtr<HOM_NetworkDot> > networkDots() = 0;
    SWIGOUT(%newobject createNetworkDot;)
    virtual HOM_NetworkDot *createNetworkDot() = 0;

    virtual bool canCreateDigitalAsset() = 0;

    // Sub-Network methods.
    SWIGOUT(%kwargs collapseIntoSubnet;)
    SWIGOUT(%newobject collapseIntoSubnet;)
    virtual HOM_Node *collapseIntoSubnet(
        const std::vector<HOM_NetworkMovableItem*> &child_items,
        const char *subnet_name=NULL, const char *subnet_type=NULL) = 0;

    virtual std::vector<HOM_ElemPtr<HOM_NetworkMovableItem> >
        extractAndDelete() = 0;

    virtual std::vector<HOM_ElemPtr<HOM_SubnetIndirectInput> >
        indirectInputs() = 0;

    // get the nodes inside a subnet that feed its outputs
    virtual std::vector<HOM_ElemPtr<HOM_Node> >
        subnetOutputs() = 0;

    virtual bool isSubNetwork() = 0;

    // User data methods:
    virtual void setUserData(const char *name, const std::string &value) = 0;
    SWIGOUT(%ignore boostAnyUserData;)
    virtual hboost::any boostAnyUserData(const char *name) = 0;
    virtual void destroyUserData(const char *name, bool must_exist=true) = 0;
    virtual void clearUserDataDict() = 0;
    virtual std::map<std::string, std::string> userDataDict() = 0;

#ifdef SWIG
%extend
{
    InterpreterObject userData(const char *name)
    { return HOMboostAnyToInterpreterObject(self->boostAnyUserData(name)); }
}
#endif

    // Sticky methods
    SWIGOUT(%newobject createStickyNote;)
    virtual HOM_StickyNote *createStickyNote(const char *name=NULL) = 0;
    virtual std::vector<HOM_ElemPtr<HOM_StickyNote> > stickyNotes() = 0;
    SWIGOUT(%newobject iterStickyNotes;)
    virtual HOM_IterableList<HOM_StickyNote> *iterStickyNotes() = 0;
    SWIGOUT(%newobject copyStickyNote;)
    virtual HOM_StickyNote *copyStickyNote(HOM_StickyNote &sticky_note_to_copy,
        const char *new_name=NULL) = 0;
    SWIGOUT(%newobject findStickyNote;)
    virtual HOM_StickyNote *findStickyNote(const char *name) = 0;
    SWIGOUT(%newobject findStickyNotes;)
    virtual std::vector<HOM_ElemPtr<HOM_StickyNote> > findStickyNotes(
        const char *pattern) = 0;
};

#endif