HOM_ui.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_ui_h__
#define __HOM_ui_h__

#include "HOM_API.h"
#include "HOM_Defines.h"
#include "HOM_Module.h"
#include "HOM_Attrib.h"
#include "HOM_EnumValue.h"
#include "HOM_EnumModules.h"
#include "HOM_Color.h"
#include "HOM_Errors.h"
#include <PY/PY_Callback.h>
#include <PY/PY_Python.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_Tuple.h>
#include <vector>

class HOM_AssetGalleryDataSource;
class HOM_Bookmark;
class HOM_Desktop;
class HOM_Dialog;
class HOM_FloatingPanel;
class HOM_Node;
class HOM_NodeType;
class HOM_Pane;
class HOM_PaneTab;
class HOM_ParameterEditor;
class HOM_RadialItem;
class HOM_RadialMenu;
class HOM_RadialScriptItem;
class HOM_RopNode;
class HOM_ShellIO;
class HOM_SopNodeType;
class HOM_Tool;
class HOM_ViewerStateMenu;
class HOM_ViewerStateTemplate;

SWIGOUT(%rename(ui) HOM_ui;)
class HOM_API HOM_ui
{
public:
    virtual ~HOM_ui()
    {}

    virtual std::string __repr__() = 0;

    virtual HOM_ShellIO &shellIO() = 0;

    SWIGOUT(%newobject curDesktop;)
    virtual HOM_Desktop* curDesktop() = 0;
    SWIGOUT(%newobject desktop;)
    virtual HOM_Desktop* desktop(const char *name) = 0;

    virtual std::vector<HOM_ElemPtr<HOM_Desktop> > desktops() = 0;
    virtual std::vector<std::string> desktopNames() = 0;

    virtual HOM_RadialMenu* radialMenu(const std::string &name) = 0;
    virtual std::vector<HOM_ElemPtr<HOM_RadialMenu> > radialMenus() = 0;
    virtual HOM_RadialMenu* createRadialMenu(
            const std::string &name,
            const char *label) = 0;

    SWIGOUT(%kwargs createRadialItem;)
    SWIGOUT(%newobject createRadialItem;)
    virtual HOM_RadialScriptItem* createRadialItem(
            bool submenu=false,
            bool callback=false) = 0;

    virtual void injectRadialItem(int location, HOM_RadialItem* item) = 0;
    virtual void injectRadialMenu(const std::string &name) = 0;
    virtual void setDefaultRadialSubmenu(int location) = 0;

    virtual std::string _getActiveRadialMenu() = 0;
    virtual void _setActiveRadialMenu(const std::string &name) = 0;

    virtual void _redrawAllWindows() = 0;

    virtual void updateMainMenuBar() = 0;
    virtual std::vector<HOM_ElemPtr<HOM_Pane> > panes() = 0;
    virtual std::vector<HOM_ElemPtr<HOM_PaneTab> > paneTabs() = 0;

    virtual std::vector<HOM_ElemPtr<HOM_PaneTab> > currentPaneTabs() = 0;

    SWIGOUT(%newobject paneTabOfType;)
    virtual HOM_PaneTab *paneTabOfType(HOM_EnumValue &type, int index=0) = 0;

    SWIGOUT(%newobject findPane;)
    virtual HOM_Pane *findPane(int pane_id) = 0;

    SWIGOUT(%newobject findPaneTab;)
    virtual HOM_PaneTab *findPaneTab(const char *name) = 0;

    virtual std::vector<HOM_ElemPtr<HOM_PaneTab> > floatingPaneTabs() = 0;

    virtual std::vector<HOM_ElemPtr<HOM_FloatingPanel> > floatingPanels() = 0;

    SWIGOUT(%newobject paneUnderCursor;)
    virtual HOM_Pane *paneUnderCursor() = 0;
    SWIGOUT(%newobject paneTabUnderCursor;)
    virtual HOM_PaneTab *paneTabUnderCursor() = 0;

    virtual bool isUserInteracting() = 0;
    virtual void setUserInteracting(bool interacting) = 0;

    virtual HOM_EnumValue &orientationUpAxis() = 0;
    virtual HOM_EnumValue &handleOrientToNormalAxis() = 0;

