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  virtual void openTOPServiceManagerDialog() = 0;
302 
303  SWIGOUT(%kwargs openParameterInterfaceDialog;)
304  virtual void openParameterInterfaceDialog(HOM_Node &node,
305  HOM_EnumValue *open_tab = nullptr,
306  const char *open_tab_tree_path = nullptr) = 0;
307 
308  virtual HOM_EnumValue &updateMode() = 0;
309 
310  virtual void setUpdateMode(HOM_EnumValue &mode) = 0;
311  virtual void triggerUpdate() = 0;
312  virtual void reloadViewportColorSchemes() = 0;
313 
314  virtual std::vector<int> _getTabMenuIconSize() = 0;
315 
316  SWIGOUT(%ignore addOpaqueSelectionCallback;)
317  virtual void addOpaqueSelectionCallback(void *py_callback) = 0;
318  SWIGOUT(%ignore removeOpaqueSelectionCallback;)
319  virtual void removeOpaqueSelectionCallback(void *py_callback) = 0;
320  virtual void removeAllSelectionCallbacks() = 0;
321  SWIGOUT(%ignore opaqueSelectionCallbacks;)
322  virtual std::vector<void *> opaqueSelectionCallbacks() = 0;
323 
324  SWIGOUT(%ignore addOpaqueEventLoopCallback;)
325  virtual void addOpaqueEventLoopCallback(void *callback) = 0;
326  SWIGOUT(%ignore removeOpaqueEventLoopCallback;)
327  virtual void removeOpaqueEventLoopCallback(void *callback) = 0;
328  SWIGOUT(%ignore opaqueEventLoopCallbacks;)
329  virtual std::vector<void *> opaqueEventLoopCallbacks() = 0;
330 
331  SWIGOUT(%newobject createDialog;)
332  virtual HOM_Dialog *createDialog(const char *ui_file_name) = 0;
333  SWIGOUT(%newobject findDialog;)
334  virtual HOM_Dialog *findDialog(const char *ui_file_name) = 0;
335  virtual std::vector<HOM_ElemPtr<HOM_Dialog> > dialogs() = 0;
336 
337  SWIGOUT(%ignore opaqueWaitUntil;)
338  virtual void opaqueWaitUntil(void *condition_callback) = 0;
339 
340  SWIGOUT(%kwargs writePythonShellHistoryFile;)
341  virtual void writePythonShellHistoryFile(const char *filename=NULL) = 0;
342 
343  SWIGOUT(%kwargs readPythonShellHistoryFile;)
344  virtual void readPythonShellHistoryFile(const char *filename=NULL) = 0;
345 
346  SWIGOUT(%kwargs setStatusMessage;)
347  virtual void setStatusMessage(
348  const char *message,
349  HOM_EnumValue &severity=HOM_severityType::Message) = 0;
350 
351  virtual void openAssetUploadDialog(
352  HOM_Node *uploading_node, const char *session_key,
353  HOM_Node *containing_node) = 0;
354 
355  virtual void openAssetDependenciesDialog(
356  const std::vector<HOM_Node *> &uploading_nodes,
357  const std::vector<HOM_Node *> &uploaded_nodes,
358  const char *session_key,
359  HOM_Node *containing_node) = 0;
360 
361  virtual bool hasDragSourceData(const char *label) = 0;
362  SWIGOUT(%kwargs getDragSourceData;)
363  virtual HOM_DDSourceAny getDragSourceData(const char *label, int index=0) = 0;
364 
365  virtual std::string resourceValueFromName(const char *name) = 0;
366  virtual HOM_Color colorFromName(const char *name) = 0;
367 
368  virtual double globalScaleFactor() = 0;
369  virtual int scaledSize(int size) = 0;
370 
371  virtual double inchesToPixels(double inches) = 0;
372  virtual double pixelsToInches(double pixels) = 0;
373 
374  virtual void copyTextToClipboard(const char *text) = 0;
375  virtual std::string getTextFromClipboard() = 0;
376 
377  virtual std::vector<std::string> hotkeys(const char *hotkey_symbol) = 0;
378  virtual std::string hotkeyDescription(const char *hotkey_symbol) = 0;
379  virtual bool isKeyMatch(const char *key, const char *hotkey_symbol) = 0;
380 
381  virtual void openCaptureWeightSpreadsheet(HOM_Node *node,
382  const char *pattern = NULL) = 0;
383 
384  virtual void registerViewerState(HOM_ViewerStateTemplate& vs_templ) = 0;
385  virtual void registerViewerStateFile(std::string const& state_file) = 0;
386  virtual void registerViewerStates() = 0;
387  virtual void unregisterViewerState(std::string const& state_typename) = 0;
388  virtual void unregisterViewerStateFile(std::string const& state_file) = 0;
389  virtual bool isRegisteredViewerState(std::string const& state_name) = 0;
390  virtual void reloadViewerState(std::string const& state_typename) = 0;
391  SWIGOUT(%kwargs reloadViewerStates;)
392  virtual void reloadViewerStates(
393  std::vector<std::string> const& state_names=std::vector<std::string>()) = 0;
394  virtual std::string viewerStateInfo() = 0;
395  SWIGOUT(%kwargs printViewerStateMessage;)
396  virtual void printViewerStateMessage(
397  std::string const& message,
398  HOM_EnumValue & message_type = HOM_severityType::Message) = 0;
399  SWIGOUT(%kwargs fireViewerStateCustomEvent;)
400  virtual void fireViewerStateCustomEvent(
401  std::map<std::string, hboost::any> const & user_data,
402  bool queue = true) = 0;
403  SWIGOUT(%ignore _openViewerStateCodeGenDialog;)
404  SWIGOUT(%kwargs _openViewerStateCodeGenDialog;)
405  virtual void _openViewerStateCodeGenDialog(
406  HOM_NodeTypeCategory const & category,
407  void* action_callback,
408  std::string const & op_name = std::string()) = 0;
409 
410  SWIGOUT(%ignore addOpaqueViewerStateEventCallback;)
411  virtual void addOpaqueViewerStateEventCallback(void *py_callback) = 0;
412  SWIGOUT(%ignore removeOpaqueViewerStateEventCallback;)
413  virtual void removeOpaqueViewerStateEventCallback(void *py_callback) = 0;
414 
415  SWIGOUT(%ignore _openFileEditor;)
416  SWIGOUT(%kwargs _openFileEditor;)
417  virtual void _openFileEditor(
418  std::string const & title,
419  std::string const & file_path,
420  void* action_callback = nullptr,
421  std::map<std::string, hboost::any> const& params =
422  std::map<std::string, hboost::any>() ) = 0;
423 
424  SWIGOUT(%newobject showFloatingParameterEditor;)
425  virtual HOM_ParameterEditor* showFloatingParameterEditor(HOM_Node *node, bool reuse=true ) = 0;
426 
427  virtual bool hideAllMinimizedStowbars() = 0;
428  virtual void setHideAllMinimizedStowbars(bool hide) = 0;
429 #ifdef SWIG
430 %extend
431 {
432  SWIGOUT(%kwargs _selectNodeData;)
433  std::vector<std::string> _selectNodeData(
434  const char *title = NULL,
435  const char *message = NULL,
436  int width = 0,
437  int height = 0,
438  const std::vector<std::string> &
439  initial_selection = std::vector<std::string>(),
440  HOM_EnumValue *node_type_filter = nullptr,
441  bool multiple_select = false,
442  bool include_data_type_headers = true,
443  bool include_parms=true,
444  bool include_object_transforms=true,
445  bool include_geometry_bounding_boxes=true,
446  bool include_geometry_attributes=true,
447  bool expand_components=true,
448  InterpreterObject custom_data_callback=nullptr,
449  InterpreterObject custom_node_filter_callback=nullptr,
450  const char *help_url=nullptr)
451  {
452  if (custom_data_callback && custom_data_callback == Py_None)
453  custom_data_callback = nullptr;
454 
455  if (custom_node_filter_callback && custom_node_filter_callback == Py_None)
456  custom_node_filter_callback = nullptr;
457 
458  return self->_selectNodeDataInternal(
459  title,
460  message,
461  width,
462  height,
463  initial_selection,
464  node_type_filter,
465  multiple_select,
466  include_data_type_headers,
467  include_parms,
468  include_object_transforms,
469  include_geometry_bounding_boxes,
470  include_geometry_attributes,
471  expand_components,
472  custom_data_callback,
473  custom_node_filter_callback,
474  help_url
475  );
476  }
477 
478  SWIGOUT(%kwargs _selectNode;)
479  std::vector<std::string> _selectNode(
480  HOM_Node *relative_to_node = NULL,
481  HOM_Node *initial_node = NULL,
482  HOM_EnumValue *node_type_filter = NULL,
483  const char *title = NULL,
484  int width = 0,
485  int height = 0,
486  bool multiple_select = false,
487  InterpreterObject custom_node_filter_callback = nullptr)
488  {
489  if (custom_node_filter_callback && custom_node_filter_callback == Py_None)
490  custom_node_filter_callback = nullptr;
491 
492  return self->_selectNodeInternal(
493  relative_to_node,
494  initial_node,
495  node_type_filter,
496  title,
497  width,
498  height,
499  multiple_select,
500  custom_node_filter_callback
501  );
502  }
503 
504  // This method is deprecated. Use selectNode() instead.
505  SWIGOUT(%kwargs selectMultipleNodes;)
506  std::vector<std::string> selectMultipleNodes(
507  HOM_Node *relative_to_node = NULL,
508  HOM_Node *initial_node = NULL,
509  HOM_EnumValue *node_type_filter = NULL,
510  const char *title = NULL,
511  int width = 0,
512  int height = 0,
513  InterpreterObject custom_node_filter_callback = nullptr)
514  {
515  if (custom_node_filter_callback && custom_node_filter_callback == Py_None)
516  custom_node_filter_callback = nullptr;
517 
518  return self->_selectMultipleNodes(
519  relative_to_node,
520  initial_node,
521  node_type_filter,
522  title,
523  width,
524  height,
525  custom_node_filter_callback
526  );
527  }
528 
529  SWIGOUT(%kwargs openColorEditor;)
530  void openColorEditor(
531  InterpreterObject color_changed_callback,
532  bool include_alpha=false,
533  HOM_Color *initial_color=nullptr, float initial_alpha=1.0f)
534  { self->_openColorEditor(
535  color_changed_callback, include_alpha, initial_color, initial_alpha); }
536 
537  SWIGOUT(%kwargs openValueLadder;)
538  void openValueLadder(
539  float initial_value,
540  InterpreterObject value_changed_callback,
541  HOM_EnumValue &type=HOM_valueLadderType::Generic,
542  HOM_EnumValue &data_type=HOM_valueLadderDataType::Float)
543  { self->_openValueLadder(
544  initial_value, value_changed_callback, type, data_type); }
545 
546  void addEventLoopCallback(InterpreterObject callback)
547  { self->addOpaqueEventLoopCallback(callback); }
548 
549  void removeEventLoopCallback(InterpreterObject callback)
550  { self->removeOpaqueEventLoopCallback(callback); }
551 
552  // Note that we return a vector of borrowed references because swig
553  // will increment the reference counts.
554  std::vector<InterpreterObject> eventLoopCallbacks()
555  {
556  std::vector<void *> opaque_callbacks(self->opaqueEventLoopCallbacks());
557 
558  std::vector<InterpreterObject> callbacks;
559  for (int i=0; i< opaque_callbacks.size(); ++i)
560  callbacks.push_back((InterpreterObject)opaque_callbacks[i]);
561  return callbacks;
562  }
563 
564  void waitUntil(InterpreterObject callback)
565  { self->opaqueWaitUntil(callback); }
566 
567  void addSelectionCallback(InterpreterObject callback)
568  { self->addOpaqueSelectionCallback(callback); }
569 
570  void removeSelectionCallback(InterpreterObject callback)
571  { self->removeOpaqueSelectionCallback(callback); }
572 
573  std::vector<InterpreterObject> selectionCallbacks()
574  {
575  std::vector<void *> opaque_callbacks = self->opaqueSelectionCallbacks();
576  std::vector<InterpreterObject> callbacks;
577 
578  for (int i = 0, n = opaque_callbacks.size(); i < n; i++)
579  callbacks.push_back((InterpreterObject)opaque_callbacks[i]);
580 
581  return callbacks;
582  }
583 
584  // viewer state events
585  void addViewerStateEventCallback(InterpreterObject callback)
586  {
587  self->addOpaqueViewerStateEventCallback(callback);
588  }
589 
590  void removeViewerStateEventCallback(InterpreterObject callback)
591  {
592  self->removeOpaqueViewerStateEventCallback(callback);
593  }
594 
595  SWIGOUT(%kwargs openFileEditor;)
596  void openFileEditor(
597  std::string const & title,
598  std::string const & file_path,
599  InterpreterObject action_callback = nullptr,
600  std::map<std::string, hboost::any> const& params =
601  std::map<std::string, hboost::any>() )
602  {
603  self->_openFileEditor(title, file_path, action_callback, params);
604  }
605 
606  SWIGOUT(%kwargs openViewerStateCodeGenDialog;)
607  void openViewerStateCodeGenDialog(
608  HOM_NodeTypeCategory const & category,
609  InterpreterObject action_callback,
610  std::string const & op_name = std::string())
611  {
612  self->_openViewerStateCodeGenDialog(category, action_callback, op_name);
613  }
614 }
615 #endif
616 
617 };
618 
619 #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