00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016 #ifndef __HOM_ui_h__
00017 #define __HOM_ui_h__
00018
00019 #include "HOM_API.h"
00020 #include "HOM_Defines.h"
00021 #include "HOM_Module.h"
00022 #include "HOM_EnumValue.h"
00023 #include "HOM_EnumModules.h"
00024 #include "HOM_Errors.h"
00025 #include <vector>
00026 #include <boost/tuple/tuple.hpp>
00027
00028 class HOM_ShellIO;
00029 class HOM_Desktop;
00030 class HOM_Pane;
00031 class HOM_PaneTab;
00032 class HOM_FloatingPanel;
00033 class HOM_NodeType;
00034 class HOM_Node;
00035 class HOM_Dialog;
00036
00037 SWIGOUT(%rename(ui) HOM_ui;)
00038 class HOM_API HOM_ui
00039 {
00040 public:
00041 virtual ~HOM_ui()
00042 {}
00043
00044 virtual std::string __repr__() throw(HOM_Error) = 0;
00045
00046 virtual HOM_ShellIO &shellIO() throw(HOM_Error) = 0;
00047
00048
00049 SWIGOUT(%newobject curDesktop;)
00050 virtual HOM_Desktop* curDesktop()
00051 throw(HOM_NotAvailable, HOM_Error) = 0;
00052
00053 SWIGPYTHONOUT(%feature("autodoc",
00054 "desktops(self) -> tuple of Desktops") desktops;)
00055 virtual std::vector<HOM_ElemPtr<HOM_Desktop> > desktops()
00056 throw(HOM_NotAvailable, HOM_Error) = 0;
00057
00058 SWIGPYTHONOUT(%feature("autodoc",
00059 "paneTabs(self) -> tuple of PaneTabs") paneTabs;)
00060 virtual std::vector<HOM_ElemPtr<HOM_PaneTab> > paneTabs()
00061 throw(HOM_NotAvailable, HOM_ObjectWasDeleted, HOM_Error) = 0;
00062
00063 SWIGPYTHONOUT(%feature("autodoc",
00064 "paneTabOfType(self, type, index=0) -> PaneTab or None")
00065 paneTabOfType;)
00066 SWIGOUT(%newobject paneTabOfType;)
00067 virtual HOM_PaneTab *paneTabOfType(HOM_EnumValue &type, int index=0)
00068 throw(HOM_NotAvailable, HOM_ObjectWasDeleted, HOM_TypeError,
00069 HOM_Error) = 0;
00070
00071 SWIGPYTHONOUT(%feature("autodoc",
00072 "findPaneTab(self, name) -> PaneTab or None") findPaneTab;)
00073 SWIGOUT(%newobject findPaneTab;)
00074 virtual HOM_PaneTab *findPaneTab(const char *name)
00075 throw(HOM_NotAvailable, HOM_ObjectWasDeleted, HOM_Error) = 0;
00076
00077 SWIGPYTHONOUT(%feature("autodoc",
00078 "floatingPaneTabs(self) -> tuple of PaneTabs") floatingPaneTabs;)
00079 virtual std::vector<HOM_ElemPtr<HOM_PaneTab> > floatingPaneTabs()
00080 throw(HOM_NotAvailable, HOM_ObjectWasDeleted, HOM_Error) = 0;
00081
00082 SWIGPYTHONOUT(%feature("autodoc",
00083 "floatingPanels(self) -> tuple of FloatingPanels") floatingPanels;)
00084 virtual std::vector<HOM_ElemPtr<HOM_FloatingPanel> > floatingPanels()
00085 throw(HOM_NotAvailable, HOM_ObjectWasDeleted, HOM_Error) = 0;
00086
00087
00088 SWIGPYTHONOUT(%feature("autodoc",
00089 "displayMessage(self, text, buttons=('OK',),"
00090 " severity=hou.severityType.Message, default_choice=0,"
00091 " help=None, title=None, details=None, details_expanded=False)")
00092 displayMessage;)
00093 SWIGOUT(%kwargs displayMessage;)
00094 virtual int displayMessage(
00095 const char *text,
00096 const std::vector<std::string> &buttons =
00097 std::vector<std::string>(1, "OK"),
00098 HOM_EnumValue &severity = HOM_severityType::Message,
00099 int default_choice = 0,
00100 const char *help = NULL,
00101 const char *title = NULL,
00102 const char *details = NULL,
00103 bool details_expanded = false)
00104 throw(HOM_TypeError, HOM_OperationInterrupted, HOM_Error) = 0;
00105
00106 SWIGPYTHONOUT(%feature("autodoc",
00107 "readInput(self, message, buttons=(1,'OK'),"
00108 " severity=hou.severityType.Message, default_choice=0,"
00109 " help=None, title=None) -> (int, string),"
00110 " initial_contents=None") readInput;)
00111 SWIGOUT(%kwargs readInput;)
00112 virtual std::pair<int, std::string> readInput(
00113 const char *message,
00114 const std::vector<std::string> &buttons =
00115 std::vector<std::string>(1, "OK"),
00116 HOM_EnumValue &severity = HOM_severityType::Message,
00117 int default_choice = 0,
00118 const char *help = NULL,
00119 const char *title = NULL,
00120 const char *initial_contents = NULL)
00121 throw(HOM_TypeError, HOM_OperationInterrupted, HOM_Error) = 0;
00122
00123 SWIGPYTHONOUT(%feature("autodoc",
00124 "readMultiInput(self, message, input_labels, password_input_indices=(),"
00125 " buttons=(1,'OK'), severity=hou.severityType.Message,"
00126 " default_choice=0, help=None, title=None, initial_contents=None) -> "
00127 "(int, tuple of strings)") readMultiInput;)
00128 SWIGOUT(%kwargs readMultiInput;)
00129 virtual std::pair<int, std::vector<std::string> > readMultiInput(
00130 const char *message,
00131 const std::vector<std::string> &input_labels,
00132 const std::vector<int> &password_input_indices = std::vector<int>(),
00133 const std::vector<std::string> &buttons =
00134 std::vector<std::string>(1, "OK"),
00135 HOM_EnumValue &severity = HOM_severityType::Message,
00136 int default_choice = 0,
00137 const char *help = NULL,
00138 const char *title = NULL,
00139 const std::vector<std::string> &initial_contents =
00140 std::vector<std::string>() )
00141 throw(HOM_TypeError, HOM_OperationInterrupted, HOM_Error) = 0;
00142
00143 SWIGPYTHONOUT(%feature("autodoc",
00144 "selectFromList(self, choices, default_choices=(0,),"
00145 " exclusive=False, message=None, title=None) -> tuple of ints")
00146 selectFromList;)
00147 SWIGOUT(%kwargs selectFromList;)
00148 virtual std::vector<int> selectFromList(
00149 const std::vector<std::string> &choices,
00150 const std::vector<int> &default_choices = std::vector<int>(1, 0),
00151 bool exclusive = false,
00152 const char *message = NULL,
00153 const char *title = NULL)
00154 throw(HOM_TypeError, HOM_OperationInterrupted, HOM_Error) = 0;
00155
00156 SWIGPYTHONOUT(%feature("autodoc",
00157 "selectFile(self, start_directory=None, title=None,"
00158 " collapse_sequences=False, file_type=hou.fileType.None,"
00159 " pattern=None, default_value=None, multiple_select=False, "
00160 " image_chooser=False, chooser_mode=hou.fileChooserMode.ReadAndWrite) "
00161 " -> string") selectFile;)
00162 SWIGOUT(%kwargs selectFile;)
00163 virtual std::string selectFile(
00164 const char *start_directory = NULL,
00165 const char *title = NULL,
00166 bool collapse_sequences = false,
00167 HOM_EnumValue &file_type = HOM_fileType::Any,
00168 const char *pattern = NULL,
00169 const char *default_value = NULL,
00170 bool multiple_select = false,
00171 bool image_chooser = false,
00172 HOM_EnumValue &chooser_mode = HOM_fileChooserMode::ReadAndWrite)
00173 throw(HOM_TypeError, HOM_OperationInterrupted, HOM_Error) = 0;
00174
00175 SWIGPYTHONOUT(%feature("autodoc",
00176 "selectNode(self, relative_to_node=None, initial_node=None,"
00177 " node_type_filter=None) -> `str` or `None`") selectNode;)
00178 SWIGOUT(%kwargs selectNode;)
00179 SWIGOUT(%newobject selectNode;)
00180 virtual char *selectNode(
00181 HOM_Node *relative_to_node = NULL,
00182 HOM_Node *initial_node = NULL,
00183 HOM_EnumValue *node_type_filter = NULL)
00184 throw(HOM_TypeError, HOM_ObjectWasDeleted, HOM_OperationInterrupted,
00185 HOM_NotAvailable, HOM_Error) = 0;
00186
00187 SWIGPYTHONOUT(%feature("autodoc",
00188 "displayFileDependencyDialog(self, rop_node=None, uploaded_files=(),"
00189 " forced_unselected_patterns=(), project_dir_variable='HIP',"
00190 " is_standalone=False) -> (`bool`, tuple of `str`)")
00191 displayFileDependencyDialog;)
00192 SWIGOUT(%kwargs displayFileDependencyDialog;)
00193 virtual boost::tuple<bool, std::vector<std::string> >
00194 displayFileDependencyDialog(
00195 HOM_Node *rop_node = NULL,
00196 const std::vector<std::string> &uploaded_files =
00197 std::vector<std::string>(),
00198 const std::vector<std::string> &forced_unselected_patterns =
00199 std::vector<std::string>(),
00200 const char *project_dir_variable="HIP",
00201 bool is_standalone=true)
00202 throw(HOM_ObjectWasDeleted, HOM_TypeError, HOM_Error) = 0;
00203
00204
00205 virtual void displayNodeHelp(HOM_NodeType &node_type)
00206 throw(HOM_Error) = 0;
00207 virtual void openTypePropertiesDialog(
00208 HOM_Node &node, bool promote_spare_parms=false,
00209 bool immediately_save=false)
00210 throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00211 virtual void openTypePropertiesDialog(
00212 HOM_NodeType &node_type, bool promote_spare_parms=false,
00213 bool immediately_save=false)
00214 throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00215
00216 SWIGPYTHONOUT(%feature("autodoc",
00217 "updateMode(self) -> hou.updateMode enum value") updateMode;)
00218 virtual HOM_EnumValue &updateMode()
00219 throw(HOM_NotAvailable, HOM_Error) = 0;
00220
00221 virtual void setUpdateMode(HOM_EnumValue &mode)
00222 throw(HOM_NotAvailable, HOM_TypeError, HOM_Error) = 0;
00223 virtual void triggerUpdate()
00224 throw(HOM_NotAvailable, HOM_Error) = 0;
00225
00226 SWIGPYTHONOUT(%feature("autodoc",
00227 "_getTabMenuIconSize(self) -> tuple of ints") _getTabMenuIconSize;)
00228 virtual std::vector<int> _getTabMenuIconSize()
00229 throw(HOM_Error) = 0;
00230
00231 SWIGOUT(%ignore addOpaqueEventLoopCallback;)
00232 virtual void addOpaqueEventLoopCallback(void *callback)
00233 throw(HOM_Error) = 0;
00234 SWIGOUT(%ignore removeOpaqueEventLoopCallback;)
00235 virtual void removeOpaqueEventLoopCallback(void *callback)
00236 throw(HOM_OperationFailed, HOM_Error) = 0;
00237 SWIGOUT(%ignore opaqueEventLoopCallbacks;)
00238 virtual std::vector<void *> opaqueEventLoopCallbacks()
00239 throw(HOM_Error) = 0;
00240
00241 SWIGOUT(%newobject createDialog;)
00242 virtual HOM_Dialog *createDialog(const char *ui_file_name)
00243 throw(HOM_OperationFailed, HOM_TypeError, HOM_Error) = 0;
00244 SWIGOUT(%newobject findDialog;)
00245 virtual HOM_Dialog *findDialog(const char *ui_file_name)
00246 throw(HOM_TypeError, HOM_Error) = 0;
00247 virtual std::vector<HOM_ElemPtr<HOM_Dialog> > dialogs()
00248 throw(HOM_Error) = 0;
00249
00250 virtual void opaqueWaitUntil(void *condition_callback)
00251 throw(HOM_Error) = 0;
00252
00253 #ifdef SWIG
00254 %extend
00255 {
00256 void addEventLoopCallback(InterpreterObject callback)
00257 throw(HOM_Error)
00258 { self->addOpaqueEventLoopCallback(callback); }
00259
00260 void removeEventLoopCallback(InterpreterObject callback)
00261 throw(HOM_Error)
00262 { self->removeOpaqueEventLoopCallback(callback); }
00263
00264
00265
00266 std::vector<InterpreterObject> eventLoopCallbacks()
00267 throw(HOM_Error)
00268 {
00269 std::vector<void *> opaque_callbacks(self->opaqueEventLoopCallbacks());
00270
00271 std::vector<InterpreterObject> callbacks;
00272 for (int i=0; i< opaque_callbacks.size(); ++i)
00273 callbacks.push_back((InterpreterObject)opaque_callbacks[i]);
00274 return callbacks;
00275 }
00276
00277 void waitUntil(InterpreterObject callback)
00278 throw(HOM_Error)
00279 { self->opaqueWaitUntil(callback); }
00280 }
00281 #endif
00282
00283 };
00284
00285 #endif