    SWIGOUT(%kwargs displayConfirmation;)
    virtual bool displayConfirmation(
            const char *text,
            HOM_EnumValue &severity = HOM_severityType::Message,
            const char *help = NULL,
            const char *title = NULL,
            const char *details = NULL,
            const char *details_label = NULL,
            HOM_EnumValue &suppress = HOM_confirmType::OverwriteFile) = 0;

    SWIGOUT(%kwargs displayCustomConfirmation;)
    virtual int displayCustomConfirmation(
            const char *text,
            const std::vector<std::string> &buttons =
                std::vector<std::string>(),
            HOM_EnumValue &severity = HOM_severityType::Message,
            int default_choice = 0,
            int close_choice = -1,
            const char *help = NULL,
            const char *title = NULL,
            const char *details = NULL,
            const char *details_label = NULL,
            HOM_EnumValue &suppress = HOM_confirmType::OverwriteFile) = 0;

    SWIGOUT(%kwargs displayMessage;)
    virtual int displayMessage(
            const char *text,
            const std::vector<std::string> &buttons =
                std::vector<std::string>(1, "OK"),
            HOM_EnumValue &severity = HOM_severityType::Message,
            int default_choice = 0,
            int close_choice = -1,
            const char *help = NULL,
            const char *title = NULL,
            const char *details = NULL,
            const char *details_label = NULL,
            bool details_expanded = false,
            HOM_EnumValue& suppress = HOM_confirmType::NoConfirmType) = 0;

    SWIGOUT(%kwargs readInput;)
    virtual std::pair<int, std::string> readInput(
            const char *message,
            const std::vector<std::string> &buttons =
                std::vector<std::string>(1, "OK"),
            HOM_EnumValue &severity = HOM_severityType::Message,
            int default_choice = 0,
            int close_choice = -1,
            const char *help = NULL,
            const char *title = NULL,
            const char *initial_contents = NULL) = 0;

    SWIGOUT(%kwargs readMultiInput;)
    virtual std::pair<int, std::vector<std::string> > readMultiInput(
            const char *message,
            const std::vector<std::string> &input_labels,
            const std::vector<int> &password_input_indices = std::vector<int>(),
            const std::vector<std::string> &buttons =
                std::vector<std::string>(1, "OK"),
            HOM_EnumValue &severity = HOM_severityType::Message,
            int default_choice = 0,
            int close_choice = -1,
            const char *help = NULL,
            const char *title = NULL,
            const std::vector<std::string> &initial_contents =
                std::vector<std::string>() ) = 0;

    SWIGOUT(%kwargs selectFromList;)
    virtual std::vector<int> selectFromList(
            const std::vector<std::string> &choices,
            const std::vector<int> &default_choices = std::vector<int>(),
            bool exclusive = false,
            const char *message = NULL,
            const char *title = NULL,
            const char *column_header = "Choices",
            int num_visible_rows = 10,
            bool clear_on_cancel = false,
            int width = 0,
            int height = 0,
            bool sort = false,
            bool condense_paths = false) = 0;

    SWIGOUT(%kwargs selectFromTree;)
    virtual std::vector<std::string> selectFromTree(
            const std::vector<std::string> &choices,
            const std::vector<std::string> &picked = std::vector<std::string>(),
            bool exclusive = false,
            const char *message = NULL,
            const char *title = NULL,
            bool clear_on_cancel = false,
            int width = 0,
            int height = 0,
            bool allow_branch_selection = false,
            bool allow_compound_selection = true
            ) = 0;

    SWIGOUT(%kwargs _selectFile;)
    virtual std::string _selectFile(
            const char *start_directory = NULL,
            const char *title = NULL,
            bool collapse_sequences = false,
            HOM_EnumValue &file_type = HOM_fileType::Any,
            const std::vector<HOM_EnumValue *>&
                file_types = {&HOM_fileType::Any},
            const char *pattern = NULL,
            const char *default_value = NULL,
            bool multiple_select = false,
            bool image_chooser = false,
            bool ignore_preferences = false,
            HOM_EnumValue &chooser_mode = HOM_fileChooserMode::ReadAndWrite,
            int width = 0,
            int height = 0) = 0;

