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 
26 class HOM_Desktop;
27 class HOM_Dialog;
28 class HOM_FloatingPanel;
29 class HOM_Node;
30 class HOM_NodeType;
31 class HOM_Pane;
32 class HOM_PaneTab;
34 class HOM_RadialMenu;
35 class HOM_RopNode;
36 class HOM_ShellIO;
37 class HOM_SopNodeType;
40 
41 SWIGOUT(%rename(ui) HOM_ui;)
43 {
44 public:
45  virtual ~HOM_ui()
46  {}
47 
48  virtual std::string __repr__() = 0;
49 
50  virtual HOM_ShellIO &shellIO() = 0;
51 
52  SWIGOUT(%newobject curDesktop;)
53  virtual HOM_Desktop* curDesktop() = 0;
54  SWIGOUT(%newobject desktop;)
55  virtual HOM_Desktop* desktop(const char *name) = 0;
56 
57  virtual std::vector<HOM_ElemPtr<HOM_Desktop> > desktops() = 0;
58 
59  virtual HOM_RadialMenu* radialMenu(const std::string &name) = 0;
60  virtual std::vector<HOM_ElemPtr<HOM_RadialMenu> > radialMenus() = 0;
61  virtual HOM_RadialMenu* createRadialMenu(const std::string &name,
62  const char *label) = 0;
63 
64  virtual std::vector<HOM_ElemPtr<HOM_Pane> > panes() = 0;
65  virtual std::vector<HOM_ElemPtr<HOM_PaneTab> > paneTabs() = 0;
66 
67  virtual std::vector<HOM_ElemPtr<HOM_PaneTab> > currentPaneTabs() = 0;
68 
69  SWIGOUT(%newobject paneTabOfType;)
70  virtual HOM_PaneTab *paneTabOfType(HOM_EnumValue &type, int index=0) = 0;
71 
72  SWIGOUT(%newobject findPane;)
73  virtual HOM_Pane *findPane(int pane_id) = 0;
74 
75  SWIGOUT(%newobject findPaneTab;)
76  virtual HOM_PaneTab *findPaneTab(const char *name) = 0;
77 
78  virtual std::vector<HOM_ElemPtr<HOM_PaneTab> > floatingPaneTabs() = 0;
79 
80  virtual std::vector<HOM_ElemPtr<HOM_FloatingPanel> > floatingPanels() = 0;
81 
82  SWIGOUT(%newobject paneUnderCursor;)
83  virtual HOM_Pane *paneUnderCursor() = 0;
84  SWIGOUT(%newobject paneTabUnderCursor;)
85  virtual HOM_PaneTab *paneTabUnderCursor() = 0;
86 
87  virtual bool isUserInteracting() = 0;
88 
89  virtual HOM_EnumValue &orientationUpAxis() = 0;
90  virtual HOM_EnumValue &handleOrientToNormalAxis() = 0;
91 
92  SWIGOUT(%kwargs displayConfirmation;)
93  virtual bool displayConfirmation(
94  const char *text,
95  HOM_EnumValue &severity = HOM_severityType::Message,
96  const char *help = NULL,
97  const char *title = NULL,
98  const char *details = NULL,
99  const char *details_label = NULL,
100  HOM_EnumValue &suppress = HOM_confirmType::OverwriteFile) = 0;
101 
102  SWIGOUT(%kwargs displayMessage;)
103  virtual int displayMessage(
104  const char *text,
105  const std::vector<std::string> &buttons =
106  std::vector<std::string>(1, "OK"),
107  HOM_EnumValue &severity = HOM_severityType::Message,
108  int default_choice = 0,
109  int close_choice = -1,
110  const char *help = NULL,
111  const char *title = NULL,
112  const char *details = NULL,
113  const char *details_label = NULL,
114  bool details_expanded = false) = 0;
115 
116  SWIGOUT(%kwargs readInput;)
117  virtual std::pair<int, std::string> readInput(
118  const char *message,
119  const std::vector<std::string> &buttons =
120  std::vector<std::string>(1, "OK"),
121  HOM_EnumValue &severity = HOM_severityType::Message,
122  int default_choice = 0,
123  int close_choice = -1,
124  const char *help = NULL,
125  const char *title = NULL,
126  const char *initial_contents = NULL) = 0;
127 
128  SWIGOUT(%kwargs readMultiInput;)
129  virtual std::pair<int, std::vector<std::string> > readMultiInput(
130  const char *message,
131  const std::vector<std::string> &input_labels,
132  const std::vector<int> &password_input_indices = std::vector<int>(),
133  const std::vector<std::string> &buttons =
134  std::vector<std::string>(1, "OK"),
135  HOM_EnumValue &severity = HOM_severityType::Message,
136  int default_choice = 0,
137  int close_choice = -1,
138  const char *help = NULL,
139  const char *title = NULL,
140  const std::vector<std::string> &initial_contents =
141  std::vector<std::string>() ) = 0;
142 
143  SWIGOUT(%kwargs selectFromList;)
144  virtual std::vector<int> selectFromList(
145  const std::vector<std::string> &choices,
146  const std::vector<int> &default_choices = std::vector<int>(),
147  bool exclusive = false,
148  const char *message = NULL,
149  const char *title = NULL,
150  const char *column_header = "Choices",
151  int num_visible_rows = 10,
152  bool clear_on_cancel = false,
153  int width = 0,
154  int height = 0) = 0;
155 
156  SWIGOUT(%kwargs selectFromTree;)
157  virtual std::vector<std::string> selectFromTree(
158  const std::vector<std::string> &choices,
159  const std::vector<std::string> &picked = std::vector<std::string>(),
160  bool exclusive = false,
161  const char *message = NULL,
162  const char *title = NULL,
163  bool clear_on_cancel = false,
164  int width = 0,
165  int height = 0) = 0;
166 
167  SWIGOUT(%kwargs selectFile;)
168  virtual std::string selectFile(
169  const char *start_directory = NULL,
170  const char *title = NULL,
171  bool collapse_sequences = false,
172  HOM_EnumValue &file_type = HOM_fileType::Any,
173  const char *pattern = NULL,
174  const char *default_value = NULL,
175  bool multiple_select = false,
176  bool image_chooser = false,
177  HOM_EnumValue &chooser_mode = HOM_fileChooserMode::ReadAndWrite,
178  int width = 0,
179  int height = 0) = 0;
180 
181  SWIGOUT(%ignore _selectNodeInternal;)
182  virtual std::vector<std::string> _selectNodeInternal(
183  HOM_Node *relative_to_node = NULL,
184  HOM_Node *initial_node = NULL,
185  HOM_EnumValue *node_type_filter = NULL,
186  const char *title = NULL,
187  int width = 0,
188  int height = 0,
189  bool multiple_select = false,
190  void *custom_node_filter_callback = nullptr) = 0;
191 
192  // This method is deprecated. Use selectNode() instead.
193  SWIGOUT(%ignore _selectMultipleNodes;)
194  virtual std::vector<std::string> _selectMultipleNodes(
195  HOM_Node *relative_to_node = NULL,
196  HOM_Node *initial_node = NULL,
197  HOM_EnumValue *node_type_filter = NULL,
198  const char *title = NULL,
199  int width = 0,
200  int height = 0,
201  void *custom_node_filter_callback = nullptr) = 0;
202 
203  SWIGOUT(%ignore _selectNodeDataInternal;)
204  virtual std::vector<std::string> _selectNodeDataInternal(
205  const char *title = NULL,
206  const char *message = NULL,
207  int width = 0,
208  int height = 0,
209  const std::vector<std::string> &
210  initial_selection = std::vector<std::string>(),
211  HOM_EnumValue *node_type_filter = nullptr,
212  bool multiple_select = false,
213  bool include_data_type_headers = true,
214  bool include_parms=true,
215  bool include_object_transforms=true,
216  bool include_geometry_bounding_boxes=true,
217  bool include_geometry_attributes=true,
218  bool expand_components=true,
219  void *custom_data_callback=nullptr,
220  void *custom_node_filter_callback = nullptr,
221  const char *help_url=nullptr) = 0;
222 
223  SWIGOUT(%kwargs selectParmTag;)
224  virtual std::vector<std::string> selectParmTag(
225  int width = 0,
226  int height = 0) = 0;
227 
228  SWIGOUT(%kwargs selectParm;)
229  virtual std::vector<std::string> selectParm(
230  HOM_NodeTypeCategory *category = NULL,
231  bool bound_parms_only = false,
232  HOM_Node *relative_to_node = NULL,
233  const char *message = NULL,
234  const char *title = NULL,
235  const std::vector<std::string> &
236  initial_parms = std::vector<std::string>(),
237  bool multiple_select = true,
238  int width = 0,
239  int height = 0) = 0;
240 
241  SWIGOUT(%kwargs selectParmTuple;)
242  virtual std::vector<std::string> selectParmTuple(
243  HOM_NodeTypeCategory *category = NULL,
244  bool bound_parms_only = false,
245  HOM_Node *relative_to_node = NULL,
246  const char *message = NULL,
247  const char *title = NULL,
248  const std::vector<std::string> &
249  initial_parm_tuples = std::vector<std::string>(),
250  bool multiple_select = true,
251  int width = 0,
252  int height = 0) = 0;
253 
254  SWIGOUT(%kwargs selectColor;)
255  SWIGOUT(%newobject selectColor;)
256  virtual HOM_Color *selectColor(HOM_Color *initial_color = NULL) = 0;
257 
258  SWIGOUT(%kwargs _openColorEditor;)
259  virtual void _openColorEditor(
260  void *color_changed_callback, bool include_alpha=false,
261  HOM_Color *initial_color=nullptr, float initial_alpha=1.0f) = 0;
262 
263  virtual std::vector<HOM_Color> loadPaletteFile(const char *file) = 0;
264  virtual void savePaletteFile(const char *file,
265  const std::vector<HOM_Color> &colors) = 0;
266 
267  SWIGOUT(%ignore _openValueLadder;)
268  SWIGOUT(%kwargs _openValueLadder;)
269  virtual void _openValueLadder(
270  float initial_value, void *value_changed_callback,
271  HOM_EnumValue &type=HOM_valueLadderType::Generic,
272  HOM_EnumValue &data_type=HOM_valueLadderDataType::Float) = 0;
273  virtual void updateValueLadder(
274  int cursor_x, int cursor_y, bool alt_key, bool shift_key) = 0;
275  virtual void closeValueLadder() = 0;
276 
277  SWIGOUT(%kwargs displayFileDependencyDialog;)
278  virtual UT_Tuple<bool,
279  std::vector<std::pair<HOM_ElemPtr<HOM_Parm>, std::string> > >
280  displayFileDependencyDialog(
281  HOM_Node *rop_node = NULL,
282  const std::vector<std::string> &uploaded_files =
283  std::vector<std::string>(),
284  const std::vector<std::string> &forced_unselected_patterns =
285  std::vector<std::string>(),
286  const char *project_dir_variable="HIP",
287  bool is_standalone=true) = 0;
288 
289  virtual void displayNodeHelp(HOM_NodeType &node_type) = 0;
290  virtual void openTypePropertiesDialog(
291  HOM_Node &node, bool promote_spare_parms=false,
292  bool immediately_save=false) = 0;
293  virtual void openTypePropertiesDialog(
294  HOM_NodeType &node_type, bool promote_spare_parms=false,
295  bool immediately_save=false) = 0;
296 
297  virtual void openRenderDialog(HOM_RopNode &rop) = 0;
298 
299  virtual void openRenameSelectedDialog(HOM_Node &network) = 0;
300 
301  SWIGOUT(%kwargs openParameterInterfaceDialog;)
302  virtual void openParameterInterfaceDialog(HOM_Node &node,
303  HOM_EnumValue *open_tab = nullptr,
304  const char *open_tab_tree_path = nullptr) = 0;
305 
306  virtual HOM_EnumValue &updateMode() = 0;
307 
308  virtual void setUpdateMode(HOM_EnumValue &mode) = 0;
309  virtual void triggerUpdate() = 0;
310  virtual void reloadViewportColorSchemes() = 0;
311 
312  virtual std::vector<int> _getTabMenuIconSize() = 0;
313 
314  SWIGOUT(%ignore addOpaqueSelectionCallback;)
315  virtual void addOpaqueSelectionCallback(void *py_callback) = 0;
316  SWIGOUT(%ignore removeOpaqueSelectionCallback;)
317  virtual void removeOpaqueSelectionCallback(void *py_callback) = 0;
318  virtual void removeAllSelectionCallbacks() = 0;
319  SWIGOUT(%ignore opaqueSelectionCallbacks;)
320  virtual std::vector<void *> opaqueSelectionCallbacks() = 0;
321 
322  SWIGOUT(%ignore addOpaqueEventLoopCallback;)
323  virtual void addOpaqueEventLoopCallback(void *callback) = 0;
324  SWIGOUT(%ignore removeOpaqueEventLoopCallback;)
325  virtual void removeOpaqueEventLoopCallback(void *callback) = 0;
326  SWIGOUT(%ignore opaqueEventLoopCallbacks;)
327  virtual std::vector<void *> opaqueEventLoopCallbacks() = 0;
328 
329  SWIGOUT(%newobject createDialog;)
330  virtual HOM_Dialog *createDialog(const char *ui_file_name) = 0;
331  SWIGOUT(%newobject findDialog;)
332  virtual HOM_Dialog *findDialog(const char *ui_file_name) = 0;
333  virtual std::vector<HOM_ElemPtr<HOM_Dialog> > dialogs() = 0;
334 
335  SWIGOUT(%ignore opaqueWaitUntil;)
336  virtual void opaqueWaitUntil(void *condition_callback) = 0;
337 
338  SWIGOUT(%kwargs writePythonShellHistoryFile;)
339  virtual void writePythonShellHistoryFile(const char *filename=NULL) = 0;
340 
341  SWIGOUT(%kwargs readPythonShellHistoryFile;)
342  virtual void readPythonShellHistoryFile(const char *filename=NULL) = 0;
343 
344  SWIGOUT(%kwargs setStatusMessage;)
345  virtual void setStatusMessage(
346  const char *message,
347  HOM_EnumValue &severity=HOM_severityType::Message) = 0;
348  virtual std::pair<std::string, HOM_EnumValue *> statusMessage() = 0;
349 
350  virtual void openAssetUploadDialog(
351  HOM_Node *uploading_node, const char *session_key,
352  HOM_Node *containing_node) = 0;
353 
354  virtual void openAssetDependenciesDialog(
355  const std::vector<HOM_Node *> &uploading_nodes,
356  const std::vector<HOM_Node *> &uploaded_nodes,
357  const char *session_key,
358  HOM_Node *containing_node) = 0;
359 
360  virtual bool hasDragSourceData(const char *label) = 0;
361  SWIGOUT(%kwargs getDragSourceData;)
362  virtual HOM_DDSourceAny getDragSourceData(const char *label, int index=0) = 0;
363 
364  virtual std::string resourceValueFromName(const char *name) = 0;
365  virtual HOM_Color colorFromName(const char *name) = 0;
366 
367  virtual double globalScaleFactor() = 0;
368  virtual int scaledSize(int size) = 0;
369 
370  virtual double inchesToPixels(double inches) = 0;
371  virtual double pixelsToInches(double pixels) = 0;
372 
373  virtual void copyTextToClipboard(const char *text) = 0;
374  virtual std::string getTextFromClipboard() = 0;
375 
376  virtual std::vector<std::string> hotkeys(const char *hotkey_symbol) = 0;
377  virtual std::string hotkeyDescription(const char *hotkey_symbol) = 0;
378  virtual bool isKeyMatch(const char *key, const char *hotkey_symbol) = 0;
379 
380  virtual void openCaptureWeightSpreadsheet(HOM_Node *node,
381  const char *pattern = NULL) = 0;
382 
383  virtual void registerViewerState(HOM_ViewerStateTemplate& vs_templ) = 0;
384  virtual void registerViewerStateFile(std::string const& state_file) = 0;
385  virtual void registerViewerStates() = 0;
386  virtual void unregisterViewerState(std::string const& state_typename) = 0;
387  virtual void unregisterViewerStateFile(std::string const& state_file) = 0;
388  virtual bool isRegisteredViewerState(std::string const& state_name) = 0;
389  virtual void reloadViewerState(std::string const& state_typename) = 0;
390  SWIGOUT(%kwargs reloadViewerStates;)
391  virtual void reloadViewerStates(
392  std::vector<std::string> const& state_names=std::vector<std::string>()) = 0;
393  virtual std::string viewerStateInfo() = 0;
394  SWIGOUT(%kwargs printViewerStateMessage;)
395  virtual void printViewerStateMessage(
396  std::string const& message,
397  HOM_EnumValue & message_type = HOM_severityType::Message) = 0;
398  SWIGOUT(%kwargs fireViewerStateCustomEvent;)
399  virtual void fireViewerStateCustomEvent(
400  std::map<std::string, hboost::any> const & user_data,
401  bool queue = true) = 0;
402  SWIGOUT(%ignore _openViewerStateCodeGenDialog;)
403  SWIGOUT(%kwargs _openViewerStateCodeGenDialog;)
404  virtual void _openViewerStateCodeGenDialog(
405  HOM_NodeTypeCategory const & category,
406  void* action_callback,
407  std::string const & op_name = std::string()) = 0;
408 
409  SWIGOUT(%ignore addOpaqueViewerStateEventCallback;)
410  virtual void addOpaqueViewerStateEventCallback(void *py_callback) = 0;
411  SWIGOUT(%ignore removeOpaqueViewerStateEventCallback;)
412  virtual void removeOpaqueViewerStateEventCallback(void *py_callback) = 0;
413 
414  SWIGOUT(%ignore _openFileEditor;)
415  SWIGOUT(%kwargs _openFileEditor;)
416  virtual void _openFileEditor(
417  std::string const & title,
418  std::string const & file_path,
419  void* action_callback = nullptr,
420  std::map<std::string, hboost::any> const& params =
421  std::map<std::string, hboost::any>() ) = 0;
422 
423  SWIGOUT(%newobject showFloatingParameterEditor;)
424  virtual HOM_ParameterEditor* showFloatingParameterEditor(HOM_Node *node, bool reuse=true ) = 0;
425 
426  virtual bool hideAllMinimizedStowbars() = 0;
427  virtual void setHideAllMinimizedStowbars(bool hide) = 0;
428 #ifdef SWIG
429 %extend
430 {
431  SWIGOUT(%kwargs _selectNodeData;)
432  std::vector<std::string> _selectNodeData(
433  const char *title = NULL,
434  const char *message = NULL,
435  int width = 0,
436  int height = 0,
437  const std::vector<std::string> &
438  initial_selection = std::vector<std::string>(),
439  HOM_EnumValue *node_type_filter = nullptr,
440  bool multiple_select = false,
441  bool include_data_type_headers = true,
442  bool include_parms=true,
443  bool include_object_transforms=true,
444  bool include_geometry_bounding_boxes=true,
445  bool include_geometry_attributes=true,
446  bool expand_components=true,
447  InterpreterObject custom_data_callback=nullptr,
448  InterpreterObject custom_node_filter_callback=nullptr,
449  const char *help_url=nullptr)
450  {
451  if (custom_data_callback && custom_data_callback == Py_None)
452  custom_data_callback = nullptr;
453 
454  if (custom_node_filter_callback && custom_node_filter_callback == Py_None)
455  custom_node_filter_callback = nullptr;
456 
457  return self->_selectNodeDataInternal(
458  title,
459  message,
460  width,
461  height,
462  initial_selection,
463  node_type_filter,
464  multiple_select,
465  include_data_type_headers,
466  include_parms,
467  include_object_transforms,
468  include_geometry_bounding_boxes,
469  include_geometry_attributes,
470  expand_components,
471  custom_data_callback,
472  custom_node_filter_callback,
473  help_url
474  );
475  }
476 
477  SWIGOUT(%kwargs _selectNode;)
478  std::vector<std::string> _selectNode(
479  HOM_Node *relative_to_node = NULL,
480  HOM_Node *initial_node = NULL,
481  HOM_EnumValue *node_type_filter = NULL,
482  const char *title = NULL,
483  int width = 0,
484  int height = 0,
485  bool multiple_select = false,
486  InterpreterObject custom_node_filter_callback = nullptr)
487  {
488  if (custom_node_filter_callback && custom_node_filter_callback == Py_None)
489  custom_node_filter_callback = nullptr;
490 
491  return self->_selectNodeInternal(
492  relative_to_node,
493  initial_node,
494  node_type_filter,
495  title,
496  width,
497  height,
498  multiple_select,
499  custom_node_filter_callback
500  );
501  }
502 
503  // This method is deprecated. Use selectNode() instead.
504  SWIGOUT(%kwargs selectMultipleNodes;)
505  std::vector<std::string> selectMultipleNodes(
506  HOM_Node *relative_to_node = NULL,
507  HOM_Node *initial_node = NULL,
508  HOM_EnumValue *node_type_filter = NULL,
509  const char *title = NULL,
510  int width = 0,
511  int height = 0,
512  InterpreterObject custom_node_filter_callback = nullptr)
513  {
514  if (custom_node_filter_callback && custom_node_filter_callback == Py_None)
515  custom_node_filter_callback = nullptr;
516 
517  return self->_selectMultipleNodes(
518  relative_to_node,
519  initial_node,
520  node_type_filter,
521  title,
522  width,
523  height,
524  custom_node_filter_callback
525  );
526  }
527 
528  SWIGOUT(%kwargs openColorEditor;)
529  void openColorEditor(
530  InterpreterObject color_changed_callback,
531  bool include_alpha=false,
532  HOM_Color *initial_color=nullptr, float initial_alpha=1.0f)
533  { self->_openColorEditor(
534  color_changed_callback, include_alpha, initial_color, initial_alpha); }
535 
536  SWIGOUT(%kwargs openValueLadder;)
537  void openValueLadder(
538  float initial_value,
539  InterpreterObject value_changed_callback,
540  HOM_EnumValue &type=HOM_valueLadderType::Generic,
541  HOM_EnumValue &data_type=HOM_valueLadderDataType::Float)
542  { self->_openValueLadder(
543  initial_value, value_changed_callback, type, data_type); }
544 
545  void addEventLoopCallback(InterpreterObject callback)
546  { self->addOpaqueEventLoopCallback(callback); }
547 
548  void removeEventLoopCallback(InterpreterObject callback)
549  { self->removeOpaqueEventLoopCallback(callback); }
550 
551  // Note that we return a vector of borrowed references because swig
552  // will increment the reference counts.
553  std::vector<InterpreterObject> eventLoopCallbacks()
554  {
555  std::vector<void *> opaque_callbacks(self->opaqueEventLoopCallbacks());
556 
557  std::vector<InterpreterObject> callbacks;
558  for (int i=0; i< opaque_callbacks.size(); ++i)
559  callbacks.push_back((InterpreterObject)opaque_callbacks[i]);
560  return callbacks;
561  }
562 
563  void waitUntil(InterpreterObject callback)
564  { self->opaqueWaitUntil(callback); }
565 
566  void addSelectionCallback(InterpreterObject callback)
567  { self->addOpaqueSelectionCallback(callback); }
568 
569  void removeSelectionCallback(InterpreterObject callback)
570  { self->removeOpaqueSelectionCallback(callback); }
571 
572  std::vector<InterpreterObject> selectionCallbacks()
573  {
574  std::vector<void *> opaque_callbacks = self->opaqueSelectionCallbacks();
575  std::vector<InterpreterObject> callbacks;
576 
577  for (int i = 0, n = opaque_callbacks.size(); i < n; i++)
578  callbacks.push_back((InterpreterObject)opaque_callbacks[i]);
579 
580  return callbacks;
581  }
582 
583  // viewer state events
584  void addViewerStateEventCallback(InterpreterObject callback)
585  {
586  self->addOpaqueViewerStateEventCallback(callback);
587  }
588 
589  void removeViewerStateEventCallback(InterpreterObject callback)
590  {
591  self->removeOpaqueViewerStateEventCallback(callback);
592  }
593 
594  SWIGOUT(%kwargs openFileEditor;)
595  void openFileEditor(
596  std::string const & title,
597  std::string const & file_path,
598  InterpreterObject action_callback = nullptr,
599  std::map<std::string, hboost::any> const& params =
600  std::map<std::string, hboost::any>() )
601  {
602  self->_openFileEditor(title, file_path, action_callback, params);
603  }
604 
605  SWIGOUT(%kwargs openViewerStateCodeGenDialog;)
606  void openViewerStateCodeGenDialog(
607  HOM_NodeTypeCategory const & category,
608  InterpreterObject action_callback,
609  std::string const & op_name = std::string())
610  {
611  self->_openViewerStateCodeGenDialog(category, action_callback, op_name);
612  }
613 }
614 #endif
615 
616 };
617 
618 #endif
virtual ~HOM_ui()
Definition: HOM_ui.h:45
GT_API const UT_StringHolder filename
GLsizeiptr size
Definition: glew.h:1681
GLuint const GLchar * name
Definition: glew.h:1814
GLenum mode
Definition: glew.h:2163
GLint GLint GLint GLint GLint GLint GLsizei width
Definition: glew.h:1252
GLuint index
Definition: glew.h:1814
OIIO_API bool rename(string_view from, string_view to, std::string &err)
GLenum severity
Definition: glew.h:2579
#define SWIGOUT(x)
Definition: HOM_Defines.h:24
GLint GLint GLint GLint GLint GLint GLsizei GLsizei height
Definition: glew.h:1252
string __repr__(VtArray< T > const &self)
Definition: wrapArray.h:349
std::tuple< Types...> UT_Tuple
Definition: UT_Tuple.h:53
GLclampf f
Definition: glew.h:3499
#define HOM_API
Definition: HOM_API.h:13
Definition: HOM_ui.h:42
GLsizei GLenum GLuint GLuint GLsizei GLchar * message
Definition: glew.h:2581
GLsizei n
Definition: glew.h:4040
*get result *(waiting if necessary)*A common idiom is to fire a bunch of sub tasks at the queue
Definition: thread.h:643
GLuint GLuint GLsizei GLenum type
Definition: glew.h:1253
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const void * pixels
Definition: glew.h:1254
GLuint GLsizei GLsizei GLchar * label
Definition: glew.h:8986
hboost::any HOM_DDSourceAny
Definition: HOM_Defines.h:42
GLsizei const GLchar *const * string
Definition: glew.h:1844
const GLfloat * params
Definition: glew.h:1531
GLubyte * pattern
Definition: glew.h:5711