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