    SWIGOUT(%ignore _selectNodeInternal;)
    virtual std::vector<std::string> _selectNodeInternal(
            HOM_Node *relative_to_node = NULL,
            HOM_Node *initial_node = NULL,
            HOM_EnumValue *node_type_filter = NULL,
            const char *title = NULL,
            int width = 0,
            int height = 0,
            bool multiple_select = false,
            void *custom_node_filter_callback = nullptr) = 0;

    // This method is deprecated. Use selectNode() instead.
    SWIGOUT(%ignore _selectMultipleNodes;)
    virtual std::vector<std::string> _selectMultipleNodes(
        HOM_Node *relative_to_node = NULL,
        HOM_Node *initial_node = NULL,
        HOM_EnumValue *node_type_filter = NULL,
        const char *title = NULL, 
        int width = 0,
        int height = 0,
        void *custom_node_filter_callback = nullptr) = 0;

    SWIGOUT(%ignore _selectNodeDataInternal;)
    virtual std::vector<std::string> _selectNodeDataInternal(
            const char *title = NULL,
            const char *message = NULL,
            int width = 0,
            int height = 0,
            const std::vector<std::string> &
                initial_selection = std::vector<std::string>(),
            HOM_EnumValue *node_type_filter = nullptr,
            bool multiple_select = false,
            bool include_data_type_headers = true,
            bool include_parms=true,
            bool include_object_transforms=true,
            bool include_geometry_bounding_boxes=true,
            bool include_geometry_attributes=true,
            bool expand_components=true,
            void *custom_data_callback=nullptr,
            void *custom_node_filter_callback = nullptr,
            const char *help_url=nullptr) = 0;

    SWIGOUT(%kwargs selectParmTag;)
    virtual std::vector<std::string> selectParmTag(
            int width = 0,
            int height = 0) = 0;

    SWIGOUT(%kwargs selectParm;)
    virtual std::vector<std::string> selectParm(
            HOM_NodeTypeCategory *category = NULL,
            bool bound_parms_only = false,
            HOM_Node *relative_to_node = NULL,
            const char *message = NULL,
            const char *title = NULL,
            const std::vector<std::string> &
                    initial_parms = std::vector<std::string>(),
            bool multiple_select = true,
            int width = 0,
            int height = 0) = 0;

    SWIGOUT(%kwargs selectParmTuple;)
    virtual std::vector<std::string> selectParmTuple(
            HOM_NodeTypeCategory *category = NULL,
            bool bound_parms_only = false,
            HOM_Node *relative_to_node = NULL,
            const char *message = NULL,
            const char *title = NULL,
            const std::vector<std::string> &
                    initial_parm_tuples = std::vector<std::string>(),
            bool multiple_select = true,
            int width = 0,
            int height = 0) = 0;

    SWIGOUT(%kwargs selectColor;)
    SWIGOUT(%newobject selectColor;)
    virtual HOM_Color *selectColor(HOM_Color *initial_color = NULL,
        std::map<std::string, hboost::any> const& options =
            std::map<std::string, hboost::any>()) = 0;

    SWIGOUT(%kwargs selectRawColor;)
    SWIGOUT(%newobject selectRawColor;)
    HOM_Color *selectRawColor(HOM_Color *initial_color = NULL)
    {
        std::map<std::string, hboost::any> options;
        options["ocio_pick_raw"] = true;
        options["ocio_show_info"] = false;
        options["apply_color_correction"] = false;

        return selectColor(initial_color, options);
    }

    SWIGOUT(%ignore _openBookmarkEditor;)
    SWIGOUT(%kwargs _openBookmarkEditor;)
    virtual void _openBookmarkEditor(HOM_Bookmark *bookmark) = 0;

    SWIGOUT(%kwargs _openColorEditor;)
    virtual void _openColorEditor(
            void *color_changed_callback, bool include_alpha=false, 
            HOM_Color *initial_color=nullptr, float initial_alpha=1.0f,
            std::map<std::string, hboost::any> const& options = 
            std::map<std::string, hboost::any>()) = 0;

    SWIGOUT(%newobject _pickScreenColorMac;)
    virtual HOM_Color *_pickScreenColorMac() = 0;

    virtual void setColorEditorOptions(
        std::map<std::string, hboost::any> const& options) = 0;

