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  bool binary) const;
216  void save(std::ostream &os,
217  bool 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, bool 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  /// Returns true if this parameter list has any spare or multi instance
237  /// parameters.
238  bool hasSpareOrMultiInstanceParms() const;
239 
240  void clearAndDestroyChannels();
241  int hasAnyChannels();
242  int addChannel(const UT_StringRef &name);
243  void reloadChannelPtrs();
244  int channelPtrModified(const UT_StringRef &name);
245 
246  unsigned getUserMask() const { return myUserMask; }
247  void setUserMask(unsigned m)
248  { myUserMask = m & PRM_RWX; }
249  unsigned getPermissions() const { return myPermissions; }
250  void setPermissions(unsigned mask)
251  { mask &= PRM_RWX;
252  if (mask != myPermissions)
253  {
254  myPermissions = mask;
255  sendChangeEvent(CH_PERMISSION_CHANGED);
256  }
257  }
258  unsigned getAssetPermissionMask() const
259  { return myAssetPermissionMask; }
261  { mask &= PRM_RWX;
262  if (mask != myAssetPermissionMask)
263  {
264  myAssetPermissionMask = mask;
265  sendChangeEvent(CH_PERMISSION_CHANGED);
266  }
267  }
268 
269  // By default, the canAccess method just tests to see if the OP is
270  // writeable.
271  int canAccess(unsigned mask=PRM_WRITE_OK,
272  const PRM_Type &type=PRM_TYPE_ZERO) const;
273  int canAccessIgnoringAssetMask(
274  unsigned mask=PRM_WRITE_OK,
275  const PRM_Type &type=PRM_TYPE_ZERO) const;
276  int canAccessCheckingOnlyAssetMask(
277  unsigned mask=PRM_WRITE_OK,
278  const PRM_Type &type=PRM_TYPE_ZERO) const;
279 
280  static void beginLoading();
281  static void endLoading();
282  static bool isLoading();
283 
284  void hardenChanges(fpreal time, bool forceflag = 0,
285  const char *patt=0,
286  CH_ChannelRefList *list=0);
287 
288  PRM_ChanState getChanState(fpreal time);
289  void sendChangeEvent(CH_CHANGE_TYPE what, PRM_Parm *who=0);
290  void setEventHandler(void *data,
291  void (*handler)(void *, CH_CHANGE_TYPE, int))
292  {
293  myEventObject = data;
294  myEventHandler = handler;
295  }
296 
297  /// If the parm list is not already flagged as time dependent then
298  /// checkTimeDependence will scan the parms for time dependencies and
299  /// return the new time dependence flag.
300  /// @note Expressions will not be flagged as time dependent until
301  /// they're evaluated. So, if it's possible that the channels have not
302  /// been evaluated, set evaluate_channels to true.
303  int checkTimeDependence(bool evaluate_channels = false);
304 
306  void setTimeDependent(bool onOff)
307  { myTimeDependent=onOff;}
309  bool getTimeDependent() const
310  { return myTimeDependent; }
312  void setCookTimeDependent(bool onOff)
313  { myCookTimeDependent=onOff;}
315  bool getCookTimeDependent() const
316  { return myCookTimeDependent; }
317 
319  { if (!opt.isstring()) return;
321  myContextOptionDeps,
322  &myContextOptionDepsLock).insert(opt); }
325  myContextOptionDepsLock);
326  myContextOptionDeps.reset(); }
329  myContextOptionDeps); }
331  { if (!opt.isstring()) return;
333  myCookContextOptionDeps,
334  &myContextOptionDepsLock).insert(opt); }
337  myContextOptionDepsLock);
338  myCookContextOptionDeps.reset(); }
341  myCookContextOptionDeps); }
342 
343  // the override callback is static
344  static PRM_ORCallback *getORCallback() { return theORCallback; }
345  static void setORCallback(PRM_ORCallback *impl)
346  { theORCallback = impl; }
347 
348  void pushVariables(); // These should only be used
349  void popVariables(); // by PSI for syntax reasons
350 
351  int findString(const char *str, bool fullword,
352  bool usewildcards) const;
353  int changeString(const char *from, const char *to,
354  bool fullword);
355 
356  bool notifyVarChange(const char *varname);
357 
358  /// This used to be called getSendExtraEvent()
359  int getNumSendExtra() const
360  { return myNumSendExtra; }
361  void bumpNumSendExtra(int n)
362  { myNumSendExtra += n; }
363 
364  /// Return a unique identifier for the current parameter settings. If this
365  /// is called outside of a cook, place a PRM_AutoBlockErrors around the
366  /// call.
367  void getMagicString(UT_TokenString &string,
368  fpreal t, int parm_group = 1);
369 
370  bool getUndoSavedFlag() const { return myUndoSavedFlag; }
371  void setUndoSavedFlag() { myUndoSavedFlag = true; }
373  { myAutoTakeUndoSavedFlag = true; }
374 
375  // Appends a block of multiparm instance parameters.
376  void appendMultiParms(const PRM_Multi &multiparmowner,
377  PRM_Template *templ, int num, bool spare,
378  const UT_IntArray &instance,
379  UT_ValArray<PRM_Parm *> &newparms);
380 
381  void removeAndDestroyParm(int index);
382 
383  void insertMultiParmItem(int index, int i);
384  void removeMultiParmItem(int index, int i);
385 
386  PRM_ParmOwner *getParmOwner() const { return myParmOwner; }
387  PRM_PresetInfo *getPresetInfo() const { return myPresetInfo; }
388  void clearParmOwner();
389 
390  /// checkMultiParmInstance() will return true if the given parm name matches
391  /// a multi-parm instance name. If the multi-parm instance isn't created
392  /// yet, then it will be created before this function returns. In that case,
393  /// do_owner_init specifies if the new instance should be initialized.
394  bool checkMultiParmInstance(const UT_StringRef &parmname,
395  bool do_owner_init);
396 
397  /// This method is used to alias a channel name to a another name
398  /// Returns true if successful and false otherwise.
399  /// NOTE: you should not need to use this directly, you should instead
400  /// call the OP_Node version.
401  bool setChannelAlias(PRM_Parm &parm, int subindex,
402  const UT_StringHolder &chan_alias);
403 
404  int64 getMemoryUsage(bool inclusive) const;
405 
406  unsigned long getAddRemoveCount() const
407  { return myAddRemoveCount; }
408  void setAddRemoveCount(unsigned long count)
409  { myAddRemoveCount = count; }
410 
411  /// Convenience functions for evaluating and setting parameters
412  /// @{
413  void evalStringRaw(UT_String &value,
414  const UT_StringRef &pn, int vi,
415  fpreal t);
416  void evalStringRaw(UT_StringHolder &value,
417  const UT_StringRef &pn, int vi,
418  fpreal t);
419  void evalString(UT_String &value,
420  const UT_StringRef &pn, int vi, fpreal t);
421  void evalString(UT_StringHolder &value,
422  const UT_StringRef &pn, int vi, fpreal t);
423  void setString(const UT_String &value,
424  CH_StringMeaning meaning,
425  const UT_StringRef &pn, int vi, fpreal t,
426  bool propagate);
427  int evalInt(const UT_StringRef &pn, int vi, fpreal t);
428  void setInt(int value, const UT_StringRef &pn, int vi,
429  fpreal t, bool propagate);
430  fpreal evalFloat(const UT_StringRef &pn, int vi, fpreal t);
431  void setFloat(fpreal value, const UT_StringRef &pn, int vi,
432  fpreal t, bool propagate);
433  /// @}
434 
435 
436  DEP_MicroNode & parmMicroNode(int parm_idx, int vi);
437  bool hasParmMicroNode(int parm_idx) const;
438 
439  /// Get all parm micronodes for the entire parm list
440  void getParmMicroNodes(DEP_MicroNodeList &micronodes) const;
441 
442  void propagateDirtyParmMicroNodes(
443  int parm_index, // can be -1 for all
444  DEP_MicroNode::Visitor client_visit,
445  DEP_MicroNode *parmlist_micronode,
446  bool force);
447 
448  void clearMicroNodeInputs();
449  void getParmInputList(
450  DEP_MicroNodeList &inputs,
451  bool cooking_only = false) const;
452  int getNumParmInputs() const;
453  void getParmOutputList(
454  DEP_MicroNodeList &outputs,
455  bool cooking_only = false) const;
456 
457  void dumpMicroNodes(
458  std::ostream &os,
459  bool as_DOT,
460  int indent_level=0) const;
461  int64 getMicroNodesMemoryUsage() const;
462 
463  // This function removes the shared parmhash info for the specified
464  // operator from the shared info table. The data will get deleted
465  // as soon as the last PRM_ParmList with a pointer to the shared
466  // info gets deleted.
467  static void removeOpSharedInfo(const UT_StringRef &optoken);
468  // This functions changes the name under which some shred parm
469  // hash info is stored in our table. This is done when the name
470  // of an operator type changes.
471  static void renameOpSharedInfo(const UT_StringRef &oldoptoken,
472  const UT_StringHolder &newoptoken);
473 
475  const int *instance,
476  int nest_level)
477  {
478  int unused;
479  const PRM_Parm *p = static_cast<const PRM_ParmList*>(this)
480  ->getParmPtrInst(parm_name, instance, nest_level, unused);
481  return const_cast<PRM_Parm*>(p);
482  }
484  const int *instance,
485  int nest_level,
486  int &theparmidx)
487  {
488  const PRM_Parm *p = static_cast<const PRM_ParmList*>(this)
489  ->getParmPtrInst(parm_name, instance, nest_level, theparmidx);
490  return const_cast<PRM_Parm*>(p);
491  }
492  const PRM_Parm *getParmPtrInst(const UT_StringRef &parm_name,
493  const int *instance,
494  int nest_level) const
495  {
496  int unused;
497  return getParmPtrInst(parm_name, instance, nest_level, unused);
498  }
499  const PRM_Parm *getParmPtrInst(const UT_StringRef &parm_name,
500  const int *instance,
501  int nest_level,
502  int &theparmidx) const;
503 
504 
505  // Create or return a const parm micro node.
506  // Const parm micro nodes always ignore time dependencies.
507  DEP_MicroNode & constParmMicroNode(int parm_idx, int vi);
508 
509 private: // forbid usage of these functions
512 
513  void moveMultiParmAlias(int index, int i, bool up);
514  void loadUnknownParmNames(UT_IStream &is,
515  UT_StringArray &names,
516  PRM_ParmList *obsoleteparms);
517  PRM_Parm *findLoadParm(const UT_StringRef &name,
518  PRM_ParmList *obsoleteparms,
519  PRM_ParmNameMap *nmap,
520  bool try_again=true);
521 
522  // Adopt the common parms (including animating parms) from the source.
523  // Note that the source parm list will be changed.
524  void adoptParmList(
525  PRM_ParmList &thesource,
526  bool leavedefaultsunchanged);
527 
528  static bool shouldCopyOnAdopt(
529  PRM_Template &dst_template,
530  PRM_Parm &srcparm,
531  bool leavedefaultsunchanged);
532 
533  // Adopt the values and other important information from one parm into
534  // another. The parms don't have to be from the same PRM_ParmList, but
535  // they can be. This allows this function to be used from the adopt()
536  // function above, or from updateSpareParms(). Note that the source
537  // parm will be changed.
538  void adoptParm(
539  PRM_Parm &dstparm,
540  PRM_Parm &srcparm,
541  bool leavedefaultsunchanged);
542 
543  void adoptChannelAlias(
544  PRM_Parm &dst_parm,
545  const PRM_Parm &src_parm);
546 
547  PRM_Parm *appendParm(
548  PRM_Parm *parm,
549  const PRM_Template &temp);
550  PRM_Parm *createMultiInstanceParm(
551  PRM_Template &temp,
552  bool spare,
553  const PRM_Multi &multiparmowner);
554  PRM_Parm *createSpareParm(
555  PRM_Template &temp);
556 
557  int findChannelIndex(const UT_StringRef &chan_name,
558  bool allow_alias) const;
559 
560 private: // data
561  UT_ValArray<PRM_Parm *> myParms;
562 
563  unsigned long myAddRemoveCount;
564 
565  // The following member data holds a pointer to shared hash tables.
566  // This is a hash table of all the parameters for this op type. This
567  // table is shared by all operators of this type. This implies two
568  // things. First, it doesn't contain spare parms or multiparm instances.
569  // Second, all operators must keep their "standard" parms always at
570  // the start of myParms (before any spare or multi parms). Otherwise
571  // The indexes for these parms would be different for each node.
572  // NOTE: The channel table is not a list of active animated channels,
573  // but a list of all possible channel names.
574  UT_SharedPtr<PRM_OpSharedInfo> myOpSharedInfo;
575 
576  // This is the hash table for holding the parm indices of spare parms
577  // and multiparm instances for this node. It is not shared, obviously.
578  // NOTE: The channel table is not a list of active animated channels,
579  // but a list of all possible channel names.
580  UT_ArrayStringMap<int> mySpareAndMultiParmHashTable;
581  UT_ArrayStringMap<int> mySpareAndMultiChannelTable;
582 
583  // This is the symbol table of channel aliases. It is also not shared,
584  // as channel aliases are per-node not per-type. Because channel aliases
585  // are always per-node, we don't need separate tables for regular parms
586  // and spare/multi parms.
587  UT_ArrayStringMap<int> myChannelAliasesTable;
588 
589  // Names of state vars on which parms in this parm list are dependent.
590  DEP_ContextOptionDepsLock myContextOptionDepsLock;
591  DEP_ContextOptionDepsPtr myContextOptionDeps;
592  DEP_ContextOptionDepsPtr myCookContextOptionDeps;
593 
594  unsigned myPermissions;
595  unsigned myUserMask;
596  unsigned myAssetPermissionMask;
597 
598  CH_Collection *myChannelGroupPtr;
599  PRM_ParmOwner *myParmOwner;
600  PRM_PresetInfo *myPresetInfo;
601 
602  void (*myEventHandler)(void *, CH_CHANGE_TYPE, int);
603  void *myEventObject;
604 
605  // myNumSendExtra is incremented whenever a parameter that has its dirty
606  // and sendExtra flags set. It should be set from the PRM_Parm::setValue
607  // code paths and it should be decremented after a OP_PRM_CHANGED or
608  // equivalent event has been sent out.
609  int myNumSendExtra;
610 
611  // This are promoted to full bool's for better performance
612  bool myTimeDependent;
613  bool myCookTimeDependent;
614 
615  bool myUndoSavedFlag;
616  bool myAutoTakeUndoSavedFlag;
617 
618  static PRM_ORCallback *theORCallback;
619  static fpreal32 theFileVersion;
620  static int thePRMLoadCount;
621 };
622 
623 #endif
void setChannelGroupPtr(CH_Collection *thechgroupptr)
Definition: PRM_ParmList.h:116
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:492
const PRM_Parm * getParmPtr(const int theindex) const
Definition: PRM_ParmList.h:148
SYS_FORCE_INLINE void setCookTimeDependent(bool onOff)
Definition: PRM_ParmList.h:312
UT_UniquePtr< DEP_ContextOptionDeps > DEP_ContextOptionDepsPtr
void setUserMask(unsigned m)
Definition: PRM_ParmList.h:247
void setUndoSavedFlag()
Definition: PRM_ParmList.h:371
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)
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:173
void setEventHandler(void *data, void(*handler)(void *, CH_CHANGE_TYPE, int))
Definition: PRM_ParmList.h:290
GLsizei const GLchar *const * path
Definition: glcorearb.h:3341
static void setORCallback(PRM_ORCallback *impl)
Definition: PRM_ParmList.h:345
int64 exint
Definition: SYS_Types.h:125
unsigned getAssetPermissionMask() const
Definition: PRM_ParmList.h:258
float fpreal32
Definition: SYS_Types.h:200
SYS_FORCE_INLINE bool getCookTimeDependent() const
Definition: PRM_ParmList.h:315
void bumpNumSendExtra(int n)
Definition: PRM_ParmList.h:361
unsigned getPermissions() const
Definition: PRM_ParmList.h:249
unsigned long getAddRemoveCount() const
Definition: PRM_ParmList.h:406
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:408
int getNumSendExtra() const
This used to be called getSendExtraEvent()
Definition: PRM_ParmList.h:359
GLdouble n
Definition: glcorearb.h:2008
PRM_ParmOwner * getParmOwner() const
Definition: PRM_ParmList.h:386
CH_CHANGE_TYPE
PRM_API const PRM_Type PRM_TYPE_ZERO
void addContextOptionDep(const UT_StringHolder &opt)
Definition: PRM_ParmList.h:318
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: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:309
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:142
void addCookContextOptionDep(const UT_StringHolder &opt)
Definition: PRM_ParmList.h:330
PRM_PresetInfo * getPresetInfo() const
Definition: PRM_ParmList.h:387
GLint GLuint mask
Definition: glcorearb.h:124
const DEP_ContextOptionDeps & getContextOptionDeps() const
Definition: PRM_ParmList.h:327
virtual ~PRM_ORCallback()
Definition: PRM_ParmList.h:64
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:483
static PRM_ORCallback * getORCallback()
Definition: PRM_ParmList.h:344
GLuint const GLchar * name
Definition: glcorearb.h:786
void clearContextOptionDeps()
Definition: PRM_ParmList.h:323
void setPermissions(unsigned mask)
Definition: PRM_ParmList.h:250
GLdouble t
Definition: glad.h:2397
bool getUndoSavedFlag() const
Definition: PRM_ParmList.h:370
**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:372
void setAssetPermissionMask(unsigned mask)
Definition: PRM_ParmList.h:260
SIM_API const UT_StringHolder force
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:339
LeafData & operator=(const LeafData &)=delete
GLuint index
Definition: glcorearb.h:786
Read, write, execute all.
Definition: PRM_ParmList.h:42
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)
Definition: core.h:1131
void clearCookContextOptionDeps()
Definition: PRM_ParmList.h:335
unsigned getUserMask() const
Definition: PRM_ParmList.h:246
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:474
type
Definition: core.h:1059
#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:306
Definition: format.h:895
int getEntries() const
Definition: PRM_ParmList.h:112