HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
HOM_ui.h
Go to the documentation of this file.
1 /*
2  * PROPRIETARY INFORMATION. This software is proprietary to
3  * Side Effects Software Inc., and is not to be reproduced,
4  * transmitted, or disclosed in any way without written permission.
5  *
6  * COMMENTS:
7  */
8 
9 #ifndef __HOM_ui_h__
10 #define __HOM_ui_h__
11 
12 #include "HOM_API.h"
13 #include "HOM_Defines.h"
14 #include "HOM_Module.h"
15 #include "HOM_Attrib.h"
16 #include "HOM_EnumValue.h"
17 #include "HOM_EnumModules.h"
18 #include "HOM_Color.h"
19 #include "HOM_Errors.h"
20 #include <PY/PY_Callback.h>
21 #include <PY/PY_Python.h>
22 #include <UT/UT_StringHolder.h>
23 #include <UT/UT_Tuple.h>
24 #include <vector>
25 
27 class HOM_Bookmark;
28 class HOM_Desktop;
29 class HOM_Dialog;
30 class HOM_FloatingPanel;
31 class HOM_Node;
32 class HOM_NodeType;
33 class HOM_Pane;
34 class HOM_PaneTab;
36 class HOM_RadialItem;
37 class HOM_RadialMenu;
39 class HOM_RopNode;
40 class HOM_ShellIO;
41 class HOM_SopNodeType;
42 class HOM_Tool;
45 
46 SWIGOUT(%rename(ui) HOM_ui;)
48 {
49 public:
50  virtual ~HOM_ui()
51  {}
52 
53  virtual std::string __repr__() = 0;
54 
55  virtual HOM_ShellIO &shellIO() = 0;
56 
57  SWIGOUT(%newobject curDesktop;)
58  virtual HOM_Desktop* curDesktop() = 0;
59  SWIGOUT(%newobject desktop;)
60  virtual HOM_Desktop* desktop(const char *name) = 0;
61 
62  virtual std::vector<HOM_ElemPtr<HOM_Desktop> > desktops() = 0;
63 
64  virtual HOM_RadialMenu* radialMenu(const std::string &name) = 0;
65  virtual std::vector<HOM_ElemPtr<HOM_RadialMenu> > radialMenus() = 0;
66  virtual HOM_RadialMenu* createRadialMenu(
67  const std::string &name,
68  const char *label) = 0;
69 
70  SWIGOUT(%kwargs createRadialItem;)
71  SWIGOUT(%newobject createRadialItem;)
72  virtual HOM_RadialScriptItem* createRadialItem(
73  bool submenu=false,
74  bool callback=false) = 0;
75 
76  virtual void injectRadialItem(int location, HOM_RadialItem* item) = 0;
77  virtual void injectRadialMenu(const std::string &name) = 0;
78  virtual void setDefaultRadialSubmenu(int location) = 0;
79 
80  virtual std::string _getActiveRadialMenu() = 0;
81  virtual void _setActiveRadialMenu(const std::string &name) = 0;
82 
83  virtual void updateMainMenuBar() = 0;
84  virtual std::vector<HOM_ElemPtr<HOM_Pane> > panes() = 0;
85  virtual std::vector<HOM_ElemPtr<HOM_PaneTab> > paneTabs() = 0;
86 
87  virtual std::vector<HOM_ElemPtr<HOM_PaneTab> > currentPaneTabs() = 0;
88 
89  SWIGOUT(%newobject paneTabOfType;)
90  virtual HOM_PaneTab *paneTabOfType(HOM_EnumValue &type, int index=0) = 0;
91 
92  SWIGOUT(%newobject findPane;)
93  virtual HOM_Pane *findPane(int pane_id) = 0;
94 
95  SWIGOUT(%newobject findPaneTab;)
96  virtual HOM_PaneTab *findPaneTab(const char *name) = 0;
97 
98  virtual std::vector<HOM_ElemPtr<HOM_PaneTab> > floatingPaneTabs() = 0;
99 
100  virtual std::vector<HOM_ElemPtr<HOM_FloatingPanel> > floatingPanels() = 0;
101 
102  SWIGOUT(%newobject paneUnderCursor;)
103  virtual HOM_Pane *paneUnderCursor() = 0;
104  SWIGOUT(%newobject paneTabUnderCursor;)
105  virtual HOM_PaneTab *paneTabUnderCursor() = 0;
106 
107  virtual bool isUserInteracting() = 0;
108  virtual void setUserInteracting(bool interacting) = 0;
109 
110  virtual HOM_EnumValue &orientationUpAxis() = 0;
111  virtual HOM_EnumValue &handleOrientToNormalAxis() = 0;
112 
113  SWIGOUT(%kwargs displayConfirmation;)
114  virtual bool displayConfirmation(
115  const char *text,
116  HOM_EnumValue &severity = HOM_severityType::Message,
117  const char *help = NULL,
118  const char *title = NULL,
119  const char *details = NULL,
120  const char *details_label = NULL,
121  HOM_EnumValue &suppress = HOM_confirmType::OverwriteFile) = 0;
122 
123  SWIGOUT(%kwargs displayCustomConfirmation;)
124  virtual int displayCustomConfirmation(
125  const char *text,
126  const std::vector<std::string> &buttons =
127  std::vector<std::string>(),
128  HOM_EnumValue &severity = HOM_severityType::Message,
129  int default_choice = 0,
130  int close_choice = -1,
131  const char *help = NULL,
132  const char *title = NULL,
133  const char *details = NULL,
134  const char *details_label = NULL,
135  HOM_EnumValue &suppress = HOM_confirmType::OverwriteFile) = 0;
136 
137  SWIGOUT(%kwargs displayMessage;)
138  virtual int displayMessage(
139  const char *text,
140  const std::vector<std::string> &buttons =
141  std::vector<std::string>(1, "OK"),
142  HOM_EnumValue &severity = HOM_severityType::Message,
143  int default_choice = 0,
144  int close_choice = -1,
145  const char *help = NULL,
146  const char *title = NULL,
147  const char *details = NULL,
148  const char *details_label = NULL,
149  bool details_expanded = false,
150  HOM_EnumValue& suppress = HOM_confirmType::NoConfirmType) = 0;
151 
152  SWIGOUT(%kwargs readInput;)
153  virtual std::pair<int, std::string> readInput(
154  const char *message,
155  const std::vector<std::string> &buttons =
156  std::vector<std::string>(1, "OK"),
157  HOM_EnumValue &severity = HOM_severityType::Message,
158  int default_choice = 0,
159  int close_choice = -1,
160  const char *help = NULL,
161  const char *title = NULL,
162  const char *initial_contents = NULL) = 0;
163 
164  SWIGOUT(%kwargs readMultiInput;)
165  virtual std::pair<int, std::vector<std::string> > readMultiInput(
166  const char *message,
167  const std::vector<std::string> &input_labels,
168  const std::vector<int> &password_input_indices = std::vector<int>(),
169  const std::vector<std::string> &buttons =
170  std::vector<std::string>(1, "OK"),
171  HOM_EnumValue &severity = HOM_severityType::Message,
172  int default_choice = 0,
173  int close_choice = -1,
174  const char *help = NULL,
175  const char *title = NULL,
176  const std::vector<std::string> &initial_contents =
177  std::vector<std::string>() ) = 0;
178 
179  SWIGOUT(%kwargs selectFromList;)
180  virtual std::vector<int> selectFromList(
181  const std::vector<std::string> &choices,
182  const std::vector<int> &default_choices = std::vector<int>(),
183  bool exclusive = false,
184  const char *message = NULL,
185  const char *title = NULL,
186  const char *column_header = "Choices",
187  int num_visible_rows = 10,
188  bool clear_on_cancel = false,
189  int width = 0,
190  int height = 0,
191  bool sort = false,
192  bool condense_paths = false) = 0;
193 
194  SWIGOUT(%kwargs selectFromTree;)
195  virtual std::vector<std::string> selectFromTree(
196  const std::vector<std::string> &choices,
197  const std::vector<std::string> &picked = std::vector<std::string>(),
198  bool exclusive = false,
199  const char *message = NULL,
200  const char *title = NULL,
201  bool clear_on_cancel = false,
202  int width = 0,
203  int height = 0,
204  bool allow_branch_selection = false,
205  bool allow_compound_selection = true
206  ) = 0;
207 
208  SWIGOUT(%kwargs _selectFile;)
209  virtual std::string _selectFile(
210  const char *start_directory = NULL,
211  const char *title = NULL,
212  bool collapse_sequences = false,
213  HOM_EnumValue &file_type = HOM_fileType::Any,
214  const std::vector<HOM_EnumValue *>&
215  file_types = {&HOM_fileType::Any},
216  const char *pattern = NULL,
217  const char *default_value = NULL,
218  bool multiple_select = false,
219  bool image_chooser = false,
220  bool ignore_preferences = false,
221  HOM_EnumValue &chooser_mode = HOM_fileChooserMode::ReadAndWrite,
222  int width = 0,
223  int height = 0) = 0;
224 
225  SWIGOUT(%ignore _selectNodeInternal;)
226  virtual std::vector<std::string> _selectNodeInternal(
227  HOM_Node *relative_to_node = NULL,
228  HOM_Node *initial_node = NULL,
229  HOM_EnumValue *node_type_filter = NULL,
230  const char *title = NULL,
231  int width = 0,
232  int height = 0,
233  bool multiple_select = false,
234  void *custom_node_filter_callback = nullptr) = 0;
235 
236  // This method is deprecated. Use selectNode() instead.
237  SWIGOUT(%ignore _selectMultipleNodes;)
238  virtual std::vector<std::string> _selectMultipleNodes(
239  HOM_Node *relative_to_node = NULL,
240  HOM_Node *initial_node = NULL,
241  HOM_EnumValue *node_type_filter = NULL,
242  const char *title = NULL,
243  int width = 0,
244  int height = 0,
245  void *custom_node_filter_callback = nullptr) = 0;
246 
247  SWIGOUT(%ignore _selectNodeDataInternal;)
248  virtual std::vector<std::string> _selectNodeDataInternal(
249  const char *title = NULL,
250  const char *message = NULL,
251  int width = 0,
252  int height = 0,
253  const std::vector<std::string> &
254  initial_selection = std::vector<std::string>(),
255  HOM_EnumValue *node_type_filter = nullptr,
256  bool multiple_select = false,
257  bool include_data_type_headers = true,
258  bool include_parms=true,
259  bool include_object_transforms=true,
260  bool include_geometry_bounding_boxes=true,
261  bool include_geometry_attributes=true,
262  bool expand_components=true,
263  void *custom_data_callback=nullptr,
264  void *custom_node_filter_callback = nullptr,
265  const char *help_url=nullptr) = 0;
266 
267  SWIGOUT(%kwargs selectParmTag;)
268  virtual std::vector<std::string> selectParmTag(
269  int width = 0,
270  int height = 0) = 0;
271 
272  SWIGOUT(%kwargs selectParm;)
273  virtual std::vector<std::string> selectParm(
274  HOM_NodeTypeCategory *category = NULL,
275  bool bound_parms_only = false,
276  HOM_Node *relative_to_node = NULL,
277  const char *message = NULL,
278  const char *title = NULL,
279  const std::vector<std::string> &
280  initial_parms = std::vector<std::string>(),
281  bool multiple_select = true,
282  int width = 0,
283  int height = 0) = 0;
284 
285  SWIGOUT(%kwargs selectParmTuple;)
286  virtual std::vector<std::string> selectParmTuple(
287  HOM_NodeTypeCategory *category = NULL,
288  bool bound_parms_only = false,
289  HOM_Node *relative_to_node = NULL,
290  const char *message = NULL,
291  const char *title = NULL,
292  const std::vector<std::string> &
293  initial_parm_tuples = std::vector<std::string>(),
294  bool multiple_select = true,
295  int width = 0,
296  int height = 0) = 0;
297 
298  SWIGOUT(%kwargs selectColor;)
299  SWIGOUT(%newobject selectColor;)
300  virtual HOM_Color *selectColor(HOM_Color *initial_color = NULL,
301  std::map<std::string, hboost::any> const& options =
302  std::map<std::string, hboost::any>()) = 0;
303 
304  SWIGOUT(%kwargs selectRawColor;)
305  SWIGOUT(%newobject selectRawColor;)
306  HOM_Color *selectRawColor(HOM_Color *initial_color = NULL)
307  {
308  std::map<std::string, hboost::any> options;
309  options["ocio_pick_raw"] = true;
310  options["ocio_show_info"] = false;
311  options["apply_color_correction"] = false;
312 
313  return selectColor(initial_color, options);
314  }
315 
316  SWIGOUT(%ignore _openBookmarkEditor;)
317  SWIGOUT(%kwargs _openBookmarkEditor;)
318  virtual void _openBookmarkEditor(HOM_Bookmark *bookmark) = 0;
319 
320  SWIGOUT(%kwargs _openColorEditor;)
321  virtual void _openColorEditor(
322  void *color_changed_callback, bool include_alpha=false,
323  HOM_Color *initial_color=nullptr, float initial_alpha=1.0f,
324  std::map<std::string, hboost::any> const& options =
325  std::map<std::string, hboost::any>()) = 0;
326 
327  virtual void setColorEditorOptions(
328  std::map<std::string, hboost::any> const& options) = 0;
329 
330  virtual std::map<std::string, hboost::any> colorEditorOptions() = 0;
331 
332  virtual std::vector<HOM_Color> loadPaletteFile(const char *file) = 0;
333  virtual void savePaletteFile(const char *file,
334  const std::vector<HOM_Color> &colors) = 0;
335 
336  SWIGOUT(%ignore _openValueLadder;)
337  SWIGOUT(%kwargs _openValueLadder;)
338  virtual void _openValueLadder(
339  float initial_value, void *value_changed_callback,
340  HOM_EnumValue &type=HOM_valueLadderType::Generic,
341  HOM_EnumValue &data_type=HOM_valueLadderDataType::Float) = 0;
342  virtual void updateValueLadder(
343  int cursor_x, int cursor_y, bool alt_key, bool shift_key) = 0;
344  virtual void closeValueLadder() = 0;
345 
346  SWIGOUT(%kwargs displayFileDependencyDialog;)
347  virtual UT_Tuple<bool,
348  std::vector<std::pair<HOM_ElemPtr<HOM_Parm>, std::string> > >
349  displayFileDependencyDialog(
350  HOM_Node *rop_node = NULL,
351  const std::vector<std::string> &uploaded_files =
352  std::vector<std::string>(),
353  const std::vector<std::string> &forced_unselected_patterns =
354  std::vector<std::string>(),
355  const char *project_dir_variable="HIP",
356  bool is_standalone=true) = 0;
357 
358  virtual void displayNodeHelp(HOM_NodeType &node_type) = 0;
359  virtual void _openTypePropertiesDialogForNode(
360  HOM_Node &node, bool promote_spare_parms,
361  bool immediately_save) = 0;
362  virtual void _openTypePropertiesDialogForNodeType(
363  HOM_NodeType &node_type, bool promote_spare_parms,
364  bool immediately_save) = 0;
365 
366  virtual void openRenderDialog(HOM_RopNode &rop) = 0;
367 
368  virtual void openRenameSelectedDialog(HOM_Node &network) = 0;
369 
370  SWIGOUT(%kwargs openParameterInterfaceDialog;)
371  virtual void openParameterInterfaceDialog(HOM_Node &node,
372  HOM_EnumValue *open_tab = nullptr,
373  const char *open_tab_tree_path = nullptr) = 0;
374 
375  virtual HOM_EnumValue &updateMode() = 0;
376  SWIGOUT(%ignore addOpaqueTriggerUpdateCallback;)
377  virtual void addOpaqueTriggerUpdateCallback(void *py_callback) = 0;
378  SWIGOUT(%ignore removeOpaqueTriggerUpdateCallback;)
379  virtual void removeOpaqueTriggerUpdateCallback(void *py_callback) = 0;
380 
381  virtual void setUpdateMode(HOM_EnumValue &mode) = 0;
382  virtual void triggerUpdate() = 0;
383  virtual void reloadViewportColorSchemes() = 0;
384  virtual void reloadColorScheme() = 0;
385  virtual std::string currentColorScheme() = 0;
386 
387  virtual bool isAutoKey() = 0;
388 
389  virtual std::vector<int> _getTabMenuIconSize() = 0;
390 
391  SWIGOUT(%ignore addOpaqueSelectionCallback;)
392  virtual void addOpaqueSelectionCallback(void *py_callback) = 0;
393  SWIGOUT(%ignore removeOpaqueSelectionCallback;)
394  virtual void removeOpaqueSelectionCallback(void *py_callback) = 0;
395  virtual void removeAllSelectionCallbacks() = 0;
396  SWIGOUT(%ignore opaqueSelectionCallbacks;)
397  virtual std::vector<void *> opaqueSelectionCallbacks() = 0;
398 
399  SWIGOUT(%ignore addOpaqueEventLoopCallback;)
400  virtual void addOpaqueEventLoopCallback(void *callback) = 0;
401  SWIGOUT(%ignore removeOpaqueEventLoopCallback;)
402  virtual void removeOpaqueEventLoopCallback(void *callback) = 0;
403  SWIGOUT(%ignore opaqueEventLoopCallbacks;)
404  virtual std::vector<void *> opaqueEventLoopCallbacks() = 0;
405  SWIGOUT(%ignore postOpaqueEventCallback;)
406  virtual void postOpaqueEventCallback(void *callback) = 0;
407  SWIGOUT(%ignore removePostedOpaqueEventCallback;)
408  virtual void removePostedOpaqueEventCallback(void *callback) = 0;
409 
410  virtual void postRedrawFence() = 0;
411 
412  SWIGOUT(%newobject createDialog;)
413  virtual HOM_Dialog *createDialog(const char *ui_file_name) = 0;
414  SWIGOUT(%newobject findDialog;)
415  virtual HOM_Dialog *findDialog(const char *ui_file_name) = 0;
416  virtual std::vector<HOM_ElemPtr<HOM_Dialog> > dialogs() = 0;
417 
418  SWIGOUT(%ignore opaqueWaitUntil;)
419  virtual void opaqueWaitUntil(void *condition_callback) = 0;
420 
421  SWIGOUT(%kwargs writePythonShellHistoryFile;)
422  virtual void writePythonShellHistoryFile(const char *filename=NULL) = 0;
423 
424  SWIGOUT(%kwargs readPythonShellHistoryFile;)
425  virtual void readPythonShellHistoryFile(const char *filename=NULL) = 0;
426 
427  SWIGOUT(%kwargs setStatusMessage;)
428  virtual void setStatusMessage(
429  const char *message,
430  HOM_EnumValue &severity=HOM_severityType::Message) = 0;
431  virtual std::pair<std::string, HOM_EnumValue *> statusMessage() = 0;
432 
433  virtual bool _processEvents() = 0;
434 
435  virtual void openAssetUploadDialog(
436  HOM_Node *uploading_node, const char *session_key,
437  HOM_Node *containing_node) = 0;
438 
439  virtual void openAssetDependenciesDialog(
440  const std::vector<HOM_Node *> &uploading_nodes,
441  const std::vector<HOM_Node *> &uploaded_nodes,
442  const char *session_key,
443  HOM_Node *containing_node) = 0;
444 
445  virtual bool hasDragSourceData(const char *label) = 0;
446  SWIGOUT(%kwargs getDragSourceData;)
447  virtual HOM_DDSourceAny getDragSourceData(const char *label, int index=0) = 0;
448 
449  virtual std::string resourceValueFromName(const char *name) = 0;
450  virtual HOM_Color colorFromName(const char *name) = 0;
451 
452  virtual double globalScaleFactor() = 0;
453  virtual int scaledSize(int size) = 0;
454 
455  virtual double inchesToPixels(double inches) = 0;
456  virtual double pixelsToInches(double pixels) = 0;
457 
458  virtual void copyTextToClipboard(const char *text) = 0;
459  virtual std::string getTextFromClipboard() = 0;
460 
461  virtual std::vector<std::string> hotkeys(const char *hotkey_symbol) = 0;
462  virtual std::string hotkeyDescription(const char *hotkey_symbol) = 0;
463  virtual bool isKeyMatch(const char *key, const char *hotkey_symbol) = 0;
464 
465  virtual std::string _geoSpreadsheetCellText(int sheet_id, int row, int col) = 0;
466  virtual void openCaptureWeightSpreadsheet(HOM_Node *node,
467  const char *pattern = NULL) = 0;
468  virtual std::string _openCaptureWeightSpreadsheet2(HOM_Node* node) = 0;
469 
470  virtual void _closeCaptureWeightSpreadsheet(const std::string &identifier) = 0;
471 
472  virtual void registerViewerState(HOM_ViewerStateTemplate& vs_templ) = 0;
473  virtual void registerViewerStateFile(std::string const& state_file) = 0;
474  virtual void registerViewerStates() = 0;
475  virtual void unregisterViewerState(std::string const& state_typename) = 0;
476  virtual void unregisterViewerStateFile(std::string const& state_file) = 0;
477  virtual bool isRegisteredViewerState(std::string const& state_name) = 0;
478  virtual void reloadViewerState(std::string const& state_typename) = 0;
479  SWIGOUT(%kwargs reloadViewerStates;)
480  virtual void reloadViewerStates(std::vector<std::string> const& state_names=std::vector<std::string>()) = 0;
481 
482  SWIGOUT(%kwargs viewerStateInfo;)
483  virtual std::string viewerStateInfo(std::vector<std::string> const& state_names=std::vector<std::string>()) = 0;
484  virtual UT_Tuple<std::string, std::string> viewerStateInfoFromFile(std::string const& state_file) = 0;
485 
486  SWIGOUT(%kwargs viewerHandleInfo;)
487  virtual std::string viewerHandleInfo(std::vector<std::string> const& handle_names=std::vector<std::string>()) = 0;
488 
489  SWIGOUT(%kwargs printResourceMessage;)
490  virtual void printResourceMessage(
491  HOM_EnumValue &resource_type,
492  std::string const &message,
493  HOM_EnumValue &message_type = HOM_severityType::Message) = 0;
494  SWIGOUT(%kwargs fireResourceCustomEvent;)
495  virtual void fireResourceCustomEvent(
496  HOM_EnumValue &resource_type,
497  std::map<std::string, hboost::any> const &user_data,
498  bool queue = true) = 0;
499 
500  SWIGOUT(%ignore _openViewerStateCodeGenDialog;)
501  SWIGOUT(%kwargs _openViewerStateCodeGenDialog;)
502  virtual void _openViewerStateCodeGenDialog(
503  HOM_NodeTypeCategory const &category,
504  void *action_callback,
505  std::string const &op_name = std::string()) = 0;
506 
507  SWIGOUT(%ignore addOpaqueResourceEventCallback;)
508  virtual void addOpaqueResourceEventCallback(void *py_callback) = 0;
509  SWIGOUT(%ignore removeOpaqueResourceEventCallback;)
510  virtual void removeOpaqueResourceEventCallback(void *py_callback) = 0;
511 
512  SWIGOUT(%ignore _openFileEditor;)
513  SWIGOUT(%kwargs _openFileEditor;)
514  virtual void _openFileEditor(
515  std::string const &title,
516  std::string const &file_path,
517  void *action_callback = nullptr,
518  std::map<std::string, hboost::any> const &params =
519  std::map<std::string, hboost::any>()) = 0;
520 
521  virtual void showInFileBrowser(const char *file_path) = 0;
522 
523  SWIGOUT(%newobject showFloatingParameterEditor;)
524  virtual HOM_ParameterEditor* showFloatingParameterEditor(HOM_Node *node, bool reuse=true ) = 0;
525 
526  virtual void openParameterExpressionEditor(HOM_Parm *parm) = 0;
527  virtual void openPreferences(const char *page, const char *label) = 0;
528 
529  virtual bool hideAllMinimizedStowbars() = 0;
530  virtual void setHideAllMinimizedStowbars(bool hide) = 0;
531 
532  // Viewer Handles
533  virtual void registerViewerHandle(HOM_ViewerHandleTemplate& tmpl) = 0;
534  virtual void registerViewerHandles() = 0;
535  virtual void registerViewerHandleFile(std::string const& handle_file) = 0;
536  virtual void unregisterViewerHandle(std::string const& handle_name) = 0;
537  virtual void unregisterViewerHandleFile(std::string const& handle_file) = 0;
538  virtual bool isRegisteredViewerHandle(std::string const& handle_name) = 0;
539  virtual void reloadViewerHandle(std::string const& handle_name) = 0;
540 
541  virtual void loadPackage(std::string const& package_filepath) = 0;
542  SWIGOUT(%kwargs loadPackageArchive;)
543  virtual std::vector<std::string> loadPackageArchive(std::string const& filepath, std::string const& extract_path=std::string()) = 0;
544  SWIGOUT(%kwargs unloadPackage;)
545  virtual void unloadPackage(std::string const& package_filepath, bool force_unload=false) = 0;
546  virtual void reloadPackage(std::string const& package_filepath) = 0;
547  virtual void activatePackage(std::string const& package_filepath) = 0;
548  virtual void deactivatePackage(std::string const& package_filepath) = 0;
549  virtual std::string packageInfo(std::vector<std::string> const& package_filepaths=std::vector<std::string>()) = 0;
550 
551  SWIGOUT(%ignore _openViewerHandleCodeGenDialog;)
552  SWIGOUT(%kwargs _openViewerHandleCodeGenDialog;)
553  virtual void _openViewerHandleCodeGenDialog(
554  HOM_NodeTypeCategory const &category, void *action_callback) = 0;
555 
556  // Asset catalog global methods.
557  SWIGOUT(%newobject sharedAssetGalleryDataSource;)
558  virtual HOM_AssetGalleryDataSource *sharedAssetGalleryDataSource(const char *gallery_name) = 0;
559  virtual void setSharedAssetGalleryDataSource(
560  HOM_AssetGalleryDataSource *data_source,
561  const char *gallery_name)
562  = 0;
563  virtual void reloadSharedAssetGalleryDataSource(const char *gallery_name) = 0;
564  virtual std::vector<HOM_ElemPtr<HOM_Tool>> _toolsWithFilter(const char *filter) = 0;
565 
566 #ifdef SWIG
567 %extend
568 {
569  SWIGOUT(%kwargs _selectNodeData;)
570  std::vector<std::string> _selectNodeData(
571  const char *title = NULL,
572  const char *message = NULL,
573  int width = 0,
574  int height = 0,
575  const std::vector<std::string> &
576  initial_selection = std::vector<std::string>(),
577  HOM_EnumValue *node_type_filter = nullptr,
578  bool multiple_select = false,
579  bool include_data_type_headers = true,
580  bool include_parms=true,
581  bool include_object_transforms=true,
582  bool include_geometry_bounding_boxes=true,
583  bool include_geometry_attributes=true,
584  bool expand_components=true,
585  InterpreterObject custom_data_callback=nullptr,
586  InterpreterObject custom_node_filter_callback=nullptr,
587  const char *help_url=nullptr)
588  {
589  if (custom_data_callback && custom_data_callback == Py_None)
590  custom_data_callback = nullptr;
591 
592  if (custom_node_filter_callback && custom_node_filter_callback == Py_None)
593  custom_node_filter_callback = nullptr;
594 
595  return self->_selectNodeDataInternal(
596  title,
597  message,
598  width,
599  height,
600  initial_selection,
601  node_type_filter,
602  multiple_select,
603  include_data_type_headers,
604  include_parms,
605  include_object_transforms,
606  include_geometry_bounding_boxes,
607  include_geometry_attributes,
608  expand_components,
609  custom_data_callback,
610  custom_node_filter_callback,
611  help_url
612  );
613  }
614 
615  SWIGOUT(%kwargs _selectNode;)
616  std::vector<std::string> _selectNode(
617  HOM_Node *relative_to_node = NULL,
618  HOM_Node *initial_node = NULL,
619  HOM_EnumValue *node_type_filter = NULL,
620  const char *title = NULL,
621  int width = 0,
622  int height = 0,
623  bool multiple_select = false,
624  InterpreterObject custom_node_filter_callback = nullptr)
625  {
626  if (custom_node_filter_callback && custom_node_filter_callback == Py_None)
627  custom_node_filter_callback = nullptr;
628 
629  return self->_selectNodeInternal(
630  relative_to_node,
631  initial_node,
632  node_type_filter,
633  title,
634  width,
635  height,
636  multiple_select,
637  custom_node_filter_callback
638  );
639  }
640 
641  // This method is deprecated. Use selectNode() instead.
642  SWIGOUT(%kwargs selectMultipleNodes;)
643  std::vector<std::string> selectMultipleNodes(
644  HOM_Node *relative_to_node = NULL,
645  HOM_Node *initial_node = NULL,
646  HOM_EnumValue *node_type_filter = NULL,
647  const char *title = NULL,
648  int width = 0,
649  int height = 0,
650  InterpreterObject custom_node_filter_callback = nullptr)
651  {
652  if (custom_node_filter_callback && custom_node_filter_callback == Py_None)
653  custom_node_filter_callback = nullptr;
654 
655  return self->_selectMultipleNodes(
656  relative_to_node,
657  initial_node,
658  node_type_filter,
659  title,
660  width,
661  height,
662  custom_node_filter_callback
663  );
664  }
665 
666  SWIGOUT(%kwargs openBookmarkEditor;)
667  void openBookmarkEditor(HOM_Bookmark *bookmark=nullptr)
668  { self->_openBookmarkEditor(bookmark); }
669 
670  SWIGOUT(%kwargs openColorEditor;)
671  void openColorEditor(
672  InterpreterObject color_changed_callback,
673  bool include_alpha=false,
674  HOM_Color *initial_color=nullptr,
675  float initial_alpha=1.0f,
676  std::map<std::string, hboost::any> const& options =
677  std::map<std::string, hboost::any>()
678  )
679  {
680  self->_openColorEditor(
681  color_changed_callback,
682  include_alpha,
683  initial_color,
684  initial_alpha,
685  options);
686  }
687 
688  SWIGOUT(%kwargs openColorEditor;)
689  void openRawColorEditor(
690  InterpreterObject color_changed_callback,
691  bool include_alpha=false,
692  HOM_Color *initial_color=nullptr,
693  float initial_alpha=1.0f
694  )
695  {
696  std::map<std::string, hboost::any> options;
697  options["ocio_pick_raw"] = true;
698  options["ocio_show_info"] = false;
699  options["apply_color_correction"] = false;
700 
701  self->_openColorEditor(
702  color_changed_callback,
703  include_alpha,
704  initial_color,
705  initial_alpha,
706  options);
707  }
708 
709  SWIGOUT(%kwargs openValueLadder;)
710  void openValueLadder(
711  float initial_value,
712  InterpreterObject value_changed_callback,
713  HOM_EnumValue &type=HOM_valueLadderType::Generic,
714  HOM_EnumValue &data_type=HOM_valueLadderDataType::Float)
715  { self->_openValueLadder(
716  initial_value, value_changed_callback, type, data_type); }
717 
718  void addEventLoopCallback(InterpreterObject callback)
719  { self->addOpaqueEventLoopCallback(callback); }
720 
721  void removeEventLoopCallback(InterpreterObject callback)
722  { self->removeOpaqueEventLoopCallback(callback); }
723 
724  void postEventCallback(InterpreterObject callback)
725  { self->postOpaqueEventCallback(callback); }
726  void removePostedEventCallback(InterpreterObject callback)
727  { self->removePostedOpaqueEventCallback(callback); }
728 
729  // Note that we return a vector of borrowed references because swig
730  // will increment the reference counts.
731  std::vector<InterpreterObject> eventLoopCallbacks()
732  {
733  std::vector<void *> opaque_callbacks(self->opaqueEventLoopCallbacks());
734 
735  std::vector<InterpreterObject> callbacks;
736  for (int i=0; i< opaque_callbacks.size(); ++i)
737  callbacks.push_back((InterpreterObject)opaque_callbacks[i]);
738  return callbacks;
739  }
740 
741  void waitUntil(InterpreterObject callback)
742  { self->opaqueWaitUntil(callback); }
743 
744  void addTriggerUpdateCallback(InterpreterObject callback)
745  { self->addOpaqueTriggerUpdateCallback(callback); }
746 
747  void removeTriggerUpdateCallback(InterpreterObject callback)
748  { self->removeOpaqueTriggerUpdateCallback(callback); }
749 
750  void addSelectionCallback(InterpreterObject callback)
751  { self->addOpaqueSelectionCallback(callback); }
752 
753  void removeSelectionCallback(InterpreterObject callback)
754  { self->removeOpaqueSelectionCallback(callback); }
755 
756  std::vector<InterpreterObject> selectionCallbacks()
757  {
758  std::vector<void *> opaque_callbacks = self->opaqueSelectionCallbacks();
759  std::vector<InterpreterObject> callbacks;
760 
761  for (int i = 0, n = opaque_callbacks.size(); i < n; i++)
762  callbacks.push_back((InterpreterObject)opaque_callbacks[i]);
763 
764  return callbacks;
765  }
766 
767  // viewer state events
768  void addResourceEventCallback(InterpreterObject callback)
769  {
770  self->addOpaqueResourceEventCallback(callback);
771  }
772 
773  void removeResourceEventCallback(InterpreterObject callback)
774  {
775  self->removeOpaqueResourceEventCallback(callback);
776  }
777 
778  SWIGOUT(%kwargs openFileEditor;)
779  void openFileEditor(
780  std::string const & title,
781  std::string const & file_path,
782  InterpreterObject action_callback = nullptr,
783  std::map<std::string, hboost::any> const& params =
784  std::map<std::string, hboost::any>() )
785  {
786  self->_openFileEditor(title, file_path, action_callback, params);
787  }
788 
789  SWIGOUT(%kwargs openViewerStateCodeGenDialog;)
790  void openViewerStateCodeGenDialog(
791  HOM_NodeTypeCategory const & category,
792  InterpreterObject action_callback,
793  std::string const & op_name = std::string())
794  {
795  self->_openViewerStateCodeGenDialog(category, action_callback, op_name);
796  }
797 
798  SWIGOUT(%kwargs openViewerHandleCodeGenDialog;)
799  void openViewerHandleCodeGenDialog(
800  HOM_NodeTypeCategory const & category,
801  InterpreterObject action_callback )
802  {
803  self->_openViewerHandleCodeGenDialog(category, action_callback);
804  }
805 
806 }
807 #endif
808 
809 };
810 
811 #endif
virtual ~HOM_ui()
Definition: HOM_ui.h:50
GLuint GLsizei const GLchar * message
Definition: glcorearb.h:2543
GT_API const UT_StringHolder filename
GLuint GLsizei const GLchar * label
Definition: glcorearb.h:2545
#define SWIGOUT(x)
Definition: HOM_Defines.h:24
string __repr__(VtArray< T > const &self)
Definition: wrapArray.h:312
PUGI__FN void sort(I begin, I end, const Pred &pred)
Definition: pugixml.cpp:7550
GLint GLint GLsizei GLint GLenum GLenum const void * pixels
Definition: glcorearb.h:108
std::tuple< Types...> UT_Tuple
Definition: UT_Tuple.h:53
std::string help(const App *app, const Error &e)
Printout the full help string on error (if this fn is set, the old default for CLI11) ...
Definition: CLI11.h:8978
GLenum const GLfloat * params
Definition: glcorearb.h:105
GLint GLsizei GLsizei height
Definition: glcorearb.h:103
GLdouble n
Definition: glcorearb.h:2008
GLfloat f
Definition: glcorearb.h:1926
GLint GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:108
#define HOM_API
Definition: HOM_API.h:13
void ignore(T const &) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:6508
HOM_Color * selectRawColor(HOM_Color *initial_color=NULL)
Definition: HOM_ui.h:306
Definition: HOM_ui.h:47
*get result *(waiting if necessary)*A common idiom is to fire a bunch of sub tasks at the queue
Definition: thread.h:632
GLint location
Definition: glcorearb.h:805
GLenum GLenum severity
Definition: glcorearb.h:2539
GLuint const GLchar * name
Definition: glcorearb.h:786
GLushort pattern
Definition: glad.h:2583
GLenum mode
Definition: glcorearb.h:99
hboost::any HOM_DDSourceAny
Definition: HOM_Defines.h:42
GLsizeiptr size
Definition: glcorearb.h:664
OIIO_UTIL_API bool rename(string_view from, string_view to, std::string &err)
GLuint index
Definition: glcorearb.h:786
GLint GLsizei width
Definition: glcorearb.h:103
GLenum GLenum GLsizei void * row
Definition: glad.h:5135
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
Definition: glcorearb.h:1297