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