    virtual std::map<std::string, hboost::any> colorEditorOptions() = 0;

    virtual std::vector<HOM_Color> loadPaletteFile(const char *file) = 0;
    virtual void savePaletteFile(const char *file,
            const std::vector<HOM_Color> &colors) = 0;

    virtual std::vector<double> _coloreditorRead(int64 token) = 0;
    virtual bool _coloreditorWrite(
        int64 token, const std::vector<double> &values,
        HOM_EnumValue &reason = HOM_uiEventReason::Changed,
        const char *node_path = nullptr,
        bool write_separately = false) = 0;
    virtual void _coloreditorUnbind(int64 token) = 0;

    virtual std::vector<std::string> _loadImagesFile(const char *file) = 0;
    virtual void _saveImagesFile(const char *file,
        const std::vector<std::string> &images) = 0;

    SWIGOUT(%ignore _openValueLadder;)
    SWIGOUT(%kwargs _openValueLadder;)
    virtual void _openValueLadder(
            float initial_value, void *value_changed_callback,
            HOM_EnumValue &type=HOM_valueLadderType::Generic, 
            HOM_EnumValue &data_type=HOM_valueLadderDataType::Float) = 0;
    virtual void updateValueLadder(
            int cursor_x, int cursor_y, bool alt_key, bool shift_key) = 0;
    virtual void closeValueLadder() = 0;

    SWIGOUT(%kwargs displayFileDependencyDialog;)
    virtual UT_Tuple<bool, 
                std::vector<std::pair<HOM_ElemPtr<HOM_Parm>, std::string> > >
        displayFileDependencyDialog(
            HOM_Node *rop_node = NULL,
            const std::vector<std::string> &uploaded_files =
                std::vector<std::string>(),
            const std::vector<std::string> &forced_unselected_patterns =
                std::vector<std::string>(),
            const char *project_dir_variable="HIP",
            bool is_standalone=true) = 0;

    virtual void displayNodeHelp(HOM_NodeType &node_type) = 0;
    virtual void _openTypePropertiesDialogForNode(
            HOM_Node &node, bool promote_spare_parms,
            bool immediately_save) = 0;
    virtual void _openTypePropertiesDialogForNodeType(
            HOM_NodeType &node_type, bool promote_spare_parms,
            bool immediately_save) = 0;

    virtual void openRenderDialog(HOM_RopNode &rop) = 0;

    virtual void openRenameSelectedDialog(HOM_Node &network) = 0;

    SWIGOUT(%kwargs openParameterInterfaceDialog;)
    virtual void openParameterInterfaceDialog(HOM_Node &node,
            HOM_EnumValue *open_tab = nullptr,
            const char *open_tab_tree_path = nullptr) = 0;

    virtual HOM_EnumValue &updateMode() = 0;
    SWIGOUT(%ignore addOpaqueTriggerUpdateCallback;)
    virtual void addOpaqueTriggerUpdateCallback(void *py_callback) = 0;
    SWIGOUT(%ignore removeOpaqueTriggerUpdateCallback;)
    virtual void removeOpaqueTriggerUpdateCallback(void *py_callback) = 0;

    virtual void setUpdateMode(HOM_EnumValue &mode) = 0;
    virtual void triggerUpdate() = 0;
    virtual void reloadViewportColorSchemes() = 0;
    virtual void reloadColorScheme() = 0;
    virtual std::string currentColorScheme() = 0;

    virtual bool isAutoKey() = 0;

    virtual std::vector<int> _getTabMenuIconSize() = 0;

    SWIGOUT(%ignore addOpaqueSelectionCallback;)
    virtual void addOpaqueSelectionCallback(void *py_callback) = 0;
    SWIGOUT(%ignore removeOpaqueSelectionCallback;)
    virtual void removeOpaqueSelectionCallback(void *py_callback) = 0;
    virtual void removeAllSelectionCallbacks() = 0;
    SWIGOUT(%ignore opaqueSelectionCallbacks;)
    virtual std::vector<void *> opaqueSelectionCallbacks() = 0;

