HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
PRM_ParmList.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: PRM_ParmList.h (Parameter Library)
7  *
8  * COMMENTS:
9  * This class is in charge of organizing PRM_Parms.
10  * It also handles variables associated with a group
11  * of parameters.
12  */
13 
14 #ifndef __PRM_ParmList__
15 #define __PRM_ParmList__
16 
17 #include "PRM_API.h"
18 #include "PRM_ChanState.h"
19 #include "PRM_Name.h"
20 #include "PRM_Parm.h"
21 #include "PRM_Template.h"
22 #include <CH/CH_EventManager.h>
23 #include <CH/CH_Types.h>
24 #include <UT/UT_ArrayMap.h>
25 #include <UT/UT_SharedPtr.h>
26 #include <UT/UT_StringHolder.h>
27 #include <SYS/SYS_Inline.h>
28 
29 #include <iosfwd>
30 
31 
32 class UT_TokenString;
33 class UT_StringArray;
34 class CH_Collection;
35 class PRM_Multi;
36 class PRM_PresetInfo;
37 class PRM_ParmNameMap;
38 class PRM_OpSharedInfo;
39 
40 typedef enum {
41  PRM_RALL = 0004, /// Read, write, execute all
42  PRM_WALL = 0002,
43  PRM_XALL = 0001,
44  PRM_RGRP = 0040, /// Read, write, execute group
45  PRM_WGRP = 0020,
46  PRM_XGRP = 0010,
47  PRM_RUSR = 0400, /// Read, write, execute user
48  PRM_WUSR = 0200,
49  PRM_XUSR = 0100,
50 
51  PRM_RWXALL = 0007,
52  PRM_RWXGRP = 0070,
53  PRM_RWXUSR = 0700,
54  PRM_RWX = 0777,
55 
60 
62 {
63 public:
64  virtual ~PRM_ORCallback() {}
65 
66  virtual fpreal getFloatOverride( int data_idx, fpreal time,
67  int *tdepend, int *enable ) = 0;
68  virtual bool setFloatOverride( int data_idx, fpreal time,
69  int *tdepend, int *enable, fpreal newvalue ) = 0;
70 
71  virtual exint getIntOverride( int data_idx, fpreal time,
72  int *tdepend, int *enable ) = 0;
73  virtual bool setIntOverride( int data_idx, fpreal time,
74  int *tdepend, int *enable, exint newvalue ) = 0;
75 
76  virtual UT_StringHolder getStringOverride( int data_idx, fpreal time,
77  int *tdepend, int *enable ) = 0;
78  virtual bool setStringOverride( int data_idx, fpreal time,
79  int *tdepend, int *enable, const UT_StringHolder &newvalue ) = 0;
80 };
81 
83 {
84 public:
85  PRM_ParmList(PRM_Template *thetemplates,
86  CH_Collection *thechgroupptr,
87  PRM_ParmOwner *node,
88  PRM_PresetInfo *presetinfo,
89  const UT_StringRef &optype,
90  bool clear_channels);
91 
92  PRM_ParmList(PRM_Template *thetemplates,
93  CH_Collection *thechgroupptr,
94  PRM_ParmOwner *node,
95  PRM_PresetInfo *presetinfo,
96  const UT_StringRef &optype,
97  bool clear_channels,
98  bool build_delayed_defaults);
99 
100  /// Constructor used to make a new parm list when
101  /// loading a new PRM_Template. This assumes that the
102  /// channel collection and variables remains the same.
103  PRM_ParmList(PRM_ParmList *thesrcptr,
104  PRM_Template *thenewtemplate,
105  PRM_ParmOwner *node,
106  PRM_PresetInfo *presetinfo,
107  const UT_StringRef &optype,
108  bool leavedefaultsunchanged);
109  ~PRM_ParmList();
110 
111 
112  int getEntries() const { return myParms.entries(); }
113 
114  // These two must be redundant now that the constructor has
115  // the channel collection in it.
116  void setChannelGroupPtr(CH_Collection *thechgroupptr)
117  { myChannelGroupPtr = thechgroupptr; }
119  { return myChannelGroupPtr; }
120 
121  fpreal getEvalTime(int thread) const;
122 
123  fpreal findNextKey(fpreal theoldtime);
124  fpreal findPrevKey(fpreal theoldtime);
125 
126  /// returns 1 if all the parms in the list are at their default values
127  /// returns 0 otherwise
128  int allDefaults() const;
129 
130  // This will call revertToDefaults on parms which haven't had their
131  // defaults set, thereby delaying the creation of multiparm entries until
132  // after we have built all our templates.
133  void buildDelayedDefaults( bool clear_channels = true );
134 
135  PRM_Parm *getParmPtr(const UT_StringRef &theparmname,
136  int &theparmidx);
137  PRM_Parm *getParmPtr(const UT_StringRef &theparmname);
138  const PRM_Parm *getParmPtr(const UT_StringRef &theparmname) const;
139  PRM_Parm *getParmPtr(const PRM_Name &name);
140  const PRM_Parm *getParmPtr(const PRM_Name &name) const;
141 
142  PRM_Parm *getParmPtr(const int theindex)
143  {
144  return (theindex >= 0 && theindex < myParms.entries())
145  ? myParms(theindex)
146  : 0;
147  }
148  const PRM_Parm *getParmPtr(const int theindex) const
149  {
150  return (theindex >= 0 && theindex < myParms.entries())
151  ? myParms(theindex)
152  : 0;
153  }
154 
155 
156  int getParmIndex(const PRM_Parm *parm) const;
157  int getParmIndex(const UT_StringRef &parmname) const;
158  int getParmIndex(const PRM_Name &name) const
159  { return getParmIndex(name.getTokenRef()); }
160 
163  const UT_StringRef &channel,
164  int *vecidx = nullptr) const
165  {
166  int i = getParmIndexFromChannel(
167  channel, vecidx, /*allow_alias*/true);
168  if (i < 0)
169  return nullptr;
170  return myParms(i);
171  }
174  const UT_StringRef &channel,
175  int *vecidx = nullptr)
176  {
177  int i = getParmIndexFromChannel(
178  channel, vecidx, /*allow_alias*/true);
179  if (i < 0)
180  return nullptr;
181  return myParms(i);
182  }
183  int getParmIndex(const UT_StringRef &channel_name,
184  int &subidx,
185  bool allow_alias = true) const
186  {
187  return getParmIndexFromChannel(
188  channel_name, &subidx, allow_alias);
189  }
190  int getParmIndexFromChannel(const UT_StringRef &channel,
191  int *vecidx,
192  bool allow_alias) const;
193 
194  // Clear the dirty flags for all parameters, or query if all dirty flags
195  // are clear.
196  void clearAllDirtyFlags();
197  int areAllFlagsClean() const;
198  void clearAllUndoSavedFlags();
199 
200  void revertToDefaults(fpreal time);
201 
202  void revertValuesToFactoryDefaults();
203 
204  // When the PRM_Template changes (i.e. reloading a new operator
205  // definition), the new PRM_ParmList is created and then this method is
206  // called to copy over any pertinent information from the old PRM_ParmList.
207  void updateFromOldTemplate(PRM_ParmList *oldlist);
208  // When the spare parameter definitions for a node changes, this function
209  // is called to update the parameters to be in line with the new set of
210  // templates. The old templates must still exist at this point.
211  void updateSpareParmTemplates(PRM_Template *newtemplates,
212  bool leavedefaultsunchanged);
213 
214  void saveSingle(PRM_Parm *, std::ostream &os,
215  int binary) const;
216  void save(std::ostream &os,
217  int binary, bool compiled) const;
218  bool load(UT_IStream &is, const char *path,
219  PRM_ParmList *obsoleteparms);
220 
221  void saveUndoData(PRM_UndoDataList &data) const;
222  void saveSingleUndoData(const PRM_Parm *parm,
223  PRM_UndoDataList &data) const;
224  void loadUndoData(const PRM_UndoDataList &data,
225  const char *path,
226  PRM_ParmList *obsoleteparms);
227 
228  /// Methods to load and save channel aliases
229  /// @{
230  void saveChannelAliases(std::ostream &os, int binary);
231  bool loadChannelAliases(UT_IStream &is, const char *path);
232  /// @}
233  /// Returns true if any of our parms have an alias and false otherwise
234  bool hasChannelAliases() const;
235 
236  void clearAndDestroyChannels();
237  int hasAnyChannels();
238  int addChannel(const UT_StringRef &name);
239  void reloadChannelPtrs();
240  int channelPtrModified(const UT_StringRef &name);
241 
242  unsigned getUserMask() const { return myUserMask; }
243  void setUserMask(unsigned m)
244  { myUserMask = m & PRM_RWX; }
245  unsigned getPermissions() const { return myPermissions; }
246  void setPermissions(unsigned mask)
247  { mask &= PRM_RWX;
248  if (mask != myPermissions)
249  {
250  myPermissions = mask;
251  sendChangeEvent(CH_PERMISSION_CHANGED);
252  }
253  }
254  unsigned getAssetPermissionMask() const
255  { return myAssetPermissionMask; }
257  { mask &= PRM_RWX;
258  if (mask != myAssetPermissionMask)
259  {
260  myAssetPermissionMask = mask;
261  sendChangeEvent(CH_PERMISSION_CHANGED);
262  }
263  }
264 
265  // By default, the canAccess method just tests to see if the OP is
266  // writeable.
267  int canAccess(unsigned mask=PRM_WRITE_OK,
268  const PRM_Type &type=PRM_TYPE_ZERO) const;
269  int canAccessIgnoringAssetMask(
270  unsigned mask=PRM_WRITE_OK,
271  const PRM_Type &type=PRM_TYPE_ZERO) const;
272  int canAccessCheckingOnlyAssetMask(
273  unsigned mask=PRM_WRITE_OK,
274  const PRM_Type &type=PRM_TYPE_ZERO) const;
275 
276  static void beginLoading();
277  static void endLoading();
278  static bool isLoading();
279 
280  void hardenChanges(fpreal time, bool forceflag = 0,
281  const char *patt=0,
282  CH_ChannelRefList *list=0);
283 
284  PRM_ChanState getChanState(fpreal time);
285  void sendChangeEvent(CH_CHANGE_TYPE what, PRM_Parm *who=0);
286  void setEventHandler(void *data,
287  void (*handler)(void *, CH_CHANGE_TYPE, int))
288  {
289  myEventObject = data;
290  myEventHandler = handler;
291  }
292 
293  /// If the parm list is not already flagged as time dependent then
294  /// checkTimeDependence will scan the parms for time dependencies and
295  /// return the new time dependence flag.
296  /// @note Expressions will not be flagged as time dependent until
297  /// they're evaluated. So, if it's possible that the channels have not
298  /// been evaluated, set evaluate_channels to true.
299  int checkTimeDependence(bool evaluate_channels = false);
300 
302  void setTimeDependent(bool onOff)
303  { myTimeDependent=onOff;}
305  bool getTimeDependent() const
306  { return myTimeDependent; }
308  void setCookTimeDependent(bool onOff)
309  { myCookTimeDependent=onOff;}
311  bool getCookTimeDependent() const
312  { return myCookTimeDependent; }
313 
315  { if (!opt.isstring()) return;
317  myContextOptionDeps,
318  &myContextOptionDepsLock).insert(opt); }
321  myContextOptionDepsLock);
322  myContextOptionDeps.reset(); }
325  myContextOptionDeps); }
327  { if (!opt.isstring()) return;
329  myCookContextOptionDeps,
330  &myContextOptionDepsLock).insert(opt); }
333  myContextOptionDepsLock);
334  myCookContextOptionDeps.reset(); }
337  myCookContextOptionDeps); }
338 
339  // the override callback is static
340  static PRM_ORCallback *getORCallback() { return theORCallback; }
341  static void setORCallback(PRM_ORCallback *impl)
342  { theORCallback = impl; }
343 
344  void pushVariables(); // These should only be used
345  void popVariables(); // by PSI for syntax reasons
346 
347  int findString(const char *str, bool fullword,
348  bool usewildcards) const;
349  int changeString(const char *from, const char *to,
350  bool fullword);
351 
352  bool notifyVarChange(const char *varname);
353 
354  /// This used to be called getSendExtraEvent()
355  int getNumSendExtra() const
356  { return myNumSendExtra; }
357  void bumpNumSendExtra(int n)
358  { myNumSendExtra += n; }
359 
360  /// Return a unique identifier for the current parameter settings. If this
361  /// is called outside of a cook, place a PRM_AutoBlockErrors around the
362  /// call.
363  void getMagicString(UT_TokenString &string,
364  fpreal t, int parm_group = 1);
365 
366  void setUndoSavedFlag() { myUndoSavedFlag = true; }
368  { myAutoTakeUndoSavedFlag = true; }
369 
370  // Appends a block of multiparm instance parameters.
371  void appendMultiParms(const PRM_Multi &multiparmowner,
372  PRM_Template *templ, int num, bool spare,
373  const UT_IntArray &instance,
374  UT_ValArray<PRM_Parm *> &newparms);
375 
376  void removeAndDestroyParm(int index);
377 
378  void insertMultiParmItem(int index, int i);
379  void removeMultiParmItem(int index, int i);
380 
381  PRM_ParmOwner *getParmOwner() const { return myParmOwner; }
382  PRM_PresetInfo *getPresetInfo() const { return myPresetInfo; }
383  void clearParmOwner();
384 
385  /// checkMultiParmInstance() will return true if the given parm name matches
386  /// a multi-parm instance name. If the multi-parm instance isn't created
387  /// yet, then it will be created before this function returns. In that case,
388  /// do_owner_init specifies if the new instance should be initialized.
389  bool checkMultiParmInstance(const UT_StringRef &parmname,
390  bool do_owner_init);
391 
392  /// This method is used to alias a channel name to a another name
393  /// Returns true if successful and false otherwise.
394  /// NOTE: you should not need to use this directly, you should instead
395  /// call the OP_Node version.
396  bool setChannelAlias(PRM_Parm &parm, int subindex,
397  const UT_StringHolder &chan_alias);
398 
399  int64 getMemoryUsage(bool inclusive) const;
400 
401  unsigned long getAddRemoveCount() const
402  { return myAddRemoveCount; }
403  void setAddRemoveCount(unsigned long count)
404  { myAddRemoveCount = count; }
405 
406  /// Convenience functions for evaluating and setting parameters
407  /// @{
408  void evalStringRaw(UT_String &value,
409  const UT_StringRef &pn, int vi,
410  fpreal t);
411  void evalString(UT_String &value,
412  const UT_StringRef &pn, int vi, fpreal t);
413  void setString(const UT_String &value,
414  CH_StringMeaning meaning,
415  const UT_StringRef &pn, int vi, fpreal t,
416  bool propagate);
417  int evalInt(const UT_StringRef &pn, int vi, fpreal t);
418  void setInt(int value, const UT_StringRef &pn, int vi,
419  fpreal t, bool propagate);
420  fpreal evalFloat(const UT_StringRef &pn, int vi, fpreal t);
421  void setFloat(fpreal value, const UT_StringRef &pn, int vi,
422  fpreal t, bool propagate);
423  /// @}
424 
425 
426  DEP_MicroNode & parmMicroNode(int parm_idx, int vi);
427  bool hasParmMicroNode(int parm_idx) const;
428 
429  /// Get all parm micronodes for the entire parm list
430  void getParmMicroNodes(DEP_MicroNodeList &micronodes) const;
431 
432  void propagateDirtyParmMicroNodes(
433  int parm_index, // can be -1 for all
434  DEP_MicroNode::Visitor client_visit,
435  DEP_MicroNode *parmlist_micronode,
436  bool force);
437 
438  void clearMicroNodeInputs();
439  void getParmInputList(
440  DEP_MicroNodeList &inputs,
441  bool cooking_only = false) const;
442  int getNumParmInputs() const;
443  void getParmOutputList(
444  DEP_MicroNodeList &outputs,
445  bool cooking_only = false) const;
446 
447  void dumpMicroNodes(
448  std::ostream &os,
449  bool as_DOT,
450  int indent_level=0) const;
451  int64 getMicroNodesMemoryUsage() const;
452 
453  // This function removes the shared parmhash info for the specified
454  // operator from the shared info table. The data will get deleted
455  // as soon as the last PRM_ParmList with a pointer to the shared
456  // info gets deleted.
457  static void removeOpSharedInfo(const UT_StringRef &optoken);
458  // This functions changes the name under which some shred parm
459  // hash info is stored in our table. This is done when the name
460  // of an operator type changes.
461  static void renameOpSharedInfo(const UT_StringRef &oldoptoken,
462  const UT_StringHolder &newoptoken);
463 
465  const int *instance,
466  int nest_level)
467  {
468  int unused;
469  const PRM_Parm *p = static_cast<const PRM_ParmList*>(this)
470  ->getParmPtrInst(parm_name, instance, nest_level, unused);
471  return const_cast<PRM_Parm*>(p);
472  }
474  const int *instance,
475  int nest_level,
476  int &theparmidx)
477  {
478  const PRM_Parm *p = static_cast<const PRM_ParmList*>(this)
479  ->getParmPtrInst(parm_name, instance, nest_level, theparmidx);
480  return const_cast<PRM_Parm*>(p);
481  }
482  const PRM_Parm *getParmPtrInst(const UT_StringRef &parm_name,
483  const int *instance,
484  int nest_level) const
485  {
486  int unused;
487  return getParmPtrInst(parm_name, instance, nest_level, unused);
488  }
489  const PRM_Parm *getParmPtrInst(const UT_StringRef &parm_name,
490  const int *instance,
491  int nest_level,
492  int &theparmidx) const;
493 
494 private: // forbid usage of these functions
496  PRM_ParmList &operator =(const PRM_ParmList &copy);
497 
498  void moveMultiParmAlias(int index, int i, bool up);
499  void loadUnknownParmNames(UT_IStream &is,
501  PRM_ParmList *obsoleteparms);
502  PRM_Parm *findLoadParm(const UT_StringRef &name,
503  PRM_ParmList *obsoleteparms,
504  PRM_ParmNameMap *nmap,
505  bool try_again=true);
506 
507  // Adopt the common parms (including animating parms) from the source.
508  // Note that the source parm list will be changed.
509  void adoptParmList(
510  PRM_ParmList &thesource,
511  bool leavedefaultsunchanged);
512 
513  static bool shouldCopyOnAdopt(
514  PRM_Template &dst_template,
515  PRM_Parm &srcparm,
516  bool leavedefaultsunchanged);
517 
518  // Adopt the values and other important information from one parm into
519  // another. The parms don't have to be from the same PRM_ParmList, but
520  // they can be. This allows this function to be used from the adopt()
521  // function above, or from updateSpareParms(). Note that the source
522  // parm will be changed.
523  void adoptParm(
524  PRM_Parm &dstparm,
525  PRM_Parm &srcparm,
526  bool leavedefaultsunchanged);
527 
528  void adoptChannelAlias(
529  PRM_Parm &dst_parm,
530  const PRM_Parm &src_parm);
531 
532  PRM_Parm *appendParm(
533  PRM_Parm *parm,
534  const PRM_Template &temp);
535  PRM_Parm *createMultiInstanceParm(
536  PRM_Template &temp,
537  bool spare,
538  const PRM_Multi &multiparmowner);
539  PRM_Parm *createSpareParm(
540  PRM_Template &temp);
541 
542  int findChannelIndex(const UT_StringRef &chan_name,
543  bool allow_alias) const;
544 
545 private: // data
546  UT_ValArray<PRM_Parm *> myParms;
547 
548  unsigned long myAddRemoveCount;
549 
550  // The following member data holds a pointer to shared hash tables.
551  // This is a hash table of all the parameters for this op type. This
552  // table is shared by all operators of this type. This implies two
553  // things. First, it doesn't contain spare parms or multiparm instances.
554  // Second, all operators must keep their "standard" parms always at
555  // the start of myParms (before any spare or multi parms). Otherwise
556  // The indexes for these parms would be different for each node.
557  // NOTE: The channel table is not a list of active animated channels,
558  // but a list of all possible channel names.
559  UT_SharedPtr<PRM_OpSharedInfo> myOpSharedInfo;
560 
561  // This is the hash table for holding the parm indices of spare parms
562  // and multiparm instances for this node. It is not shared, obviously.
563  // NOTE: The channel table is not a list of active animated channels,
564  // but a list of all possible channel names.
565  UT_ArrayStringMap<int> mySpareAndMultiParmHashTable;
566  UT_ArrayStringMap<int> mySpareAndMultiChannelTable;
567 
568  // This is the symbol table of channel aliases. It is also not shared,
569  // as channel aliases are per-node not per-type. Because channel aliases
570  // are always per-node, we don't need separate tables for regular parms
571  // and spare/multi parms.
572  UT_ArrayStringMap<int> myChannelAliasesTable;
573 
574  // Names of state vars on which parms in this parm list are dependent.
575  DEP_ContextOptionDepsLock myContextOptionDepsLock;
576  DEP_ContextOptionDepsPtr myContextOptionDeps;
577  DEP_ContextOptionDepsPtr myCookContextOptionDeps;
578 
579  unsigned myPermissions;
580  unsigned myUserMask;
581  unsigned myAssetPermissionMask;
582 
583  CH_Collection *myChannelGroupPtr;
584  PRM_ParmOwner *myParmOwner;
585  PRM_PresetInfo *myPresetInfo;
586 
587  void (*myEventHandler)(void *, CH_CHANGE_TYPE, int);
588  void *myEventObject;
589 
590  // myNumSendExtra is incremented whenever a parameter that has its dirty
591  // and sendExtra flags set. It should be set from the PRM_Parm::setValue
592  // code paths and it should be decremented after a OP_PRM_CHANGED or
593  // equivalent event has been sent out.
594  int myNumSendExtra;
595 
596  // This are promoted to full bool's for better performance
597  bool myTimeDependent;
598  bool myCookTimeDependent;
599 
600  bool myUndoSavedFlag;
601  bool myAutoTakeUndoSavedFlag;
602 
603  static PRM_ORCallback *theORCallback;
604  static fpreal32 theFileVersion;
605  static int thePRMLoadCount;
606 };
607 
608 #endif
void setChannelGroupPtr(CH_Collection *thechgroupptr)
Definition: PRM_ParmList.h:116
const PRM_Parm * getParmPtrInst(const UT_StringRef &parm_name, const int *instance, int nest_level) const
Definition: PRM_ParmList.h:482
const PRM_Parm * getParmPtr(const int theindex) const
Definition: PRM_ParmList.h:148
std::function< void(DEP_MicroNode &, DEP_MicroNode &) > Visitor
SYS_FORCE_INLINE void setCookTimeDependent(bool onOff)
Definition: PRM_ParmList.h:308
UT_UniquePtr< DEP_ContextOptionDeps > DEP_ContextOptionDepsPtr
void setUserMask(unsigned m)
Definition: PRM_ParmList.h:243
GLuint const GLchar * name
Definition: glew.h:1814
void setUndoSavedFlag()
Definition: PRM_ParmList.h:366
CH_StringMeaning
GT_API const UT_StringHolder time
GLuint index
Definition: glew.h:1814
DEP_API const DEP_ContextOptionDeps & DEPgetContextOptionDepsFromPtr(const DEP_ContextOptionDepsPtr &ptr)
UT_ConcurrentSet< UT_StringHolder > DEP_ContextOptionDeps
SYS_FORCE_INLINE PRM_Parm * getParmPtrFromChannel(const UT_StringRef &channel, int *vecidx=nullptr)
Definition: PRM_ParmList.h:173
void setEventHandler(void *data, void(*handler)(void *, CH_CHANGE_TYPE, int))
Definition: PRM_ParmList.h:286
static void setORCallback(PRM_ORCallback *impl)
Definition: PRM_ParmList.h:341
int64 exint
Definition: SYS_Types.h:125
const GLdouble * m
Definition: glew.h:9124
GLenum GLint GLuint mask
Definition: glew.h:1845
unsigned getAssetPermissionMask() const
Definition: PRM_ParmList.h:254
float fpreal32
Definition: SYS_Types.h:200
SYS_FORCE_INLINE bool getCookTimeDependent() const
Definition: PRM_ParmList.h:311
void bumpNumSendExtra(int n)
Definition: PRM_ParmList.h:357
unsigned getPermissions() const
Definition: PRM_ParmList.h:245
unsigned long getAddRemoveCount() const
Definition: PRM_ParmList.h:401
Read, write, execute user.
Definition: PRM_ParmList.h:48
SYS_FORCE_INLINE const PRM_Parm * getParmPtrFromChannel(const UT_StringRef &channel, int *vecidx=nullptr) const
Definition: PRM_ParmList.h:162
void setAddRemoveCount(unsigned long count)
Definition: PRM_ParmList.h:403
int getNumSendExtra() const
This used to be called getSendExtraEvent()
Definition: PRM_ParmList.h:355
PRM_ParmOwner * getParmOwner() const
Definition: PRM_ParmList.h:381
CH_CHANGE_TYPE
PRM_API const PRM_Type PRM_TYPE_ZERO
void addContextOptionDep(const UT_StringHolder &opt)
Definition: PRM_ParmList.h:314
int getParmIndex(const UT_StringRef &channel_name, int &subidx, bool allow_alias=true) const
Definition: PRM_ParmList.h:183
const UT_StringRef & getTokenRef() const
Use this for hash tables, might be the sentinel value.
Definition: PRM_Name.h:95
std::shared_ptr< T > UT_SharedPtr
Wrapper around std::shared_ptr.
Definition: UT_SharedPtr.h:28
GLint GLenum GLsizei GLint GLsizei const void * data
Definition: glew.h:1379
SYS_FORCE_INLINE bool getTimeDependent() const
Definition: PRM_ParmList.h:305
const GLuint GLenum const void * binary
Definition: glew.h:3502
PRM_ChanState
Definition: PRM_ChanState.h:14
#define SYS_FORCE_INLINE
Definition: SYS_Inline.h:45
PRM_Parm * getParmPtr(const int theindex)
Definition: PRM_ParmList.h:142
void addCookContextOptionDep(const UT_StringHolder &opt)
Definition: PRM_ParmList.h:326
void
Definition: png.h:1083
PRM_PresetInfo * getPresetInfo() const
Definition: PRM_ParmList.h:382
GLuint const GLuint * names
Definition: glew.h:2690
GLsizei n
Definition: glew.h:4040
const DEP_ContextOptionDeps & getContextOptionDeps() const
Definition: PRM_ParmList.h:323
virtual ~PRM_ORCallback()
Definition: PRM_ParmList.h:64
long long int64
Definition: SYS_Types.h:116
typedef int(WINAPI *PFNWGLRELEASEPBUFFERDCARBPROC)(HPBUFFERARB hPbuffer
PRM_Parm * getParmPtrInst(const UT_StringRef &parm_name, const int *instance, int nest_level, int &theparmidx)
Definition: PRM_ParmList.h:473
static PRM_ORCallback * getORCallback()
Definition: PRM_ParmList.h:340
*Note that the tasks the is the thread number *for the or if it s being executed by a non pool thread(this *can happen in cases where the whole pool is occupied and the calling *thread contributes to running the work load).**Thread pool.Have fun
GLuint GLuint GLsizei GLenum type
Definition: glew.h:1253
void clearContextOptionDeps()
Definition: PRM_ParmList.h:319
void setPermissions(unsigned mask)
Definition: PRM_ParmList.h:246
GLsizei const GLchar *const * path
Definition: glew.h:6461
GLfloat GLfloat p
Definition: glew.h:16321
void setAutoTakeUndoSavedFlag()
Definition: PRM_ParmList.h:367
void setAssetPermissionMask(unsigned mask)
Definition: PRM_ParmList.h:256
GLuint num
Definition: glew.h:2690
GA_API const UT_StringHolder up
fpreal64 fpreal
Definition: SYS_Types.h:277
int getParmIndex(const PRM_Name &name) const
Definition: PRM_ParmList.h:158
const DEP_ContextOptionDeps & getCookContextOptionDeps() const
Definition: PRM_ParmList.h:335
OIIO_API bool copy(string_view from, string_view to, std::string &err)
Read, write, execute all.
Definition: PRM_ParmList.h:42
GLuint GLuint GLsizei count
Definition: glew.h:1253
PRM_Permission
Definition: PRM_ParmList.h:40
Read, write, execute group.
Definition: PRM_ParmList.h:45
DEP_API DEP_ContextOptionDeps & DEPcreateContextOptionDepsFromPtr(DEP_ContextOptionDepsPtr &ptr, DEP_ContextOptionDepsLock *lock=nullptr)
void clearCookContextOptionDeps()
Definition: PRM_ParmList.h:331
unsigned getUserMask() const
Definition: PRM_ParmList.h:242
CH_Collection * getChannelGroupPtr() const
Definition: PRM_ParmList.h:118
PRM_Parm * getParmPtrInst(const UT_StringRef &parm_name, const int *instance, int nest_level)
Definition: PRM_ParmList.h:464
#define PRM_API
Definition: PRM_API.h:10
GLsizei const GLfloat * value
Definition: glew.h:1849
GLboolean enable
Definition: glew.h:2745
GLdouble GLdouble t
Definition: glew.h:1398
SYS_FORCE_INLINE bool isstring() const
SYS_FORCE_INLINE void setTimeDependent(bool onOff)
Definition: PRM_ParmList.h:302
int getEntries() const
Definition: PRM_ParmList.h:112