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