    SWIGOUT(%ignore addOpaqueEventLoopCallback;)
    virtual void addOpaqueEventLoopCallback(void *callback) = 0;
    SWIGOUT(%ignore removeOpaqueEventLoopCallback;)
    virtual void removeOpaqueEventLoopCallback(void *callback) = 0;
    SWIGOUT(%ignore opaqueEventLoopCallbacks;)
    virtual std::vector<void *> opaqueEventLoopCallbacks() = 0;
    SWIGOUT(%ignore postOpaqueEventCallback;)
    virtual void postOpaqueEventCallback(void *callback) = 0;
    SWIGOUT(%ignore removePostedOpaqueEventCallback;)
    virtual void removePostedOpaqueEventCallback(void *callback) = 0;

    virtual void postRedrawFence() = 0;

    SWIGOUT(%newobject createDialog;)
    virtual HOM_Dialog *createDialog(const char *ui_file_name) = 0;
    SWIGOUT(%newobject findDialog;)
    virtual HOM_Dialog *findDialog(const char *ui_file_name) = 0;
    virtual std::vector<HOM_ElemPtr<HOM_Dialog> > dialogs() = 0;

    SWIGOUT(%ignore opaqueWaitUntil;)
    virtual void opaqueWaitUntil(void *condition_callback) = 0;

    SWIGOUT(%kwargs writePythonShellHistoryFile;)
    virtual void writePythonShellHistoryFile(const char *filename=NULL) = 0;

    SWIGOUT(%kwargs readPythonShellHistoryFile;)
    virtual void readPythonShellHistoryFile(const char *filename=NULL) = 0;

    SWIGOUT(%kwargs setStatusMessage;)
    virtual void setStatusMessage(
            const char *message,
            HOM_EnumValue &severity=HOM_severityType::Message) = 0;
    virtual std::pair<std::string, HOM_EnumValue *> statusMessage() = 0;

    virtual bool _processEvents() = 0;

    virtual void openAssetUploadDialog(
            HOM_Node *uploading_node, const char *session_key,
            HOM_Node *containing_node) = 0;

    virtual void openAssetDependenciesDialog(
            const std::vector<HOM_Node *> &uploading_nodes,
            const std::vector<HOM_Node *> &uploaded_nodes,
            const char *session_key,
            HOM_Node *containing_node) = 0;

    virtual bool hasDragSourceData(const char *label) = 0;
    SWIGOUT(%kwargs getDragSourceData;)
    virtual HOM_DDSourceAny getDragSourceData(const char *label, int index=0) = 0;

    virtual std::string resourceValueFromName(const char *name) = 0;
    virtual HOM_Color colorFromName(const char *name) = 0;

    virtual double globalScaleFactor() = 0;
    virtual int scaledSize(int size) = 0;

    virtual double inchesToPixels(double inches) = 0;
    virtual double pixelsToInches(double pixels) = 0;

    virtual void copyTextToClipboard(const char *text) = 0;
    virtual std::string getTextFromClipboard() = 0;

    virtual std::vector<std::string> hotkeys(const char *hotkey_symbol) = 0;
    virtual std::string hotkeyDescription(const char *hotkey_symbol) = 0;
    virtual bool isKeyMatch(const char *key, const char *hotkey_symbol) = 0;

    virtual std::string _geoSpreadsheetCellText(int sheet_id, int row, int col) = 0;
    virtual void openCaptureWeightSpreadsheet(HOM_Node *node, 
                                              const char *pattern = NULL) = 0;
    virtual std::string _openCaptureWeightSpreadsheet2(HOM_Node* node) = 0;

    virtual void _closeCaptureWeightSpreadsheet(const std::string &identifier) = 0;

    virtual void registerViewerState(HOM_ViewerStateTemplate& vs_templ) = 0;
    virtual void registerViewerStateFile(std::string const& state_file) = 0;
    virtual void registerViewerStates() = 0;
    virtual void unregisterViewerState(std::string const& state_typename) = 0;
    virtual void unregisterViewerStateFile(std::string const& state_file) = 0;
    virtual bool isRegisteredViewerState(std::string const& state_name) = 0;
    virtual void reloadViewerState(std::string const& state_typename) = 0;
    SWIGOUT(%kwargs reloadViewerStates;)
    virtual void reloadViewerStates(std::vector<std::string> const& state_names=std::vector<std::string>()) = 0;

