HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
PI_ResourceManager.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  * NAME: PI_ResourceManager.h ( Direct Manipulation Library, C++)
7  *
8  * COMMENTS:
9  * This class maintains a table of all states, handles, op-handle links,
10  * and input selectors. All state, handle, and op-handle link objects
11  * are created and deleted through a PI_ResourceManager. The active one
12  * is obtained via the global function BMgetResourceManager().
13  */
14 
15 #ifndef __PI_ResourceManager_H__
16 #define __PI_ResourceManager_H__
17 
18 #include "PI_API.h"
19 #include "PI_ResourceTemplate.h"
20 #include "PI_SettingList.h"
21 #include "PI_PythonResourceTypes.h"
22 
23 #include <OP/OP_Error.h>
24 #include <OP/OP_OperatorTable.h>
25 #include <UT/UT_Array.h>
26 #include <UT/UT_String.h>
27 #include <UT/UT_StringMap.h>
28 #include <UT/UT_SymbolTable.h>
29 #include <UT/UT_ValArray.h>
30 #include <SYS/SYS_Hash.h>
31 #include <utility>
32 
33 class CPP_Manager;
34 class PRM_Template;
35 class OP_Operator;
36 class OP_OperatorTable;
37 class OP_Node;
38 class CMD_Args;
39 class PI_OpHandleLink;
40 class pi_OpHandleBinding;
41 class pi_OpSelectorBinding;
42 
43 namespace PI_PythonState
44 {
45  class Template;
46 }
47 
48 namespace PI_PythonHandle
49 {
50  class Template;
51 }
52 
53 /// Error codes retured by PI_ResourceManager bind methods
54 /// @{
55 #define PI_BIND_OK 1
56 #define PI_NO_TEMPLATE_FOR_HANDLE -2
57 #define PI_INVALID_OP_PARM -3
58 #define PI_INVALID_PI_PARM -4
59 #define PI_BINDING_EXISTS -5
60 #define PI_INVALID_OP_FOR_PI -6
61 /// @}
62 
63 typedef void (*PI_SaveCallback)(void *data);
64 
66 {
67 public:
69 
70  // Note this is the channel name: the receiver should do a
71  // PRM_ParmList::getParmPtrFromChannel to get the parm.
72  const UT_String &getOpParm() const
73  { return myOpParm; }
74  const UT_String &getPIParm() const
75  { return myPIParm; }
76  int operator==(const PI_BindingParmInfo &i) const
77  { return (this == &i); }
78 
79 private:
80  UT_String myOpParm;
81  UT_String myPIParm;
82  friend class pi_OpHandleBinding;
83 };
84 
89 
91 {
92 public:
94 
95  const UT_String &getPIName() const
96  { return myPIName; }
97  const UT_String &getPIDescription() const
98  { return myPIDescription; }
100  { return myDefaultSettings; }
101  int getId() const
102  { return myId; }
104  { return myBindings; }
105  int operator==(const PI_BindingHandleInfo &i) const
106  { return (this == &i); }
107 
108 private:
109  UT_String myPIName;
110  UT_String myPIDescription;
111  PI_SettingList myDefaultSettings;
112  int myId;
113  PI_BindingParmArray myBindings;
114  friend class pi_OpHandleBinding;
115 };
117 
118 // See the bindSelector function for a description of all the data
119 // members of this class. They map directly to the bindSelector parameters.
121 {
122 public:
124 
125  const UT_String &getName() const
126  { return myName; }
127  const UT_String &getDescription() const
128  { return myDescription; }
129  const UT_String &getPrompt() const
130  { return myPrompt; }
131  const UT_String &getOpParm() const
132  { return myOpParm; }
133  const UT_String &getMenu() const
134  { return myMenu; }
135  const UT_String &getPrimMask() const
136  { return myPrimMask; }
137  int getOpInput() const
138  { return myOpInput; }
139  bool getOpInputReq() const
140  { return myOpInputReq; }
141  bool getAllowDrag() const
142  { return myAllowDrag; }
143  bool getAstSelAll() const
144  { return myAstSelAll; }
145  const UT_String &getExtraInfo() const
146  { return myExtraInfo; }
147  int operator==(const PI_BindingSelectorInfo &i) const
148  { return (this == &i); }
149 
150 private:
151  UT_String myName;
152  UT_String myDescription;
153  UT_String myPrompt;
154  UT_String myOpParm;
155  UT_String myMenu;
156  UT_String myPrimMask;
157  int myOpInput;
158  bool myOpInputReq;
159  bool myAllowDrag;
160  bool myAstSelAll;
161  UT_String myExtraInfo;
162  friend class pi_OpSelectorBinding;
163 };
165 
168 {
169 public:
171  ~PI_ResourceManager() override;
172 
173  // Return 1 on success and 0 if the state/handle/op-handle link
174  // is already registered.
175  virtual int registerState(PI_StateTemplate *type);
176  virtual int registerHandle(PI_HandleTemplate *type);
177  virtual int registerOpHandleLink(PI_PITemplate *type);
178  virtual int registerSelector(PI_SelectorTemplate *type);
179 
180  bool containsState(const char *name,
181  PI_ViewerType viewer_type,
182  unsigned netmask) const;
183  bool containsHandle(const char *name) const;
184  bool containsOpHandleLink(const char *name) const;
185  bool containsSelector(const char *name) const;
186 
187  // Get all the bound handles and parms for a given op type.
189  *getBindingHandles(OP_Operator *op) const;
190  // Get all the bound selectors for a given op type.
192  *getBindingSelectors(OP_Operator *op) const;
193 
194  // Return the list of states that can be used in a viewer for the
195  // specified network type.
197  &stateList(PI_ViewerType viewer_type,
198  const char *network_type) const;
200  &stateList(PI_ViewerType viewer_type,
201  PI_NetworkType net_type) const;
202  PI_StateTemplate *getStateTemplate(const char *name,
203  PI_ViewerType viewer_type,
204  const char *type) const;
205  PI_StateTemplate *getStateTemplate(OP_Operator *op,
206  PI_ViewerType viewer_type,
207  const char *type) const;
208 
209  // Viewer state handling
210  // Return the registration status of a state template.
212  getViewerStateRegisterStatus(
213  const char* state_name, PI_ViewerType viewer_type, const char* type) const;
214 
215  // Fires a register viewer state event callback
216  virtual void fireResourceEvent(
219  PI_PythonResource::EventMessage::Data const& event_data);
220 
221  // return true if the state name is valid
222  bool validStateTemplateName(const char* name) const;
223 
224  // unregister a python viewer state
225  virtual PI_PythonResource::Status unregisterViewerState(const char* name);
226 
227  // return true if a viewer state is registered
228  virtual bool isRegisteredViewerState(const char* name) const;
229 
230  // return a viewer state given a name
231  virtual PI_PythonState::Template const * viewerStateTemplate(const char * state_name) const;
232  virtual PI_PythonState::Template * viewerStateTemplate(const char * state_name) ;
233 
234  // Viewer Handles
235  virtual PI_PythonResource::Status unregisterViewerHandle(const char* name);
236  virtual bool isRegisteredViewerHandle(const char* name) const;
237 
238  virtual PI_PythonHandle::Template const*
239  viewerHandleTemplate(const char* handle_name) const;
240 
241  // These are functions which are called from commands that allow
242  // for dynamic binding of handles to parameters
243  int unbind(OP_Operator *op, const char *pidescription,
244  const UT_String &opparm);
245  int bind(OP_Operator *op, const char *piname,
246  const char *pidescription,
247  const UT_String &opparm,
248  const UT_String &piparm,
249  const char *default_settings);
250  // this API is typically used for handle late-binding e.g. python states
251  // would provide functions for binding handle parms
252  int bind(OP_Operator *op, const char *piname,
253  const char *pidescription,
254  const char *default_settings);
255  int bindScriptOp(OP_Operator *op, const char *piname,
256  const char *pidescription,
257  const UT_String &opparm,
258  const UT_String &piparm,
259  const char *default_settings);
260 
261  // Used for binding node operators to registered viewer states (i..e. python states)
262  // returns true if the operation succeeded
263  virtual bool bindOperatorToViewerState(const char* state_name, OP_Operator* op);
264 
265  // Returns true if a state is expected to exist for an operator of a given
266  // network type. By design, management operators are not expected to operate
267  // outside their own network, this function will return false in this case.
268  //
269  // op_name: operator name
270  // op_type: operator type e.g. DOP
271  bool operatorStateMandatory(const char* op_name, const char* op_type) const;
272 
273  /// Unbind the given selector from an operator. Uses the short description
274  /// when bound using bindSelector()
275  int unbindSelector(OP_Operator *op,
276  const char *seldescription);
277 
278  /// Dynamic binding of a selector to an operator
279  ///
280  /// @param op Operator type that we want to bind a selector to
281  /// @param sname Selector type
282  /// @param seldescription Short description that identifies this selector
283  /// in the context of a one operator (used to
284  /// unbind the selector).
285  /// @param prompt Text in the status area when the selector is
286  /// active.
287  /// @param opparm Operator parameter where the selection string
288  /// is put.
289  /// @param opinput Wire input index where the op owning the
290  /// selected geometry is attached to our op.
291  /// @param opinputreq Is an input is required?
292  /// @param primmask Mask of which primitive types can be in the
293  /// selection. This uses the *_FILEID enum in
294  /// GEO_PrimTypeCompat.h. A regular
295  /// GEO_PrimTypeCompat mask can be used if you
296  /// first convert it using
297  /// GEO_PrimTypeCompat::convertToFileFromMask()
298  /// @param allowdrag Determines if click-and-drag operations are
299  /// allowed.
300  /// @param menu Operator menu parameter where we choose the
301  /// selection type.
302  /// @param astselall If an asterisk is required in the selection
303  /// string to indicate selecting all the input.
304  /// Otherwise we assume an empty string indicates
305  /// that the whole geometry is selected.
306  /// @param extrainfo String that is passed to the selector,
307  /// particular selectors may need specific
308  /// parameters that can be passed through this
309  /// mechanism.
310  /// @param fromScriptOp Used by our dialog script parser to avoid
311  /// infinite recursion. Setting this flag decreases
312  /// the error checking we do.
313  ///
314  /// @return PI_BIND_OK upon success, else see of one of the other potential
315  /// error codes at the top of PI_ResourceManager.h
316  int bindSelector(OP_Operator *op, const char *sname,
317  const char *seldescription,
318  const char *prompt, const char *opparm,
319  int opinput, int opinputreq,
320  const char *primmask, int allowdrag,
321  const char *menu, int astselall,
322  const char *extrainfo, bool fromScriptOp);
323 
324  //Helper functions for the above
325  PRM_Template *getTemplateAndVecId(const UT_String &,
326  OP_Operator *,
327  int &) const;
328 
329  // This is for converting old style "t 2" into new style "tz". It
330  // only works if the operator has the template already, else it
331  // assumes channel name == parmname. Thus, it won't work on
332  // multiparms that only exist with OP_Node, not OP_Operator.
333  void getChannelNameFromParmAndVec(UT_String &chan,
334  OP_Operator *op, const char *parmname,
335  int vecidx);
336 
337  int checkForPIName( const char *pi_name,
338  const char *pi_parm ) const;
339 
340  OP_Operator *findOperator(PI_NetworkType net_type,
341  const char *op_name,
342  bool display_warning = true) const;
343  OP_Operator *findOperator(const char *opbindname,
344  UT_String *optype = 0) const;
345 
346  virtual void findVolatileKeys(const char *volatile_hotkey_name,
347  UT_Array<int> &volatile_keys,
348  UT_Array<int> &keys_modifiers)
349  const;
350  virtual void updateViewports(int id, const char *opname,
351  bool open_only = false) const;
352 
353  //These methods are used in PI_ResourceManagerCommand.C.
354  const PI_OpHandleLinkMap &getOpHandleLinks() const { return myOpHandleLinks; }
355  PI_PITemplate *getOpHandleLinkTemplate(const char *pi_name) const;
356  const PI_SelectorTemplateMap &getSelectors() const { return mySelectors; }
357  PI_SelectorTemplate *getSelectorTemplate(const char *selector_name) const;
358 
359  // The following method is used by builddialogs
360  const PI_HandleTemplateMap &getHandles() const { return myHandles; }
361 
362  // Tell us if the pi with the given name is an invisible PI by nature.
363  // Optionally return the type of the pi in isfloat (int or float assumed)
364  bool isPIEthereal(const char *piname,
365  bool *isfloat = 0) const;
366 
367  // Because the order of callbacks for OP_UpdateTableSink is
368  // undefined, some callbacks rely on the resource manager's table of states
369  // to be accurate. Since the resource manager's callback can happen
370  // after the other callbacks, they can call these methods to ensure the
371  // resource manager's table is accurate.
372  void ensureStatesExistForAllOperators(const char *net_type_name);
373  virtual void ensureStatesExistForAllOperators(PI_NetworkType net_type);
374 
375  // Map a viewer type token to a PI_ViewerType, or vice-versa.
376  static bool getViewerType(const char *viewer_type_token,
377  PI_ViewerType &type);
378  static void getViewerTypeToken(PI_ViewerType type,
379  UT_String &viewer_type_token);
380 
381  // Map the network name returned by OP_Node::getOpType() to a
382  // PI_NetworkType, or vice-versa.
383  static bool getNetworkType(const char *network_type_name,
384  PI_NetworkType &type);
385  static const UT_StringHolder &getNetworkTypeName(PI_NetworkType type);
386  static OP_OperatorTable *getOpTableFromOperator(const OP_Operator *op);
387 
388  // Choose the first network type from a mask that contains multiple ones.
389  static PI_NetworkType getFirstNetworkType(unsigned int network_mask);
390 
391  static PRM_Template *findParmTemplate(OP_Operator &op,
392  const char *op_Parm_name,
393  int vec_idx, int *parm_idx);
394 
395  // Write out our bindings information to a file.
396  int writeBindingsFile(const char *fname) const;
397 
398  // Load/save/remove the settings for a particular PI and a node that's
399  // linked to it.
400  void loadPISettingsFromTables(PI_OpHandleLink &pi,
401  bool okay_to_use_last_settings) const;
402  void savePISettingsToTables(PI_OpHandleLink &pi);
403  virtual void removePISettingsFromTables(OP_Operator &op_type);
404  void removePISettingsFromTables(const PI_OpHandleLink &pi);
405 
406  // Record settings for a particular PI. This method should only be
407  // called by the omparm command.
408  void recordPISettings(const char *pi_description,
409  const char *pi_type,
410  const OP_Node &op_node,
411  const char *settings);
412 
413  // Objects may add callbacks that are called just before the resource
414  // manager saves its data to the hip file. These callbacks update
415  // the resource manager to make sure the data it saves is current.
416  void addSaveCallback(PI_SaveCallback callback, void *data);
417  void removeSaveCallback(PI_SaveCallback callback,
418  void *data);
419 
420  void registerOpHandleBindings();
421  virtual void removeAllBindings(OP_Operator *op);
422 
423  // Returns the name of the state being created
424  char const* stateToCreate() const;
425 
426  // Set by BM_PythonSupport to give access to the python support
427  // object while the python resource instance is being created.
428  void setPythonResourceSupport(void* res_support);
429  void* getPythonResourceSupport();
430 
431 protected:
432  static void startParmsCache();
433  static void stopParmsCache();
434  static void getParmsCache(UT_ValArray<OP_Node *> *&ops,
435  UT_ValArray<PRM_Parm *> *&parms,
436  UT_IntArray *&vec_indices);
437  static void getParmsCacheBehaviour( bool &set_keys,
438  bool &do_scope,
439  bool &append_scope );
440 
441  // Save the name of the state being created.
442  void saveStateToCreate(char const* state);
443 public:
444  static int cacheParms();
445  static void appendToParmsCache(OP_Node *op, PRM_Parm *parm,
446  int vi);
447  static void setParmsCacheBehaviour( bool set_keys, bool do_scope,
448  bool append_scope );
449 
451  { return theHideLockedHandleParts; }
452  static void setHideLockedHandleParts( bool hide )
453  { theHideLockedHandleParts = hide; }
454  static bool getScopeChannelsOnKey()
455  { return theScopeChannelsOnKey; }
456  static void setScopeChannelsOnKey( bool scope )
457  { theScopeChannelsOnKey = scope; }
458  static bool getAddScopedChannels()
459  { return theAddScopedChannels; }
460  static void setAddScopedChannels( bool add )
461  { theAddScopedChannels = add; }
463  { return theOpenChannelEditorOnScope; }
464  static void setOpenChannelEditorOnScope( bool do_open )
465  { theOpenChannelEditorOnScope = do_open; }
466  static void getChannelScopeCommandPrefix( UT_String &str );
467 
468 
469 protected:
470  // Classes:
471 
473  {
474  public:
475  PI_OpPIKey(const char *pi_name_in_setting_table, const char *pi_type,
476  int op_id) :
477  myPINameInSettingTable(pi_name_in_setting_table),
478  myPIType(pi_type),
479  myOpId(op_id) {}
480 
481  bool operator==(const PI_OpPIKey &o) const
482  {
483  // myPIType is not used.
484  return myPINameInSettingTable == o.myPINameInSettingTable &&
485  myOpId == o.myOpId;
486  }
487 
489  {
490  // myPIType is not used.
491  SYS_HashType hash = myPINameInSettingTable.hash();
492  SYShashCombine(hash, myOpId);
493  return hash;
494  }
495 
496  UT_StringHolder piNameInSettingTable() const { return myPINameInSettingTable; }
497  UT_StringHolder piType() const { return myPIType; }
498  int opId() const { return myOpId; }
499 
500  struct Hasher
501  {
502  size_t operator()(const PI_OpPIKey &pk) const { return size_t(pk.hash()); }
503  };
504 
505  private:
506  UT_StringHolder myPINameInSettingTable;
507  UT_StringHolder myPIType;
508  int myOpId;
509  };
510 
512  {
515  };
516 
517  // Methods:
518 
519  void installCommands();
520  void registerOpHandleLinks();
521  void registerCopHandleLinks();
522  void registerOpHandleConstructors();
523  void registerSelectors();
524  void registerSelectorConstructors();
525 
526  // Functions used by registerOpHandleLinks for loading the OPbindings file.
527  bool isValidPiParmName( const UT_String &pi_name,
528  const UT_String &pi_parm);
529  void loadHandle(CPP_Manager &cppman, OP_Operator *op,
530  pi_OpHandleBinding *binding);
531  void loadSelector(CPP_Manager &cppman,
532  const UT_String &selname,
533  const UT_String &seldescription,
534  pi_OpSelectorBinding *binding);
535  void loadOperator(CPP_Manager &cppman,
536  const UT_String &oppath);
537  void loadOperator(CPP_Manager &cppman,
538  const UT_String &optype,
539  OP_Operator *op,
540  pi_OpHandleBinding *hbinding,
541  pi_OpSelectorBinding *sbinding);
542 
543  virtual void addAutomaticStates(PI_NetworkType net_type);
544  void tableUpdated(OP_OperatorTable *table) override;
545  void tableDeleted(OP_OperatorTable *table) override;
546  void templatesUpdated(OP_Operator *op) override;
547  void operatorDeleted(OP_Operator *op) override;
548  void ensureTableInterestExists(PI_NetworkType net_type,
550 
551  PI_HandleTemplate *getHandleTemplate(const char *handle_name) const;
552 
553  // Save all the PI settings to a stream.
554  static OP_ERROR savePIResourceManagerCallback(std::ostream &os,
555  void *data);
556  OP_ERROR saveSettings(std::ostream &os) const;
557 
558  // We need the non-const version of getDefaultPISettings() because we
559  // might need to sort the default settings.
560  const PI_SettingList *getDefaultPISettings(OP_Operator &op_type,
561  const char *type_name,
562  const char *description) const;
563  PI_SettingList *getDefaultPISettings(OP_Operator &op_type,
564  const char *type_name,
565  const char *description);
566 
567  // Clear and re-create the bindings if necessary
568  void resetOpBindings(OP_Operator *op);
569 
570  // This method is implemented by the leaf class (i.e. MT_ResourceManager)
571  // and is used for updating the PI Settings (i.e. handle settings)
572  // loaded from the PI setting tables (loadPISettingsFromTables).
573  // MT_ResourceManager uses the latest PI settings registered by a
574  // python state to update the loaded settings.
575 
576  // pi_settings: The PI settings to update. The implementation should
577  // update it directly and return the same pointer.
578  // op: The owner operator.
579  // pi_type: The PI type name.
580  // pi_name: The PI description name.
581  virtual PI_SettingList const * onUpdatePISettings( PI_SettingList const& pi_settings,
582  OP_Operator & op,
583  char const* pi_type,
584  char const* pi_name) const;
585 
586  // Data:
587  using PI_SaveCallbackInfo = std::pair<PI_SaveCallback, void *>;
593 
596 
599 
603 
605  void* myCurrentPythonSupport = nullptr;
606 
607  static bool ourSetKeyOnParms;
608  static bool ourScopeParmChannels;
609  static bool ourAppendToScope;
610  static int ourCacheParms;
614 
617  static bool theAddScopedChannels;
619 };
620 
622 PI_API extern void PIcreateResourceManager(bool verbose=true);
623 PI_API extern bool PIresourceManagerExists();
624 
625 #endif
int operator==(const PI_BindingSelectorInfo &i) const
int operator==(const PI_BindingHandleInfo &i) const
const UT_String & getPrompt() const
UT_StringHolder piNameInSettingTable() const
GLuint const GLchar * name
Definition: glew.h:1814
Unsorted map container.
Definition: UT_Map.h:83
const PI_OpHandleLinkMap & getOpHandleLinks() const
UT_Array< PI_SaveCallbackInfo > mySaveCallbacks
PI_HandleTemplateMap myHandles
static bool theOpenChannelEditorOnScope
const PI_SelectorTemplateMap & getSelectors() const
static UT_ValArray< OP_Node * > ourParmNodes
UT_SymbolMap< pi_OpHandleBinding * > myOpHandleBindings
PI_API void PIcreateResourceManager(bool verbose=true)
static void setScopeChannelsOnKey(bool scope)
PI_OpHandleLinkMap myOpHandleLinks
PI_NetworkType
static bool getAddScopedChannels()
GLenum GLsizei GLenum GLenum const void * table
Definition: glew.h:4940
PI_ViewerType
PI_OpPIKey(const char *pi_name_in_setting_table, const char *pi_type, int op_id)
std::size_t SYS_HashType
Define the type for hash values.
Definition: SYS_Hash.h:19
UT_ErrorSeverity
Definition: UT_Error.h:25
const PI_SettingList & getDefaultSettings() const
#define PI_API
Definition: PI_API.h:10
static void setOpenChannelEditorOnScope(bool do_open)
PI_API bool PIresourceManagerExists()
UT_StringHolder piType() const
void(* PI_SaveCallback)(void *data)
PI_SelectorTemplateMap mySelectors
const UT_String & getPIDescription() const
static bool theHideLockedHandleParts
bool operator==(const PI_OpPIKey &o) const
static bool theScopeChannelsOnKey
UT_SymbolMap< PI_NetworkType > myNetworkTypeTable
static UT_IntArray ourParmVecIndices
GLint GLenum GLsizei GLint GLsizei const void * data
Definition: glew.h:1379
static bool ourScopeParmChannels
const UT_String & getOpParm() const
size_t operator()(const PI_OpPIKey &pk) const
void
Definition: png.h:1083
static bool getHideLockedHandleParts()
const UT_String & getPrimMask() const
std::pair< PI_SaveCallback, void * > PI_SaveCallbackInfo
static bool getOpenChannelEditorOnScope()
static void setAddScopedChannels(bool add)
const UT_String & getExtraInfo() const
GLuint GLuint GLsizei GLenum type
Definition: glew.h:1253
static bool getScopeChannelsOnKey()
PI_API PI_ResourceManager * PIgetResourceManager()
static void setHideLockedHandleParts(bool hide)
static bool theAddScopedChannels
const UT_String & getPIName() const
const PI_HandleTemplateMap & getHandles() const
const PI_BindingParmArray & getBindings() const
const UT_String & getMenu() const
static bool ourSetKeyOnParms
UT_StringHolder myStateBeingCreated
UT_Map< PI_OpPIKey, OpPISettingInfo, PI_OpPIKey::Hasher > myPISettingsForOps
const UT_String & getDescription() const
constexpr T pi()
Pi constant taken from Boost to match old behaviour.
Definition: Math.h:108
UT_SymbolMap< pi_OpSelectorBinding * > myOpSelectorBindings
static UT_ValArray< PRM_Parm * > ourParms
ImageBuf OIIO_API add(Image_or_Const A, Image_or_Const B, ROI roi={}, int nthreads=0)
int operator==(const PI_BindingParmInfo &i) const
static bool ourAppendToScope
const UT_String & getName() const
UT_StringMap< PI_SettingList * > myLastPISettings
const UT_String & getPIParm() const
const UT_String & getOpParm() const