HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
PRM_Template.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_Template.h (Parameter Library)
7  *
8  * COMMENTS:
9  * PRM_Template is the class which contains all the static data
10  * relating to a parameter. It encapsulates the characteristics
11  * of the parameter, such as type, default values, range, etc.
12  * A PRM_Template is used in conjunction with a PRM_Instance to
13  * define a PRM_Parm. A PRM_Instance is to a PRM_Template as
14  * an object is to a class in C++.
15  */
16 
17 #ifndef __PRM_Template__
18 #define __PRM_Template__
19 
20 #include "PRM_API.h"
21 #include "PRM_Callback.h"
22 #include "PRM_ConditionalType.h"
23 #include "PRM_Name.h"
24 #include "PRM_Type.h"
25 #include <UT/UT_Assert.h>
26 #include <UT/UT_IntArray.h>
27 #include <UT/UT_String.h>
28 #include <UT/UT_StringHolder.h>
29 #include <UT/UT_UniquePtr.h>
30 #include <UT/UT_ValArray.h>
31 #include <SYS/SYS_Types.h>
32 
33 #define PRM_TYPE_IS_SWITCHER(type) (type.isSwitcher())
34 #define PRM_IS_JOIN(parm) ((parm).getTypeExtended() == PRM_TYPE_TOGGLE_JOIN || \
35  (parm).getTypeExtended() == PRM_TYPE_JOIN_PAIR || \
36  (parm).getTypeExtended() == PRM_TYPE_MENU_JOIN)
37 
38 class UT_WorkBuffer;
39 class PRM_ChoiceList;
40 class PRM_Conditional;
42 class PRM_Range;
43 class PRM_Default;
44 class PRM_Template;
45 class PRM_SpareData;
46 
48 
50 {
51 public:
52  // An export level is a hint to say if a parm should be displayed or not.
53  // By default, all parms have minimum export level, which means that
54  // they are only displayed if someone asks for a dialog with the minimum
55  // export level. Creating a dialog with a higher export level will only
56  // contain those parameters with higher export levels.
58  {
62  PRM_EXPORT_TBX // for toolboxes
63  };
64 
65  enum
66  {
67  // This is maximum vector size for parameters. This is because we keep
68  // per component flags in uint32 variables. For myAutoScopeField, we
69  // use the high-bit to keep track of whether it's initialized so the
70  // actual limit is 31, not 32.
71  MAX_VECTOR_SIZE = 31
72  };
73 
74  // No extended type given and no export level given.
76  int thevectorsize = 1,
77  PRM_Name *thenameptr = 0,
78  PRM_Default *thedefaults = 0,
79  PRM_ChoiceList *thechoicelistptr = 0,
80  PRM_Range *therangeptr = 0,
81  PRM_Callback thecallbackfunc = 0,
82  PRM_SpareData *thespareptr = 0,
83  int theparmgroup = 1,
84  const char *thehelptext = 0,
85  PRM_ConditionalBase *thecondptr = 0);
86 
87  // No extended type given but export level given.
88  PRM_Template(PRM_Type thetype,
89  PRM_Export theexportlevel,
90  int thevectorsize = 1,
91  PRM_Name *thenameptr = 0,
92  PRM_Default *thedefaults = 0,
93  PRM_ChoiceList *thechoicelistptr = 0,
94  PRM_Range *therangeptr = 0,
95  PRM_Callback thecallbackfunc = 0,
96  PRM_SpareData *thespareptr = 0,
97  int theparmgroup = 1,
98  const char *thehelptext = 0,
99  PRM_ConditionalBase *thecondptr = 0);
100 
101  // Extended type given but no export level given.
102  PRM_Template(PRM_Type thetype,
103  PRM_TypeExtended thetype_ext,
104  int thevectorsize = 1,
105  PRM_Name *thenameptr = 0,
106  PRM_Default *thedefaults = 0,
107  PRM_ChoiceList *thechoicelistptr = 0,
108  PRM_Range *therangeptr = 0,
109  PRM_Callback thecallbackfunc = 0,
110  PRM_SpareData *thespareptr = 0,
111  int theparmgroup = 1,
112  const char *thehelptext = 0,
113  PRM_ConditionalBase *thecondptr = 0);
114 
115  // Extended type given and export level given.
116  PRM_Template(PRM_Type thetype,
117  PRM_TypeExtended thetype_ext,
118  PRM_Export theexportlevel,
119  int thevectorsize = 1,
120  PRM_Name *thenameptr = 0,
121  PRM_Default *thedefaults = 0,
122  PRM_ChoiceList *thechoicelistptr = 0,
123  PRM_Range *therangeptr = 0,
124  PRM_Callback thecallbackfunc = 0,
125  PRM_SpareData *thespareptr = 0,
126  int theparmgroup = 1,
127  const char *thehelptext = 0,
128  PRM_ConditionalBase *thecondptr = 0);
129 
130  // Dynamic multi-parm type contructors:
131 
132  // Notes: - the export level cannot be PRM_EXPORT_TBX (they won't fit)
133  // - the vector size is the number of shown instances (Scroll type)
134  // or the number of instances per tab (Switcher type).
135  // - the default is the number of default instances (int)
136  // - the range is the allowable range of instances, min zero.
137  // - the template list is a list of templates to use as a guide
138  // to create new instances (a template, but I didn't want to use
139  // that word again). Names will have a number suffixed to them
140  // depending on the instance number ("foo1") or %d may be used to
141  // specify where the number is put ("foo%dbar"). The template list
142  // otherwise should look exactly the same as a normal list.
143  // - the start offset is where we start counting our instances,
144  // by default from 1.
145  PRM_Template(PRM_MultiType thetype,
146  PRM_Template *thetemplates,
147  PRM_Export theexportlevel,
148  fpreal multisize,
149  PRM_Name *thenameptr,
150  PRM_Default *thedefaultsize = 0,
151  PRM_Range *thedefaultrange = 0,
152  PRM_SpareData *thespareptr = 0,
153  const char *thehelptext = 0,
154  PRM_ConditionalBase *thecondptr = 0,
155  PRM_Callback thecallbackfunc = 0);
156  // no export option.
157  PRM_Template(PRM_MultiType thetype,
158  PRM_Template *thetemplates,
159  fpreal multisize,
160  PRM_Name *thenameptr,
161  PRM_Default *thedefaultsize = 0,
162  PRM_Range *thedefaultrange = 0,
163  PRM_SpareData *thespareptr = 0,
164  const char *thehelptext = 0,
165  PRM_ConditionalBase *thecondptr = 0,
166  PRM_Callback thecallbackfunc = 0);
167 
168  PRM_Template(const PRM_Template &src);
169  ~PRM_Template();
170 
171  int64 getMemoryUsage(bool inclusive) const;
172 
173  const PRM_Template &operator=(const PRM_Template &src);
174 
175  void initialize(PRM_Type thetype,
176  PRM_TypeExtended thetype_ext,
177  PRM_Export theexportlevel,
178  int thevectorsize,
179  PRM_Name *thenameptr,
180  PRM_Default *thedefaults,
181  PRM_ChoiceList *thechoicelistptr,
182  PRM_Range *therangeptr,
183  PRM_Callback thecallbackfunc,
184  PRM_SpareData *thespareptr,
185  int theparmgroup,
186  const char *thehelptext,
187  PRM_ConditionalBase *thecondptr);
188 
189  void initMulti(PRM_MultiType thetype,
190  PRM_Template *thetemplates,
191  PRM_Export theexportlevel,
192  fpreal multisize,
193  PRM_Name *thenameptr,
194  PRM_Default *thedefaultsize,
195  PRM_Range *thedefaultrange,
196  PRM_Callback thecallbackfunc,
197  PRM_SpareData *thespareptr,
198  const char *thehelptext,
199  PRM_ConditionalBase *thecondptr);
200 
201  // This method is effectively an assignment operator which copies everything
202  // from the source except for the vector size and defaults.
203  void assign(const PRM_Template &src, int thevectorsize,
204  PRM_Default *thedefaults);
205 
206  const PRM_Type &getType() const { return myType; }
207  PRM_MultiType getMultiType() const { return myMultiType; }
208  bool isMultiType() const;
209  bool isRampType() const;
210  bool isRampTypeColor() const;
211  PRM_TypeExtended getTypeExtended() const { return myTypeExtended; }
212  int getVectorSize() const { return myVectorSize; }
213  fpreal getMultiSize() const { return myMultiSize; }
214  void setNamePtr(PRM_Name *name) { myNamePtr = name; }
215  PRM_Name *getNamePtr() { return myNamePtr; }
216  const PRM_Name *getNamePtr() const { return myNamePtr; }
217  PRM_SpareData *getSparePtr() { return mySparePtr; }
218  const PRM_SpareData *getSparePtr() const { return mySparePtr; }
219  PRM_SpareData *getOrCreateSparePtr();
221  { mySparePtr = spare; }
222  PRM_Conditional *getConditionalPtr(PRM_ConditionalType type);
223  const PRM_Conditional *getConditionalPtr(PRM_ConditionalType type) const;
225  { return myConditionalPtr; }
227  { return myConditionalPtr; }
229  { myConditionalPtr = conditional; return *this; }
230 
232  { return getConditionalPtr(PRM_CONDTYPE_DISABLE); }
234  { return getConditionalPtr(PRM_CONDTYPE_DISABLE); }
236  {
237  const PRM_ChoiceList *list;
238  if (!myChoiceListPtr &&
239  (myType & PRM_TYPE_ORDINAL) &&
240  (myType & PRM_TYPE_TOGGLE))
241  list = &PRMtoggleMenu;
242  else
243  list = myChoiceListPtr;
244  return list;
245  }
247  {
248  PRM_ChoiceList *list;
249  if (myChoiceListPtr == nullptr
250  && myType.isOrdinalType()
251  && myType.hasOrdinalType(
253  list = &PRMtoggleMenu;
254  else
255  list = myChoiceListPtr;
256  return list;
257  }
259  {
260  myChoiceListPtr = list;
261  }
262  const PRM_Range *getRangePtr() const { return myRangePtr; }
263  PRM_Range *getRangePtr() { return myRangePtr; }
264  PRM_Callback getCallback() const { return myCallbackFunc; }
265  void setCallback(PRM_Callback callback)
266  { myCallbackFunc = callback; }
267  const UT_StringHolder &getHelpText() const { return myHelpText; }
268  unsigned int getAutoScopeField()
269  {
270  if (myAutoScopeField & (1<<(unsigned)myVectorSize))
271  setAutoScopeField();
272  return myAutoScopeField;
273  }
274 
276  { return myMultiParmTemplate; }
278  { return myMultiParmTemplate; }
280  {
281  UT_ASSERT(!tplate || !tplate->isRampType());
282  myMultiParmTemplate = tplate;
283  }
284  int getMultiStartOffset() const;
285 
286  /// matchMultiInstance() tests the given name and returns true if it
287  /// might be an instance parm of the multiparm token (with # characters).
288  /// - If the result is true, then the parsed instance index (relative to
289  /// start_offset) is returned.
290  /// - If the index in the name is less that start_offset, then it will be
291  /// rejected.
292  /// - For nested multiparms, the instance_index array contains an array of
293  /// the parent multiparm instance indices that you want to match against.
294  /// If it is nullptr, then those checks will be skipped.
295  static bool matchMultiInstance(const char *name,
296  const char *multi_name,
297  int start_offset,
298  int &index,
299  const UT_IntArray *instance_index);
300 
302  {
303  return (myDefaults
304  && index >= 0 && index < myVectorSize)
305  ? myDefaults[index].get() : nullptr;
306  }
307  const PRM_Default *getDefault(int index) const
308  {
309  return (myDefaults
310  && index >= 0 && index < myVectorSize)
311  ? myDefaults[index].get() : nullptr;
312  }
314  {
315  return myFactoryDefaults;
316  }
318  {
319  myFactoryDefaults = defaults;
320  }
321  void restoreFactoryDefaults();
322  void setFloatDefault(int index, fpreal v);
323  void setOrdinalDefault(int index, int v);
324  void setStringDefault(int index, const char *v);
325  void setDefault(int index, const PRM_Default &d);
326 
327  // This function sets the PRM_TYPE_NORESIM flag on an existing parameter.
328  // This is an odd operation because it is changing the type of a parameter
329  // when it already exists. But setting this flag doesn't really change
330  // the fundamental type of the parameter. This capability is used in
331  // DOP_Table.C for marking parameters related to guide geometry as not
332  // requiring a refresh.
333  void setNoResim(bool noresim);
334  void setNoCook(bool nocook);
335  /// Set the no-cook flag based on the "cook_dependent" spare data. If the
336  /// force flag is set, the no-cook flag will be set to true if the spare
337  /// data doesn't exist.
338  /// @return The value of the nocook flag
339  bool setNoCook(const PRM_SpareData *spare,
340  bool force=false);
341  void setBaseParm(bool baseparm);
342  void setInvisible(bool invisible);
343  bool getInvisible() const
344  { return (myType & PRM_TYPE_INVISIBLE) != 0; }
345  void setJoinNext(bool joinnext);
346  bool getJoinNext() const
347  { return (myType & PRM_TYPE_JOIN_NEXT) != 0; }
348  void setLabelNone(bool labelnone);
349  bool getLabelNone() const
350  { return (myType & PRM_TYPE_LABEL_NONE) != 0; }
351 
353  { myTypeExtended = type_ext; }
354 
356  { return (PRM_Export)myExportLevel; }
358  { myExportLevel = (unsigned char)level; }
359  int getParmGroup() const { return (int)myParmGroup; }
360 
361  // findSubIndex returns -1 if no parameter is found
362  int findSubIndex(const UT_StringRef &thechannelname) const
363  {
364  if (!myChannelNames)
365  buildChannelNames();
366 
367  for (int i = 0; i < myVectorSize; i++)
368  {
369  if (myChannelNames[i] == thechannelname)
370  return i;
371  }
372  return -1;
373  }
374 
376  {
377  if (!myChannelNames)
378  buildChannelNames();
379  return myChannelNames.get();
380  }
381  void getChannelToken(UT_String &s, int vi) const
382  {
383  if (!myChannelNames)
384  buildChannelNames();
385 
386  if (vi >= 0 && vi < myVectorSize)
387  {
388  s = myChannelNames[vi].buffer();
389  }
390  else
391  {
392  UT_ASSERT(!"ERROR: Out of range");
393  s = "";
394  }
395  }
396 
397  const UT_StringHolder &getChannelToken(int vi) const
398  {
399  if (!myChannelNames)
400  buildChannelNames();
401 
402  if (vi >= 0 && vi < myVectorSize)
403  return myChannelNames[vi];
404 
405  UT_ASSERT(!"ERROR: Out of range");
407  }
408 
410  {
411  if (!myDecodedChannelNames)
412  buildChannelNames(true);
413 
414  if (vi >= 0 && vi < myVectorSize)
415  return myDecodedChannelNames[vi];
416 
417  UT_ASSERT(!"ERROR: Out of range");
419  }
420 
421  bool hasChannelToken(const UT_StringRef &s, int vi) const
422  {
423  if (!myChannelNames)
424  buildChannelNames();
425 
426  UT_ASSERT_P(vi >= 0 && vi < myVectorSize);
427  return myChannelNames[vi] == s;
428  }
429  void getChannelLabel(UT_String &thestrref,
430  int theindex) const;
431  void getToken(UT_String &thestrref) const
432  {
433  thestrref = myNamePtr->getToken();
434  }
435  void getLabel(UT_String &thestrref) const
436  {
437  thestrref = myNamePtr->getLabel();
438  }
439 
440  int getExpressionFlag() const
441  {
442  return myNamePtr->getExpressionFlag();
443  }
444 
445  //
446  // Retrieve as strings instead of UT_Strings.
447  const char *getToken() const
448  {
449  return myNamePtr->getToken();
450  }
451  const UT_StringRef &getTokenRef() const
452  {
453  return myNamePtr->getTokenRef();
454  }
455  const char *getLabel() const
456  {
457  return myNamePtr->getLabel();
458  }
459  unsigned getTokenHash() const
460  {
461  return myNamePtr->getHash();
462  }
463 
464  // A utility function to count the number of templates in a list. When
465  // counting a list for inclusion into a switcher, nested switchers (and all
466  // their templates) only count as a single template. When for_switcher is
467  // true, the count will include switchers (and all their nested templates)
468  // as a single entity. When for_switcher is false, the function will
469  // return the total size of the template. Similarly for toggle joins &
470  // parm joins with 'for_join'.
471  static int countTemplates(
472  const PRM_Template *templates,
473  bool for_switcher = false,
474  bool for_joins = false,
475  bool for_rows = false);
476  // Finds an index of a template that matches a given token. Returns -1 if
477  // not found.
478  static int getTemplateIndexByToken(
479  const PRM_Template *templates,
480  const char * token);
481 
482  // Returns a pointer to the template right after the PRM_SWITCHER
483  // template that is passed in.
484  static const PRM_Template *getEndOfSwitcher(
485  const PRM_Template *templates);
486  // Returns the number of switcher and non-switcher parms contained
487  // within another switcher.
488  static void getSwitcherStats(
489  const PRM_Template *templates,
490  UT_IntArray &numswitchersonpages,
491  UT_IntArray &numnonswitchersonpages);
492 
493  static bool getEnclosingSwitcherFolder(
494  const PRM_Template *tplates,
495  const int index,
496  int &switcher, int &folder);
497 
498  // Returns the highest export level for any template in the list.
499  static PRM_Export getHighestExportLevel(
500  const PRM_Template *tplates);
501 
502  // Return whether our choicelist is the one used automatically when none
503  // is specified by the user.
504  bool isAutomaticallyGeneratedChoiceList() const;
505 
506  // Find the first folder, if any, with the specified label in a switcher
507  // template. Returns -1 if none exists.
508  int findSwitcherFolderWithLabel(
509  const char *label) const;
510 
511  unsigned int getAutoSelectField()
512  {
513  if (myAutoSelectField & (1<<(unsigned)myVectorSize))
514  setAutoSelectField();
515  return myAutoSelectField;
516  }
517 private:
518  void clearOurData();
519  void buildChannelNames(bool decoded=false) const;
520  void setAutoScopeField();
521  void setAutoSelectField();
522 
523  using PRM_DefaultPtr = UT_UniquePtr<PRM_Default>;
524 
525  PRM_Type myType;
526  PRM_MultiType myMultiType;
527  PRM_TypeExtended myTypeExtended;
528  int myVectorSize;
529  PRM_Name *myNamePtr;
531  PRM_Default *myFactoryDefaults;
532  PRM_ChoiceList *myChoiceListPtr;
533  PRM_Range *myRangePtr;
534  PRM_Callback myCallbackFunc;
535  PRM_SpareData *mySparePtr;
536  PRM_ConditionalBase *myConditionalPtr;
537  unsigned char myExportLevel;
538  unsigned char myParmGroup;
539  unsigned char myChoiceListOwnedByMe;
540  unsigned int myAutoScopeField;
541  unsigned int myAutoSelectField;
542  PRM_Template *myMultiParmTemplate;
543  fpreal myMultiSize;
544  UT_StringHolder myHelpText;
545  // Caches
547  myChannelNames;
549  myDecodedChannelNames;
550 };
551 
552 #endif
PRM_Default * getFactoryDefaults() const
Definition: PRM_Template.h:313
const char * getToken() const
Definition: PRM_Template.h:447
GLdouble s
Definition: glew.h:1390
PRM_ChoiceList * getChoiceListPtr()
Definition: PRM_Template.h:246
PRM_Default * getDefault(int index)
Definition: PRM_Template.h:301
PRM_Template * getMultiParmTemplate()
Definition: PRM_Template.h:277
const PRM_Type & getType() const
Definition: PRM_Template.h:206
unsigned getTokenHash() const
Definition: PRM_Template.h:459
GLenum src
Definition: glew.h:2410
#define SYS_DEPRECATED(__V__)
GLuint const GLchar * name
Definition: glew.h:1814
bool hasChannelToken(const UT_StringRef &s, int vi) const
Definition: PRM_Template.h:421
PRM_Callback getCallback() const
Definition: PRM_Template.h:264
const UT_StringRef & getTokenRef() const
Definition: PRM_Template.h:451
GLuint index
Definition: glew.h:1814
PRM_SpareData * getSparePtr()
Definition: PRM_Template.h:217
const PRM_Template * getMultiParmTemplate() const
Definition: PRM_Template.h:275
void setNamePtr(PRM_Name *name)
Definition: PRM_Template.h:214
PRM_Template & setConditionalBasePtr(PRM_ConditionalBase *conditional)
Definition: PRM_Template.h:228
const PRM_Conditional * getDisablePtr() const
Definition: PRM_Template.h:233
const GLdouble * v
Definition: glew.h:1391
unsigned int getAutoSelectField()
Definition: PRM_Template.h:511
void setExportLevel(PRM_Export level)
Definition: PRM_Template.h:357
PRM_API const PRM_Type PRM_TYPE_TOGGLE
void setCallback(PRM_Callback callback)
Definition: PRM_Template.h:265
const UT_StringHolder & getChannelToken(int vi) const
Definition: PRM_Template.h:397
const UT_StringHolder & getDecodedChannelToken(int vi) const
Definition: PRM_Template.h:409
PRM_Range * getRangePtr()
Definition: PRM_Template.h:263
long long int64
Definition: SYS_Types.h:111
const char * buffer() const
Definition: UT_String.h:503
void setSparePtr(PRM_SpareData *spare)
Definition: PRM_Template.h:220
const UT_StringHolder & getHelpText() const
Definition: PRM_Template.h:267
int getExpressionFlag() const
Definition: PRM_Template.h:440
bool getJoinNext() const
Definition: PRM_Template.h:346
void getChannelToken(UT_String &s, int vi) const
Definition: PRM_Template.h:381
const PRM_Range * getRangePtr() const
Definition: PRM_Template.h:262
unsigned int getAutoScopeField()
Definition: PRM_Template.h:268
#define UT_ASSERT_P(ZZ)
Definition: UT_Assert.h:134
static const UT_StringHolder theEmptyString
bool getInvisible() const
Definition: PRM_Template.h:343
const char * getLabel() const
Definition: PRM_Template.h:455
bool getLabelNone() const
Definition: PRM_Template.h:349
OPENVDB_API void initialize()
Global registration of basic types.
Definition: logging.h:318
PRM_API const PRM_Type PRM_TYPE_LABEL_NONE
void getToken(UT_String &thestrref) const
Definition: PRM_Template.h:431
void setFactoryDefaults(PRM_Default *defaults)
Definition: PRM_Template.h:317
GLuint GLuint GLsizei GLenum type
Definition: glew.h:1253
PRM_MultiType getMultiType() const
Definition: PRM_Template.h:207
GLuint GLsizei GLsizei GLchar * label
Definition: glew.h:8986
int getVectorSize() const
Definition: PRM_Template.h:212
PRM_TypeExtended getTypeExtended() const
Definition: PRM_Template.h:211
PRM_Conditional * getDisablePtr()
Definition: PRM_Template.h:231
const PRM_ConditionalBase * getConditionalBasePtr() const
Definition: PRM_Template.h:226
PRM_API const PRM_Type PRM_LIST_TERMINATOR
int findSubIndex(const UT_StringRef &thechannelname) const
Definition: PRM_Template.h:362
double fpreal
Definition: SYS_Types.h:276
const PRM_Name * getNamePtr() const
Definition: PRM_Template.h:216
PRM_ConditionalType
PRM_TypeExtended
Definition: PRM_Type.h:506
fpreal getMultiSize() const
Definition: PRM_Template.h:213
PRM_Export exportLevel() const
Definition: PRM_Template.h:355
PRM_API const PRM_Type PRM_TYPE_JOIN_NEXT
void setChoiceListPtr(PRM_ChoiceList *list)
Definition: PRM_Template.h:258
A smart pointer for unique ownership of dynamically allocated objects.
Definition: UT_UniquePtr.h:47
PRM_API const PRM_Type PRM_TYPE_ORDINAL
void setMultiParmTemplate(PRM_Template *tplate)
Definition: PRM_Template.h:279
const UT_StringHolder * getChannelTokens() const
Definition: PRM_Template.h:375
bool isRampType() const
const PRM_ChoiceList * getChoiceListPtr() const
Definition: PRM_Template.h:235
#define UT_ASSERT(ZZ)
Definition: UT_Assert.h:135
const PRM_SpareData * getSparePtr() const
Definition: PRM_Template.h:218
PRM_API const PRM_Type PRM_TYPE_INVISIBLE
int getParmGroup() const
Definition: PRM_Template.h:359
PRM_ConditionalBase * getConditionalBasePtr()
Definition: PRM_Template.h:224
#define PRM_API
Definition: PRM_API.h:10
void setTypeExtended(PRM_TypeExtended type_ext)
Definition: PRM_Template.h:352
void getLabel(UT_String &thestrref) const
Definition: PRM_Template.h:435
GLint level
Definition: glew.h:1252
PRM_Name * getNamePtr()
Definition: PRM_Template.h:215
PRM_API PRM_ChoiceList PRMtoggleMenu
PRM_MultiType
This type enum defines the different types of multi (dynamic) parameters.
Definition: PRM_Type.h:417
const PRM_Default * getDefault(int index) const
Definition: PRM_Template.h:307