    SWIGOUT(%kwargs viewerStateInfo;)
    virtual std::string viewerStateInfo(std::vector<std::string> const& state_names=std::vector<std::string>()) = 0;
    virtual UT_Tuple<std::string, std::string> viewerStateInfoFromFile(std::string const& state_file) = 0;

    SWIGOUT(%kwargs viewerHandleInfo;)
    virtual std::string viewerHandleInfo(std::vector<std::string> const& handle_names=std::vector<std::string>()) = 0;

    SWIGOUT(%kwargs printResourceMessage;)
    virtual void printResourceMessage(
        HOM_EnumValue &resource_type,
        std::string const &message,
        HOM_EnumValue &message_type = HOM_severityType::Message) = 0;
    SWIGOUT(%kwargs fireResourceCustomEvent;)
    virtual void fireResourceCustomEvent(
        HOM_EnumValue &resource_type,
        std::map<std::string, hboost::any> const &user_data,
        bool queue = true) = 0;

    SWIGOUT(%ignore _openViewerStateCodeGenDialog;)
    SWIGOUT(%kwargs _openViewerStateCodeGenDialog;)
    virtual void _openViewerStateCodeGenDialog(
        HOM_NodeTypeCategory const &category,
        void *action_callback,
        std::string const &op_name = std::string()) = 0;

    SWIGOUT(%ignore addOpaqueResourceEventCallback;)
    virtual void addOpaqueResourceEventCallback(void *py_callback) = 0;
    SWIGOUT(%ignore removeOpaqueResourceEventCallback;)
    virtual void removeOpaqueResourceEventCallback(void *py_callback) = 0;

    SWIGOUT(%ignore _openFileEditor;)
    SWIGOUT(%kwargs _openFileEditor;)
    virtual void _openFileEditor(
        std::string const &title,
        std::string const &file_path,
        void *action_callback = nullptr,
        std::map<std::string, hboost::any> const &params =
            std::map<std::string, hboost::any>()) = 0;

    virtual void showInFileBrowser(const char *file_path) = 0;

    SWIGOUT(%newobject showFloatingParameterEditor;)
    virtual HOM_ParameterEditor* showFloatingParameterEditor(HOM_Node *node, bool reuse=true ) = 0;

    virtual void openParameterExpressionEditor(HOM_Parm *parm) = 0;
    virtual void openPreferences(const char *page, const char *label) = 0;

    virtual bool hideAllMinimizedStowbars() = 0;
    virtual void setHideAllMinimizedStowbars(bool hide) = 0;

    virtual void setFullscreen(bool fullscreen) = 0;
    virtual bool isFullscreen() = 0;
    virtual void toggleFullscreen() = 0;

    // Viewer Handles
    virtual void registerViewerHandle(HOM_ViewerHandleTemplate& tmpl) = 0;
    virtual void registerViewerHandles() = 0;
    virtual void registerViewerHandleFile(std::string const& handle_file) = 0;
    virtual void unregisterViewerHandle(std::string const& handle_name) = 0;
    virtual void unregisterViewerHandleFile(std::string const& handle_file) = 0;
    virtual bool isRegisteredViewerHandle(std::string const& handle_name) = 0;
    virtual void reloadViewerHandle(std::string const& handle_name) = 0;

    virtual void loadPackage(std::string const& package_filepath) = 0;
    SWIGOUT(%kwargs loadPackageArchive;)
    virtual std::vector<std::string> loadPackageArchive(std::string const& filepath, std::string const& extract_path=std::string()) = 0;
    SWIGOUT(%kwargs unloadPackage;)
    virtual void unloadPackage(std::string const& package_filepath, bool force_unload=false) = 0;
    virtual void reloadPackage(std::string const& package_filepath) = 0;
    virtual void activatePackage(std::string const& package_filepath) = 0;
    virtual void deactivatePackage(std::string const& package_filepath) = 0;
    virtual std::string packageInfo(std::vector<std::string> const& package_filepaths=std::vector<std::string>()) = 0;

    SWIGOUT(%ignore _openViewerHandleCodeGenDialog;)
    SWIGOUT(%kwargs _openViewerHandleCodeGenDialog;)
    virtual void _openViewerHandleCodeGenDialog(
        HOM_NodeTypeCategory const &category, void *action_callback) = 0;

