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  void setUndoSavedFlag() { myUndoSavedFlag = true; }
372  { myAutoTakeUndoSavedFlag = true; }
373 
374  // Appends a block of multiparm instance parameters.
375  void appendMultiParms(const PRM_Multi &multiparmowner,
376  PRM_Template *templ, int num, bool spare,
377  const UT_IntArray &instance,
378  UT_ValArray<PRM_Parm *> &newparms);
379 
380  void removeAndDestroyParm(int index);
381 
382  void insertMultiParmItem(int index, int i);
383  void removeMultiParmItem(int index, int i);
384 
385  PRM_ParmOwner *getParmOwner() const { return myParmOwner; }
386  PRM_PresetInfo *getPresetInfo() const { return myPresetInfo; }
387  void clearParmOwner();
388 
389  /// checkMultiParmInstance() will return true if the given parm name matches
390  /// a multi-parm instance name. If the multi-parm instance isn't created
391  /// yet, then it will be created before this function returns. In that case,
392  /// do_owner_init specifies if the new instance should be initialized.
393  bool checkMultiParmInstance(const UT_StringRef &parmname,
394  bool do_owner_init);
395 
396  /// This method is used to alias a channel name to a another name
397  /// Returns true if successful and false otherwise.
398  /// NOTE: you should not need to use this directly, you should instead
399  /// call the OP_Node version.
400  bool setChannelAlias(PRM_Parm &parm, int subindex,
401  const UT_StringHolder &chan_alias);
402 
403  int64 getMemoryUsage(bool inclusive) const;
404 
405  unsigned long getAddRemoveCount() const
406  { return myAddRemoveCount; }
407  void setAddRemoveCount(unsigned long count)
408  { myAddRemoveCount = count; }
409 
410  /// Convenience functions for evaluating and setting parameters
411  /// @{
412  void evalStringRaw(UT_String &value,
413  const UT_StringRef &pn, int vi,
414  fpreal t);
415  void evalStringRaw(UT_StringHolder &value,
416  const UT_StringRef &pn, int vi,
417  fpreal t);
418  void evalString(UT_String &value,
419  const UT_StringRef &pn, int vi, fpreal t);
420  void evalString(UT_StringHolder &value,
421  const UT_StringRef &pn, int vi, fpreal t);
422  void setString(const UT_String &value,
423  CH_StringMeaning meaning,
424  const UT_StringRef &pn, int vi, fpreal t,
425  bool propagate);
426  int evalInt(const UT_StringRef &pn, int vi, fpreal t);
427  void setInt(int value, const UT_StringRef &pn, int vi,
428  fpreal t, bool propagate);
429  fpreal evalFloat(const UT_StringRef &pn, int vi, fpreal t);
430  void setFloat(fpreal value, const UT_StringRef &pn, int vi,
431  fpreal t, bool propagate);
432  /// @}
433 
434 
435  DEP_MicroNode & parmMicroNode(int parm_idx, int vi);
436  bool hasParmMicroNode(int parm_idx) const;
437 
438  /// Get all parm micronodes for the entire parm list
439  void getParmMicroNodes(DEP_MicroNodeList &micronodes) const;
440 
441  void propagateDirtyParmMicroNodes(
442  int parm_index, // can be -1 for all
443  DEP_MicroNode::Visitor client_visit,
444  DEP_MicroNode *parmlist_micronode,
445  bool force);
446 
447  void clearMicroNodeInputs();
448  void getParmInputList(
449  DEP_MicroNodeList &inputs,
450  bool cooking_only = false) const;
451  int getNumParmInputs() const;
452  void getParmOutputList(
453  DEP_MicroNodeList &outputs,
454  bool cooking_only = false) const;
455 
456  void dumpMicroNodes(
457  std::ostream &os,
458  bool as_DOT,
459  int indent_level=0) const;
460  int64 getMicroNodesMemoryUsage() const;
461 
462  // This function removes the shared parmhash info for the specified
463  // operator from the shared info table. The data will get deleted
464  // as soon as the last PRM_ParmList with a pointer to the shared
465  // info gets deleted.
466  static void removeOpSharedInfo(const UT_StringRef &optoken);
467  // This functions changes the name under which some shred parm
468  // hash info is stored in our table. This is done when the name
469  // of an operator type changes.
470  static void renameOpSharedInfo(const UT_StringRef &oldoptoken,
471  const UT_StringHolder &newoptoken);
472 
474  const int *instance,
475  int nest_level)
476  {
477  int unused;
478  const PRM_Parm *p = static_cast<const PRM_ParmList*>(this)
479  ->getParmPtrInst(parm_name, instance, nest_level, unused);
480  return const_cast<PRM_Parm*>(p);
481  }
483  const int *instance,
484  int nest_level,
485  int &theparmidx)
486  {
487  const PRM_Parm *p = static_cast<const PRM_ParmList*>(this)
488  ->getParmPtrInst(parm_name, instance, nest_level, theparmidx);
489  return const_cast<PRM_Parm*>(p);
490  }
491  const PRM_Parm *getParmPtrInst(const UT_StringRef &parm_name,
492  const int *instance,
493  int nest_level) const
494  {
495  int unused;
496  return getParmPtrInst(parm_name, instance, nest_level, unused);
497  }
498  const PRM_Parm *getParmPtrInst(const UT_StringRef &parm_name,
499  const int *instance,
500  int nest_level,
501  int &theparmidx) const;
502 
503 
504  // Create or return a const parm micro node.
505  // Const parm micro nodes always ignore time dependencies.
506  DEP_MicroNode & constParmMicroNode(int parm_idx, int vi);
507 
508 private: // forbid usage of these functions
510  PRM_ParmList &operator =(const PRM_ParmList &copy);
511 
512  void moveMultiParmAlias(int index, int i, bool up);
513  void loadUnknownParmNames(UT_IStream &is,
515  PRM_ParmList *obsoleteparms);
516  PRM_Parm *findLoadParm(const UT_StringRef &name,
517  PRM_ParmList *obsoleteparms,
518  PRM_ParmNameMap *nmap,
519  bool try_again=true);
520 
521  // Adopt the common parms (including animating parms) from the source.
522  // Note that the source parm list will be changed.
523  void adoptParmList(
524  PRM_ParmList &thesource,
525  bool leavedefaultsunchanged);
526 
527  static bool shouldCopyOnAdopt(
528  PRM_Template &dst_template,
529  PRM_Parm &srcparm,
530  bool leavedefaultsunchanged);
531 
532  // Adopt the values and other important information from one parm into
533  // another. The parms don't have to be from the same PRM_ParmList, but
534  // they can be. This allows this function to be used from the adopt()
535  // function above, or from updateSpareParms(). Note that the source
536  // parm will be changed.
537  void adoptParm(
538  PRM_Parm &dstparm,
539  PRM_Parm &srcparm,
540  bool leavedefaultsunchanged);
541 
542  void adoptChannelAlias(
543  PRM_Parm &dst_parm,
544  const PRM_Parm &src_parm);
545 
546  PRM_Parm *appendParm(
547  PRM_Parm *parm,
548  const PRM_Template &temp);
549  PRM_Parm *createMultiInstanceParm(
550  PRM_Template &temp,
551  bool spare,
552  const PRM_Multi &multiparmowner);
553  PRM_Parm *createSpareParm(
554  PRM_Template &temp);
555 
556  int findChannelIndex(const UT_StringRef &chan_name,
557  bool allow_alias) const;
558 
559 private: // data
560  UT_ValArray<PRM_Parm *> myParms;
561 
562  unsigned long myAddRemoveCount;
563 
564  // The following member data holds a pointer to shared hash tables.
565  // This is a hash table of all the parameters for this op type. This
566  // table is shared by all operators of this type. This implies two
567  // things. First, it doesn't contain spare parms or multiparm instances.
568  // Second, all operators must keep their "standard" parms always at
569  // the start of myParms (before any spare or multi parms). Otherwise
570  // The indexes for these parms would be different for each node.
571  // NOTE: The channel table is not a list of active animated channels,
572  // but a list of all possible channel names.
573  UT_SharedPtr<PRM_OpSharedInfo> myOpSharedInfo;
574 
575  // This is the hash table for holding the parm indices of spare parms
576  // and multiparm instances for this node. It is not shared, obviously.
577  // NOTE: The channel table is not a list of active animated channels,
578  // but a list of all possible channel names.
579  UT_ArrayStringMap<int> mySpareAndMultiParmHashTable;
580  UT_ArrayStringMap<int> mySpareAndMultiChannelTable;
581 
582  // This is the symbol table of channel aliases. It is also not shared,
583  // as channel aliases are per-node not per-type. Because channel aliases
584  // are always per-node, we don't need separate tables for regular parms
585  // and spare/multi parms.
586  UT_ArrayStringMap<int> myChannelAliasesTable;
587 
588  // Names of state vars on which parms in this parm list are dependent.
589  DEP_ContextOptionDepsLock myContextOptionDepsLock;
590  DEP_ContextOptionDepsPtr myContextOptionDeps;
591  DEP_ContextOptionDepsPtr myCookContextOptionDeps;
592 
593  unsigned myPermissions;
594  unsigned myUserMask;
595  unsigned myAssetPermissionMask;
596 
597  CH_Collection *myChannelGroupPtr;
598  PRM_ParmOwner *myParmOwner;
599  PRM_PresetInfo *myPresetInfo;
600 
601  void (*myEventHandler)(void *, CH_CHANGE_TYPE, int);
602  void *myEventObject;
603 
604  // myNumSendExtra is incremented whenever a parameter that has its dirty
605  // and sendExtra flags set. It should be set from the PRM_Parm::setValue
606  // code paths and it should be decremented after a OP_PRM_CHANGED or
607  // equivalent event has been sent out.
608  int myNumSendExtra;
609 
610  // This are promoted to full bool's for better performance
611  bool myTimeDependent;
612  bool myCookTimeDependent;
613 
614  bool myUndoSavedFlag;
615  bool myAutoTakeUndoSavedFlag;
616 
617  static PRM_ORCallback *theORCallback;
618  static fpreal32 theFileVersion;
619  static int thePRMLoadCount;
620 };
621 
622 #endif
void setChannelGroupPtr(CH_Collection *thechgroupptr)
Definition: PRM_ParmList.h:116
GLboolean enable
Definition: glew.h:2750
const PRM_Parm * getParmPtrInst(const UT_StringRef &parm_name, const int *instance, int nest_level) const
Definition: PRM_ParmList.h:491
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:312
UT_UniquePtr< DEP_ContextOptionDeps > DEP_ContextOptionDepsPtr
void setUserMask(unsigned m)
Definition: PRM_ParmList.h:247
void setUndoSavedFlag()
Definition: PRM_ParmList.h:370
void
Definition: png.h:1083
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
GLuint const GLchar * name
Definition: glcorearb.h:786
unsigned getAssetPermissionMask() const
Definition: PRM_ParmList.h:258
float fpreal32
Definition: SYS_Types.h:200
GLdouble GLdouble t
Definition: glew.h:1403
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:405
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:407
int getNumSendExtra() const
This used to be called getSendExtraEvent()
Definition: PRM_ParmList.h:359
PRM_ParmOwner * getParmOwner() const
Definition: PRM_ParmList.h:385
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
GLint GLuint mask
Definition: glcorearb.h:124
SYS_FORCE_INLINE bool getTimeDependent() const
Definition: PRM_ParmList.h:309
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
GLuint num
Definition: glew.h:2695
void addCookContextOptionDep(const UT_StringHolder &opt)
Definition: PRM_ParmList.h:330
PRM_PresetInfo * getPresetInfo() const
Definition: PRM_ParmList.h:386
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
GLfloat GLfloat p
Definition: glew.h:16656
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:482
GLuint const GLuint * names
Definition: glew.h:2695
static PRM_ORCallback * getORCallback()
Definition: PRM_ParmList.h:344
GLint GLsizei count
Definition: glcorearb.h:405
void clearContextOptionDeps()
Definition: PRM_ParmList.h:323
void setPermissions(unsigned mask)
Definition: PRM_ParmList.h:250
GLdouble n
Definition: glcorearb.h:2008
GLboolean * data
Definition: glcorearb.h:131
**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:371
void setAssetPermissionMask(unsigned mask)
Definition: PRM_ParmList.h:260
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
GLuint index
Definition: glcorearb.h:786
Read, write, execute all.
Definition: PRM_ParmList.h:42
const GLdouble * m
Definition: glew.h:9166
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
type
Definition: core.h:1059
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:473
#define PRM_API
Definition: PRM_API.h:10
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