    // Asset catalog global methods.
    SWIGOUT(%newobject sharedAssetGalleryDataSource;)
    virtual HOM_AssetGalleryDataSource *sharedAssetGalleryDataSource(const char *gallery_name) = 0;
    virtual void setSharedAssetGalleryDataSource(
            HOM_AssetGalleryDataSource *data_source,
            const char *gallery_name)
            = 0;
    virtual void reloadSharedAssetGalleryDataSource(const char *gallery_name) = 0;
    virtual std::vector<HOM_ElemPtr<HOM_Tool>> _toolsWithFilter(const char *filter) = 0;

#ifdef SWIG
%extend
{
    SWIGOUT(%kwargs _selectNodeData;)
    std::vector<std::string> _selectNodeData(
            const char *title = NULL,
            const char *message = NULL,
            int width = 0,
            int height = 0,
            const std::vector<std::string> &
                initial_selection = std::vector<std::string>(),
            HOM_EnumValue *node_type_filter = nullptr,
            bool multiple_select = false,
            bool include_data_type_headers = true,
            bool include_parms=true,
            bool include_object_transforms=true,
            bool include_geometry_bounding_boxes=true,
            bool include_geometry_attributes=true,
            bool expand_components=true,
            InterpreterObject custom_data_callback=nullptr,
            InterpreterObject custom_node_filter_callback=nullptr,
            const char *help_url=nullptr)
    {
        if (custom_data_callback && custom_data_callback == Py_None)
            custom_data_callback = nullptr;

        if (custom_node_filter_callback && custom_node_filter_callback == Py_None)
            custom_node_filter_callback = nullptr;

        return self->_selectNodeDataInternal(
            title,
            message,
            width,
            height,
            initial_selection,
            node_type_filter,
            multiple_select,
            include_data_type_headers,
            include_parms,
            include_object_transforms,
            include_geometry_bounding_boxes,
            include_geometry_attributes,
            expand_components,
            custom_data_callback,
            custom_node_filter_callback,
            help_url
        );
    }

    SWIGOUT(%kwargs _selectNode;)
    std::vector<std::string> _selectNode(
            HOM_Node *relative_to_node = NULL,
            HOM_Node *initial_node = NULL,
            HOM_EnumValue *node_type_filter = NULL,
            const char *title = NULL,
            int width = 0,
            int height = 0,
            bool multiple_select = false,
            InterpreterObject custom_node_filter_callback = nullptr)
    {
        if (custom_node_filter_callback && custom_node_filter_callback == Py_None)
            custom_node_filter_callback = nullptr;

        return self->_selectNodeInternal(
            relative_to_node,
            initial_node,
            node_type_filter,
            title,
            width,
            height,
            multiple_select,
            custom_node_filter_callback
        );
    }

    // This method is deprecated. Use selectNode() instead.
    SWIGOUT(%kwargs selectMultipleNodes;)
    std::vector<std::string> selectMultipleNodes(
            HOM_Node *relative_to_node = NULL,
            HOM_Node *initial_node = NULL,
            HOM_EnumValue *node_type_filter = NULL,
            const char *title = NULL,
            int width = 0,
            int height = 0,
            InterpreterObject custom_node_filter_callback = nullptr)
    {
        if (custom_node_filter_callback && custom_node_filter_callback == Py_None)
            custom_node_filter_callback = nullptr;

        return self->_selectMultipleNodes(
            relative_to_node,
            initial_node,
            node_type_filter,
            title,
            width,
            height,
            custom_node_filter_callback
        );
    }

    SWIGOUT(%kwargs openBookmarkEditor;)
    void openBookmarkEditor(HOM_Bookmark *bookmark=nullptr)
    { self->_openBookmarkEditor(bookmark); }

    SWIGOUT(%kwargs openColorEditor;)
    void openColorEditor(
        InterpreterObject color_changed_callback,
        bool include_alpha=false,
        HOM_Color *initial_color=nullptr,
        float initial_alpha=1.0f,
        std::map<std::string, hboost::any> const& options =
            std::map<std::string, hboost::any>()
        )
    {
        self->_openColorEditor(
            color_changed_callback,
            include_alpha,
            initial_color,
            initial_alpha,
            options);
    }

    SWIGOUT(%kwargs openColorEditor;)
    void openRawColorEditor(
        InterpreterObject color_changed_callback,
        bool include_alpha=false,
        HOM_Color *initial_color=nullptr,
        float initial_alpha=1.0f
        )
    {
        std::map<std::string, hboost::any> options;
        options["ocio_pick_raw"] = true;
        options["ocio_show_info"] = false;
        options["apply_color_correction"] = false;

        self->_openColorEditor(
            color_changed_callback,
            include_alpha,
            initial_color,
            initial_alpha,
            options);
    }

    SWIGOUT(%kwargs openValueLadder;)
    void openValueLadder(
        float initial_value, 
        InterpreterObject value_changed_callback, 
        HOM_EnumValue &type=HOM_valueLadderType::Generic, 
        HOM_EnumValue &data_type=HOM_valueLadderDataType::Float)
    { self->_openValueLadder(
        initial_value, value_changed_callback, type, data_type); }

    void addEventLoopCallback(InterpreterObject callback)
    { self->addOpaqueEventLoopCallback(callback); }

    void removeEventLoopCallback(InterpreterObject callback)
    { self->removeOpaqueEventLoopCallback(callback); }

    void postEventCallback(InterpreterObject callback)
    { self->postOpaqueEventCallback(callback); }
    void removePostedEventCallback(InterpreterObject callback)
    { self->removePostedOpaqueEventCallback(callback); }

    // Note that we return a vector of borrowed references because swig
    // will increment the reference counts.
    std::vector<InterpreterObject> eventLoopCallbacks()
    {
        std::vector<void *> opaque_callbacks(self->opaqueEventLoopCallbacks());

        std::vector<InterpreterObject> callbacks;
        for (int i=0; i< opaque_callbacks.size(); ++i)
            callbacks.push_back((InterpreterObject)opaque_callbacks[i]);
        return callbacks;
    }

    void waitUntil(InterpreterObject callback)
    { self->opaqueWaitUntil(callback); }

    void addTriggerUpdateCallback(InterpreterObject callback)
    { self->addOpaqueTriggerUpdateCallback(callback); }

    void removeTriggerUpdateCallback(InterpreterObject callback)
    { self->removeOpaqueTriggerUpdateCallback(callback); }

    void addSelectionCallback(InterpreterObject callback)
    { self->addOpaqueSelectionCallback(callback); }

    void removeSelectionCallback(InterpreterObject callback)
    { self->removeOpaqueSelectionCallback(callback); }

    std::vector<InterpreterObject> selectionCallbacks()
    {
        std::vector<void *> opaque_callbacks = self->opaqueSelectionCallbacks();
        std::vector<InterpreterObject> callbacks;

        for (int i = 0, n = opaque_callbacks.size(); i < n; i++)
            callbacks.push_back((InterpreterObject)opaque_callbacks[i]);

        return callbacks;
    }

    // viewer state events
    void addResourceEventCallback(InterpreterObject callback)
    { 
        self->addOpaqueResourceEventCallback(callback); 
    }

    void removeResourceEventCallback(InterpreterObject callback)
    {
        self->removeOpaqueResourceEventCallback(callback); 
    }

    SWIGOUT(%kwargs openFileEditor;)
    void openFileEditor(
        std::string const &                         title, 
        std::string const &                         file_path,
        InterpreterObject                           action_callback = nullptr,
        std::map<std::string, hboost::any> const&   params = 
            std::map<std::string, hboost::any>() )
    {
        self->_openFileEditor(title, file_path, action_callback, params);
    }

    SWIGOUT(%kwargs openViewerStateCodeGenDialog;)
    void openViewerStateCodeGenDialog(
        HOM_NodeTypeCategory const &    category,
        InterpreterObject               action_callback,
        std::string const &             op_name = std::string())
    {
        self->_openViewerStateCodeGenDialog(category, action_callback, op_name);
    }

    SWIGOUT(%kwargs openViewerHandleCodeGenDialog;)
    void openViewerHandleCodeGenDialog(
        HOM_NodeTypeCategory const &    category,
        InterpreterObject               action_callback )
    {
        self->_openViewerHandleCodeGenDialog(category, action_callback);
    }

}
#endif

};

#endif