AAX SDK  2.4.1
Avid Audio Extensions Development Kit
AAX_CParameter.h
Go to the documentation of this file.
1 /*================================================================================================*/
2 /*
3  *
4  * Copyright 2013-2017, 2019, 2021 by Avid Technology, Inc.
5  * All rights reserved.
6  *
7  * CONFIDENTIAL: This document contains confidential information. Do not
8  * read or examine this document unless you are an Avid Technology employee
9  * or have signed a non-disclosure agreement with Avid Technology which protects
10  * the confidentiality of this document. DO NOT DISCLOSE ANY INFORMATION
11  * CONTAINED IN THIS DOCUMENT TO ANY THIRD-PARTY WITHOUT THE PRIOR WRITTEN CONSENT
12  * OF Avid Technology, INC.
13  *
14  */
15 
22 /*================================================================================================*/
23 
24 
25 #ifndef AAX_CPARAMETER_H
26 #define AAX_CPARAMETER_H
27 
28 #include "AAX_Assert.h"
29 #include "AAX_IParameter.h"
30 #include "AAX_ITaperDelegate.h"
31 #include "AAX_IDisplayDelegate.h"
33 #include "AAX_CString.h" //concrete class required for name.
34 
35 #include <cstring>
36 #include <list>
37 #include <map>
38 
39 
41 #if 0
42 #pragma mark -
43 #endif
45 
47 
53 template <typename T>
55 {
56 public:
57  enum Defaults {
60  };
61 
62 public:
64 
67 
69 
77  explicit AAX_CParameterValue(AAX_CParamID identifier);
78 
86  explicit AAX_CParameterValue(AAX_CParamID identifier, const T& value);
87 
90  explicit AAX_CParameterValue(const AAX_CParameterValue<T>& other);
91 
92 public: // AAX_CParameterValue<T> implementation
95  const T& Get() const { return mValue; }
98  void Set(const T& inValue) { mValue = inValue; }
99 
100 public: // AAX_IParameterValue implementation
101 
103  AAX_CParamID Identifier() const AAX_OVERRIDE { return mIdentifier; }
104 
109  bool GetValueAsBool(bool* value) const AAX_OVERRIDE;
110  bool GetValueAsInt32(int32_t* value) const AAX_OVERRIDE;
111  bool GetValueAsFloat(float* value) const AAX_OVERRIDE;
112  bool GetValueAsDouble(double* value) const AAX_OVERRIDE;
113  bool GetValueAsString(AAX_IString* value) const AAX_OVERRIDE;
115 
116 private:
117  void InitIdentifier(const char* inIdentifier);
118 
119 private:
120  char mIdentifier[eParemeterDefaultMaxIdentifierSize];
121  T mValue;
122 };
123 
124 
126 
127 template <typename T>
129 : mValue()
130 {
131  InitIdentifier(identifier);
132 }
133 
134 template <typename T>
136 : mValue(value)
137 {
138  InitIdentifier(identifier);
139 }
140 
141 template <typename T>
143 : mValue(other.mValue)
144 {
145  InitIdentifier(other.mIdentifier);
146 }
147 
148 template<typename T>
149 bool AAX_CParameterValue<T>::GetValueAsBool(bool* /*value*/) const
150 {
151  return false;
152 }
153 template <>
155 
156 
157 template<typename T>
158 bool AAX_CParameterValue<T>::GetValueAsInt32(int32_t* /*value*/) const
159 {
160  return false;
161 }
162 template<>
164 
165 template<typename T>
166 bool AAX_CParameterValue<T>::GetValueAsFloat(float* /*value*/) const
167 {
168  return false;
169 }
170 template<>
172 
173 template<typename T>
174 bool AAX_CParameterValue<T>::GetValueAsDouble(double* /*value*/) const
175 {
176  return false;
177 }
178 template<>
180 
181 template<typename T>
183 {
184  return false;
185 }
186 template<>
188 
189 template<typename T>
190 void AAX_CParameterValue<T>::InitIdentifier(const char *inIdentifier)
191 {
192 
193  const size_t len = strlen(inIdentifier);
194  AAX_ASSERT(len < eParemeterDefaultMaxIdentifierSize);
195  if (len < eParemeterDefaultMaxIdentifierSize)
196  {
197  std::strncpy(mIdentifier, inIdentifier, 1+len);
198  mIdentifier[len] = 0;
199  }
200  else
201  {
202  std::strncpy(mIdentifier, inIdentifier, eParameterDefaultMaxIdentifierLength);
203  mIdentifier[eParameterDefaultMaxIdentifierLength] = 0;
204  }
205 }
206 
207 
209 #if 0
210 #pragma mark -
211 #endif
213 
215 
236 template <typename T>
238 {
239 public:
240 
241  enum Type {
247  };
248 
249  enum Defaults {
252  };
253 
284  AAX_CParameter(AAX_CParamID identifier, const AAX_IString& name, T defaultValue, const AAX_ITaperDelegate<T>& taperDelegate, const AAX_IDisplayDelegate<T>& displayDelegate, bool automatable=false);
285 
292  AAX_CParameter(const AAX_IString& identifier, const AAX_IString& name, T defaultValue, const AAX_ITaperDelegate<T>& taperDelegate, const AAX_IDisplayDelegate<T>& displayDelegate, bool automatable=false);
293 
303  AAX_CParameter(const AAX_IString& identifier, const AAX_IString& name, T defaultValue, bool automatable=false);
304 
315  AAX_CParameter(const AAX_IString& identifier, const AAX_IString& name, bool automatable=false);
316 
320 
324  AAX_DELETE(AAX_CParameter& operator= (const AAX_CParameter& other));
325 
331 
333 
339  void SetName(const AAX_CString& name) AAX_OVERRIDE;
340  const AAX_CString& Name() const AAX_OVERRIDE;
341  void AddShortenedName(const AAX_CString& name) AAX_OVERRIDE;
342  const AAX_CString& ShortenedName(int32_t iNumCharacters) const AAX_OVERRIDE;
345 
350  void SetNormalizedDefaultValue(double normalizedDefault) AAX_OVERRIDE;
351  double GetNormalizedDefaultValue() const AAX_OVERRIDE;
353  void SetNormalizedValue(double newNormalizedValue) AAX_OVERRIDE;
354  double GetNormalizedValue() const AAX_OVERRIDE;
355  void SetNumberOfSteps(uint32_t numSteps) AAX_OVERRIDE;
356  uint32_t GetNumberOfSteps() const AAX_OVERRIDE;
357  uint32_t GetStepValue() const AAX_OVERRIDE;
358  double GetNormalizedValueFromStep(uint32_t iStep) const AAX_OVERRIDE;
359  uint32_t GetStepValueFromNormalizedValue(double normalizedValue) const AAX_OVERRIDE;
360  void SetStepValue(uint32_t iStep) AAX_OVERRIDE;
361  void SetType(AAX_EParameterType iControlType) AAX_OVERRIDE;
365  void SetTaperDelegate(AAX_ITaperDelegateBase& inTaperDelegate,bool inPreserveValue=true) AAX_OVERRIDE;
367 
372  void SetDisplayDelegate(AAX_IDisplayDelegateBase& inDisplayDelegate) AAX_OVERRIDE;
373  bool GetValueString( AAX_CString* valueString) const AAX_OVERRIDE;
374  bool GetValueString(int32_t iMaxNumChars, AAX_CString* valueString) const AAX_OVERRIDE;
375  bool GetNormalizedValueFromBool(bool value, double *normalizedValue) const AAX_OVERRIDE;
376  bool GetNormalizedValueFromInt32(int32_t value, double *normalizedValue) const AAX_OVERRIDE;
377  bool GetNormalizedValueFromFloat(float value, double *normalizedValue) const AAX_OVERRIDE;
378  bool GetNormalizedValueFromDouble(double value, double *normalizedValue) const AAX_OVERRIDE;
379  bool GetNormalizedValueFromString(const AAX_CString& valueString, double *normalizedValue) const AAX_OVERRIDE;
380  bool GetBoolFromNormalizedValue(double normalizedValue, bool* value) const AAX_OVERRIDE;
381  bool GetInt32FromNormalizedValue(double normalizedValue, int32_t* value) const AAX_OVERRIDE;
382  bool GetFloatFromNormalizedValue(double normalizedValue, float* value) const AAX_OVERRIDE;
383  bool GetDoubleFromNormalizedValue(double normalizedValue, double* value) const AAX_OVERRIDE;
384  bool GetStringFromNormalizedValue(double normalizedValue, AAX_CString& valueString) const AAX_OVERRIDE;
385  bool GetStringFromNormalizedValue(double normalizedValue, int32_t iMaxNumChars, AAX_CString& valueString) const AAX_OVERRIDE;
386  bool SetValueFromString(const AAX_CString& newValueString) AAX_OVERRIDE;
388 
393  void SetAutomationDelegate ( AAX_IAutomationDelegate * iAutomationDelegate ) AAX_OVERRIDE;
394  bool Automatable() const AAX_OVERRIDE;
395  void Touch() AAX_OVERRIDE;
396  void Release() AAX_OVERRIDE;
398 
403  bool GetValueAsBool(bool* value) const AAX_OVERRIDE;
404  bool GetValueAsInt32(int32_t* value) const AAX_OVERRIDE;
405  bool GetValueAsFloat(float* value) const AAX_OVERRIDE;
406  bool GetValueAsDouble(double* value) const AAX_OVERRIDE;
407  bool GetValueAsString(AAX_IString* value) const AAX_OVERRIDE;
408  bool SetValueWithBool(bool value) AAX_OVERRIDE;
409  bool SetValueWithInt32(int32_t value) AAX_OVERRIDE;
410  bool SetValueWithFloat(float value) AAX_OVERRIDE;
411  bool SetValueWithDouble(double value) AAX_OVERRIDE;
412  bool SetValueWithString(const AAX_IString& value) AAX_OVERRIDE;
414 
419  void UpdateNormalizedValue(double newNormalizedValue) AAX_OVERRIDE;
421 
439  void SetValue(T newValue );
446  T GetValue() const;
455  void SetDefaultValue(T newDefaultValue);
462  T GetDefaultValue() const;
467  const AAX_ITaperDelegate<T>* TaperDelegate() const;
472  const AAX_IDisplayDelegate<T>* DisplayDelegate() const;
474 
475 protected:
478  uint32_t mNumSteps;
485 
488 
489 private:
490  void InitializeNumberOfSteps();
491 };
492 
493 
495 
496 template <typename T>
497 AAX_CParameter<T>::AAX_CParameter(AAX_CParamID identifier, const AAX_IString& name, T defaultValue, const AAX_ITaperDelegate<T>& taperDelegate, const AAX_IDisplayDelegate<T>& displayDelegate, bool automatable)
498 : mNames(name)
499 , mAutomatable(automatable)
500 , mNumSteps(0) // Default set below for discrete/continuous
503 , mTaperDelegate(taperDelegate.Clone())
504 , mDisplayDelegate(displayDelegate.Clone())
506 , mNeedNotify(true)
507 , mValue(identifier)
508 , mDefaultValue(defaultValue)
509 {
510  this->InitializeNumberOfSteps();
511  this->SetToDefaultValue();
512 }
513 
514 template <typename T>
515 AAX_CParameter<T>::AAX_CParameter(const AAX_IString& identifier, const AAX_IString& name, T defaultValue, const AAX_ITaperDelegate<T>& taperDelegate, const AAX_IDisplayDelegate<T>& displayDelegate, bool automatable)
516 : mNames(name)
517 , mAutomatable(automatable)
518 , mNumSteps(0) // Default set below for discrete/continuous
521 , mTaperDelegate(taperDelegate.Clone())
522 , mDisplayDelegate(displayDelegate.Clone())
524 , mNeedNotify(true)
525 , mValue(identifier.Get())
526 , mDefaultValue(defaultValue)
527 {
528  this->InitializeNumberOfSteps();
529  this->SetToDefaultValue();
530 }
531 
532 template <typename T>
533 AAX_CParameter<T>::AAX_CParameter(const AAX_IString& identifier, const AAX_IString& name, T defaultValue, bool automatable)
534 : mNames(name)
535 , mAutomatable(automatable)
536 , mNumSteps(0)
537 , mControlType( AAX_eParameterType_Continuous )
538 , mOrientation( AAX_eParameterOrientation_Default )
539 , mTaperDelegate(NULL)
540 , mDisplayDelegate(NULL)
541 , mAutomationDelegate(NULL)
542 , mNeedNotify(true)
543 , mValue(identifier)
544 , mDefaultValue(defaultValue)
545 {
546  this->InitializeNumberOfSteps();
547  this->SetToDefaultValue();
548 }
549 
550 template <typename T>
551 AAX_CParameter<T>::AAX_CParameter(const AAX_IString& identifier, const AAX_IString& name, bool automatable)
552 : mNames(name)
553 , mAutomatable(automatable)
554 , mNumSteps(0)
555 , mControlType( AAX_eParameterType_Continuous )
556 , mOrientation( AAX_eParameterOrientation_Default )
557 , mTaperDelegate(NULL)
558 , mDisplayDelegate(NULL)
559 , mAutomationDelegate(NULL)
560 , mNeedNotify(true)
561 , mValue(identifier)
562 , mDefaultValue()
563 {
564  this->InitializeNumberOfSteps();
565  this->SetToDefaultValue(); // WARNING: uninitialized default value
566 }
567 
568 template <typename T>
570 {
571  //Make sure to remove any registration with the token system.
572  SetAutomationDelegate(0);
573 
574  delete mTaperDelegate;
575  mTaperDelegate = 0;
576  delete mDisplayDelegate;
577  mDisplayDelegate = 0;
578 }
579 
580 template <typename T>
582 {
583  return new AAX_CParameterValue<T>(mValue);
584 }
585 
586 template <typename T>
588 {
589  return mValue.Identifier();
590 }
591 
592 template <typename T>
594 {
595  mNames.SetPrimary(name);
596 }
597 
598 template <typename T>
600 {
601  return mNames.Primary();
602 }
603 
604 template <typename T>
606 {
607  mNames.Add(name);
608 }
609 
610 template <typename T>
611 const AAX_CString& AAX_CParameter<T>::ShortenedName(int32_t iNumCharacters) const
612 {
613  return mNames.Get(iNumCharacters);
614 }
615 
616 template <typename T>
618 {
619  mNames.Clear();
620 }
621 
622 
623 
624 template<typename T>
625 void AAX_CParameter<T>::SetValue( T newValue )
626 {
627  double newNormalizedValue = mTaperDelegate->RealToNormalized(newValue);
628 
629  // <DMT> Always go through the automation delegate even if the control isn't automatable to prevent fighting with other GUIs.
630  // Somewhere back in the automation delegate, or elsewhere in the system, it will determine the differences in behavior surrounding
631  // automation. The only reason that there wouldn't be an automation delegate is if this parameter has yet to be added to a
632  // ParameterManager. Let's put the null value guards in place, just in case, and also for unit tests.
633  if ( mAutomationDelegate )
634  {
635  //TODO: Create RAII utility class for touch/release
636 
637  //Touch the control
638  Touch();
639 
640  //Send that token.
641  mAutomationDelegate->PostSetValueRequest(Identifier(), newNormalizedValue );
642 
643  //Release the control
644  Release();
645  }
646  else
647  {
648  mNeedNotify = true;
649 
650  // In the rare case that an automation delegate doesn't exist, lets still set the value. It's possible that someone is trying to
651  // set the new value before adding the parameter to a parametermanager.
652  UpdateNormalizedValue(newNormalizedValue);
653  }
654 }
655 
656 template <typename T>
657 void AAX_CParameter<T>::UpdateNormalizedValue(double newNormalizedValue)
658 {
659  T newValue = mTaperDelegate->NormalizedToReal(newNormalizedValue);
660  if (mNeedNotify || (mValue.Get() != newValue))
661  {
662  //Set the new value
663  mValue.Set(newValue);
664 
665  //<DMT> Always notify that the value has changed through the automation delegate to guarantee that all control surfaces and other
666  // GUIs get their values updated.
667  if (mAutomationDelegate)
668  mAutomationDelegate->PostCurrentValue(Identifier(), newNormalizedValue);
669 
670  // clear flag
671  mNeedNotify = false;
672  }
673 }
674 
675 template <typename T>
677 {
678  if (mNumSteps == 0) // If no explicit number of steps has been set...
679  {
680  switch (mControlType)
681  {
683  {
684  // Discrete parameters default to binary unless
685  // otherwise specified
686  this->SetNumberOfSteps (eParameterDefaultNumStepsDiscrete);
687  break;
688  }
690  {
691  // Defaulting to 128 steps to match one full rotation of
692  // Command|8 and similar surfaces, which query the num
693  // steps to determine tick values for rotary encoders
694  this->SetNumberOfSteps (eParameterDefaultNumStepsContinuous);
695  break;
696  }
697  default:
698  {
699  AAX_ASSERT (0); // Invalid type
700  break;
701  }
702  }
703  }
704 }
705 
706 template<typename T>
708 {
709  return mValue.Get();
710 }
711 
712 
713 template<typename T>
714 bool AAX_CParameter<T>::GetValueAsBool(bool* value) const
715 {
716  return mValue.GetValueAsBool(value);
717 }
718 
719 template<typename T>
720 bool AAX_CParameter<T>::GetValueAsInt32(int32_t* value) const
721 {
722  return mValue.GetValueAsInt32(value);
723 }
724 
725 template<typename T>
726 bool AAX_CParameter<T>::GetValueAsFloat(float* value) const
727 {
728  return mValue.GetValueAsFloat(value);
729 }
730 
731 template<typename T>
732 bool AAX_CParameter<T>::GetValueAsDouble(double* value) const
733 {
734  return mValue.GetValueAsDouble(value);
735 }
736 
737 template<typename T>
739 {
740  bool result = false;
741  if (value)
742  {
743  AAX_CString valueString;
744  result = this->GetValueString(&valueString);
745  if (true == result)
746  {
747  *value = valueString;
748  }
749  }
750  return result;
751 }
752 
753 template<>
755 
756 
757 template<typename T>
759 {
760  return false;
761 }
762 template<>
764 
765 template<typename T>
767 {
768  return false;
769 }
770 template<>
772 
773 template<typename T>
775 {
776  return false;
777 }
778 template<>
780 
781 template<typename T>
783 {
784  return false;
785 }
786 template<>
788 
789 template<typename T>
791 {
792  const AAX_CString valueString(value);
793  return this->SetValueFromString(valueString);
794 }
795 template<>
797 
798 template<typename T>
799 void AAX_CParameter<T>::SetNormalizedDefaultValue(double newNormalizedDefault)
800 {
801  T newDefaultValue = mTaperDelegate->NormalizedToReal(newNormalizedDefault);
802  SetDefaultValue(newDefaultValue);
803 }
804 
805 template<typename T>
807 {
808  double normalizedDefault = mTaperDelegate->RealToNormalized(mDefaultValue);
809  return normalizedDefault;
810 }
811 
812 template<typename T>
813 void AAX_CParameter<T>::SetDefaultValue(T newDefaultValue)
814 {
815  newDefaultValue = mTaperDelegate->ConstrainRealValue(newDefaultValue);
816  mDefaultValue = newDefaultValue;
817 }
818 
819 template<typename T>
821 {
822  return mDefaultValue;
823 }
824 
825 template<typename T>
827 {
828  SetValue(mDefaultValue);
829 }
830 
831 template<typename T>
832 void AAX_CParameter<T>::SetNumberOfSteps(uint32_t numSteps)
833 {
834  AAX_ASSERT(0 < numSteps);
835  if (0 < numSteps)
836  {
837  mNumSteps = numSteps;
838  }
839 }
840 
841 template<typename T>
843 {
844  return mNumSteps;
845 }
846 
847 template<typename T>
849 {
850  return GetStepValueFromNormalizedValue(this->GetNormalizedValue());
851 }
852 
853 template<typename T>
855 {
856  double numSteps = (double) this->GetNumberOfSteps ();
857  if ( numSteps < 2.0 )
858  return 0.0;
859 
860  double valuePerStep = 1.0 / ( numSteps - 1.0 );
861  double value = valuePerStep * (double) iStep;
862  if ( value < 0.0 )
863  value = 0.0;
864  else if ( value > 1.0 )
865  value = 1.0;
866 
867  return value;
868 }
869 
870 template<typename T>
871 uint32_t AAX_CParameter<T>::GetStepValueFromNormalizedValue(double normalizedValue) const
872 {
873  double numSteps = (double) this->GetNumberOfSteps ();
874  if ( numSteps < 2.0 )
875  return 0;
876 
877  double valuePerStep = 1.0 / ( numSteps - 1.0 );
878  double curStep = ( normalizedValue / valuePerStep ) + 0.5;
879  if ( curStep < 0.0 )
880  curStep = 0.0;
881  else if ( curStep > (double) ( numSteps - 1.0 ) )
882  curStep = (double) ( numSteps - 1.0 );
883 
884  return (uint32_t) curStep;
885 }
886 
887 template<typename T>
889 {
890  double numSteps = (double) this->GetNumberOfSteps ();
891  if ( numSteps < 2.0 )
892  return;
893 
894  this->SetNormalizedValue ( GetNormalizedValueFromStep(iStep) );
895 }
896 
897 template<typename T>
899 {
900  mControlType = iControlType;
901 }
902 
903 template<typename T>
905 {
906  return mControlType;
907 }
908 
909 template<typename T>
911 {
912  mOrientation = iOrientation;
913 }
914 
915 template<typename T>
917 {
918  return mOrientation;
919 }
920 
921 template<typename T>
922 void AAX_CParameter<T>::SetNormalizedValue(double normalizedNewValue)
923 {
924  T newValue = mTaperDelegate->NormalizedToReal(normalizedNewValue);
925  this->SetValue(newValue);
926 }
927 
928 template<typename T>
930 {
931  T val = GetValue();
932  return mTaperDelegate->RealToNormalized(val);
933 }
934 
935 
936 template<typename T>
938 {
939  return mDisplayDelegate->ValueToString(this->GetValue(), valueString);
940 }
941 
942 template<typename T>
943 bool AAX_CParameter<T>::GetValueString(int32_t /*iMaxNumChars*/, AAX_CString* valueString) const
944 {
945  return mDisplayDelegate->ValueToString(this->GetValue(), valueString);
946 }
947 
948 template <typename T>
949 bool AAX_CParameter<T>::GetNormalizedValueFromBool(bool /*value*/, double * /*normalizedValue*/) const
950 {
951  return false;
952 }
953 template <>
954 bool AAX_CParameter<bool>::GetNormalizedValueFromBool(bool value, double *normalizedValue) const;
955 
956 template <typename T>
957 bool AAX_CParameter<T>::GetNormalizedValueFromInt32(int32_t /*value*/, double * /*normalizedValue*/) const
958 {
959  return false;
960 }
961 template <>
962 bool AAX_CParameter<int32_t>::GetNormalizedValueFromInt32(int32_t value, double *normalizedValue) const;
963 
964 template <typename T>
965 bool AAX_CParameter<T>::GetNormalizedValueFromFloat(float /*value*/, double * /*normalizedValue*/) const
966 {
967  return false;
968 }
969 template <>
970 bool AAX_CParameter<float>::GetNormalizedValueFromFloat(float value, double *normalizedValue) const;
971 
972 template <typename T>
973 bool AAX_CParameter<T>::GetNormalizedValueFromDouble(double /*value*/, double * /*normalizedValue*/) const
974 {
975  return false;
976 }
977 template <>
978 bool AAX_CParameter<double>::GetNormalizedValueFromDouble(double value, double *normalizedValue) const;
979 
980 template <typename T>
981 bool AAX_CParameter<T>::GetNormalizedValueFromString(const AAX_CString& valueString, double *normalizedValue) const
982 {
983  //First, convert the string to a value using the wrapped parameter's display delegate.
984  T value;
985  if (!mDisplayDelegate->StringToValue(valueString, &value))
986  return false;
987 
988  //Then use the wrapped parameter's taper delegate to convert to a normalized representation.
989  //If the parameter is out of range, the normalizedValue will be clamped just to be safe.
990  *normalizedValue = mTaperDelegate->RealToNormalized(value);
991  return true;
992 }
993 
994 template<typename T>
995 bool AAX_CParameter<T>::GetBoolFromNormalizedValue(double /*inNormalizedValue*/, bool* /*value*/) const
996 {
997  return false;
998 }
999 template <>
1000 bool AAX_CParameter<bool>::GetBoolFromNormalizedValue(double inNormalizedValue, bool* value) const;
1001 
1002 
1003 template<typename T>
1004 bool AAX_CParameter<T>::GetInt32FromNormalizedValue(double /*inNormalizedValue*/, int32_t* /*value*/) const
1005 {
1006  return false;
1007 }
1008 template<>
1009 bool AAX_CParameter<int32_t>::GetInt32FromNormalizedValue(double inNormalizedValue, int32_t* value) const;
1010 
1011 template<typename T>
1012 bool AAX_CParameter<T>::GetFloatFromNormalizedValue(double /*inNormalizedValue*/, float* /*value*/) const
1013 {
1014  return false;
1015 }
1016 template<>
1017 bool AAX_CParameter<float>::GetFloatFromNormalizedValue(double inNormalizedValue, float* value) const;
1018 
1019 template<typename T>
1020 bool AAX_CParameter<T>::GetDoubleFromNormalizedValue(double /*inNormalizedValue*/, double* /*value*/) const
1021 {
1022  return false;
1023 }
1024 template<>
1025 bool AAX_CParameter<double>::GetDoubleFromNormalizedValue(double inNormalizedValue, double* value) const;
1026 
1027 template <typename T>
1028 bool AAX_CParameter<T>::GetStringFromNormalizedValue(double normalizedValue, AAX_CString& valueString) const
1029 {
1030  T value = mTaperDelegate->NormalizedToReal(normalizedValue);
1031  if (!mDisplayDelegate->ValueToString(value, &valueString))
1032  return false;
1033 
1034  //If the parameter is out of range, we should probably return false, even though we clamped the normalizedValue already just to be safe.
1035  if ((value > mTaperDelegate->GetMaximumValue()) || (value < mTaperDelegate->GetMinimumValue()))
1036  return false;
1037  return true;
1038 }
1039 
1040 template <typename T>
1041 bool AAX_CParameter<T>::GetStringFromNormalizedValue(double normalizedValue, int32_t iMaxNumChars, AAX_CString& valueString) const
1042 {
1043  T value = mTaperDelegate->NormalizedToReal(normalizedValue);
1044  if (!mDisplayDelegate->ValueToString(value, iMaxNumChars, &valueString))
1045  return false;
1046 
1047  //If the parameter is out of range, we should probably return false, even though we clamped the normalizedValue already just to be safe.
1048  if ((value > mTaperDelegate->GetMaximumValue()) || (value < mTaperDelegate->GetMinimumValue()))
1049  return false;
1050  return true;
1051 }
1052 
1053 template<typename T>
1055 {
1056  T newValue;
1057  if (!mDisplayDelegate->StringToValue(newValueString, &newValue))
1058  return false;
1059  SetValue(newValue);
1060  return true;
1061 }
1062 
1063 template<typename T>
1064 void AAX_CParameter<T>::SetTaperDelegate(AAX_ITaperDelegateBase& inTaperDelegate,bool inPreserveValue)
1065 {
1066  double normalizeValue = this->GetNormalizedValue ();
1067 
1068  AAX_ITaperDelegate<T>* oldDelegate = mTaperDelegate;
1069  mTaperDelegate = ((AAX_ITaperDelegate<T> &) inTaperDelegate).Clone();
1070  delete oldDelegate;
1071 
1072  mNeedNotify = true;
1073  if ( inPreserveValue )
1074  this->SetValue ( mValue.Get() );
1075  else this->UpdateNormalizedValue ( normalizeValue );
1076 }
1077 
1078 template<typename T>
1080 {
1081  AAX_IDisplayDelegate<T>* oldDelegate = mDisplayDelegate;
1082  mDisplayDelegate = ((AAX_IDisplayDelegate<T> &)inDisplayDelegate).Clone();
1083  delete oldDelegate;
1084 
1085  if (mAutomationDelegate != 0)
1086  mAutomationDelegate->PostCurrentValue(this->Identifier(), this->GetNormalizedValue()); //<DMT> Make sure GUIs are all notified of the change.
1087 }
1088 
1089 template<typename T>
1091 {
1092  return mTaperDelegate;
1093 }
1094 
1095 template<typename T>
1097 {
1098  return mDisplayDelegate;
1099 }
1100 
1101 template<typename T>
1103 {
1104  return mAutomatable;
1105 }
1106 
1107 template<typename T>
1109 {
1110  //Remove the old automation delegate
1111  if ( mAutomationDelegate )
1112  {
1113  mAutomationDelegate->UnregisterParameter ( this->Identifier() );
1114  }
1115 
1116  //Add the new automation delegate, wrapped by the versioning layer.
1117  mAutomationDelegate = iAutomationDelegate;
1118  if ( mAutomationDelegate )
1119  mAutomationDelegate->RegisterParameter ( this->Identifier() );
1120 }
1121 
1122 template<typename T>
1124 {
1125  //<DT> Always send the touch command, even if the control isn't automatable.
1126  if (mAutomationDelegate)
1127  mAutomationDelegate->PostTouchRequest( this->Identifier() );
1128 }
1129 
1130 template<typename T>
1132 {
1133  //<DT> Always send the release command, even if the control isn't automatable.
1134  if (mAutomationDelegate)
1135  mAutomationDelegate->PostReleaseRequest( this->Identifier() );
1136 }
1137 
1138 
1140 #if 0
1141 #pragma mark -
1142 #pragma mark AAX_CStatelessParameter
1143 #endif
1145 
1153 {
1154 public:
1155  AAX_CStatelessParameter(AAX_CParamID identifier, const AAX_IString& name, const AAX_IString& inValueString)
1156  : mNames(name)
1157  , mID(identifier)
1158  , mAutomationDelegate(NULL)
1159  , mValueString(inValueString)
1160  {
1161  }
1162 
1163  AAX_CStatelessParameter(const AAX_IString& identifier, const AAX_IString& name, const AAX_IString& inValueString)
1164  : mNames(name)
1165  , mID(identifier)
1166  , mAutomationDelegate(NULL)
1167  , mValueString(inValueString)
1168  {
1169  }
1170 
1172 
1173  AAX_IParameterValue* CloneValue() const AAX_OVERRIDE { return NULL; }
1174 
1180  void SetName(const AAX_CString& name) AAX_OVERRIDE { mNames.SetPrimary(name); }
1181  const AAX_CString& Name() const AAX_OVERRIDE { return mNames.Primary(); }
1182  void AddShortenedName(const AAX_CString& name) AAX_OVERRIDE { mNames.Add(name); }
1183  const AAX_CString& ShortenedName(int32_t iNumCharacters) const AAX_OVERRIDE { return mNames.Get(iNumCharacters); }
1186 
1191  bool Automatable() const AAX_OVERRIDE { return false; }
1193  {
1194  //Remove the old automation delegate
1195  if ( mAutomationDelegate )
1196  {
1198  }
1199 
1200  //Add the new automation delegate, wrapped by the versioning layer.
1201  mAutomationDelegate = iAutomationDelegate;
1202  if ( mAutomationDelegate )
1204  }
1208 
1213  void SetNormalizedValue(double /*newNormalizedValue*/) AAX_OVERRIDE {}
1214  double GetNormalizedValue() const AAX_OVERRIDE { return 0.; }
1215  void SetNormalizedDefaultValue(double /*normalizedDefault*/) AAX_OVERRIDE {}
1216  double GetNormalizedDefaultValue() const AAX_OVERRIDE { return 0.; }
1218  void SetNumberOfSteps(uint32_t /*numSteps*/) AAX_OVERRIDE {}
1219  uint32_t GetNumberOfSteps() const AAX_OVERRIDE { return 1; }
1220  uint32_t GetStepValue() const AAX_OVERRIDE { return 0; }
1221  double GetNormalizedValueFromStep(uint32_t /*iStep*/) const AAX_OVERRIDE { return 0.; }
1222  uint32_t GetStepValueFromNormalizedValue(double /*normalizedValue*/) const AAX_OVERRIDE { return 0; }
1223  void SetStepValue(uint32_t /*iStep*/) AAX_OVERRIDE {}
1225 
1232  bool GetValueString(AAX_CString* valueString) const AAX_OVERRIDE { if (valueString) *valueString = mValueString; return true; }
1233  bool GetValueString(int32_t /*iMaxNumChars*/, AAX_CString* valueString) const AAX_OVERRIDE { return this->GetValueString(valueString); }
1234  bool GetNormalizedValueFromBool(bool /*value*/, double* normalizedValue) const AAX_OVERRIDE { if (normalizedValue) { *normalizedValue = 0.; } return true; }
1235  bool GetNormalizedValueFromInt32(int32_t /*value*/, double* normalizedValue) const AAX_OVERRIDE { if (normalizedValue) { *normalizedValue = 0.; } return true; }
1236  bool GetNormalizedValueFromFloat(float /*value*/, double* normalizedValue) const AAX_OVERRIDE { if (normalizedValue) { *normalizedValue = 0.; } return true; }
1237  bool GetNormalizedValueFromDouble(double /*value*/, double* normalizedValue) const AAX_OVERRIDE { if (normalizedValue) { *normalizedValue = 0.; } return true; }
1238  bool GetNormalizedValueFromString(const AAX_CString& /*valueString*/, double* normalizedValue) const AAX_OVERRIDE { if (normalizedValue) { *normalizedValue = 0.; } return true; }
1239  bool GetBoolFromNormalizedValue(double /*normalizedValue*/, bool* value) const AAX_OVERRIDE { if (value) { *value = false; } return true; }
1240  bool GetInt32FromNormalizedValue(double /*normalizedValue*/, int32_t* /*value*/) const AAX_OVERRIDE { return false; }
1241  bool GetFloatFromNormalizedValue(double /*normalizedValue*/, float* /*value*/) const AAX_OVERRIDE { return false; }
1242  bool GetDoubleFromNormalizedValue(double /*normalizedValue*/, double* /*value*/) const AAX_OVERRIDE { return false; }
1243  bool GetStringFromNormalizedValue(double /*normalizedValue*/, AAX_CString& valueString) const AAX_OVERRIDE { valueString = mValueString; return true; }
1244  bool GetStringFromNormalizedValue(double normalizedValue, int32_t /*iMaxNumChars*/, AAX_CString& valueString) const AAX_OVERRIDE { return this->GetStringFromNormalizedValue(normalizedValue, valueString); }
1245  bool SetValueFromString(const AAX_CString& newValueString) AAX_OVERRIDE { mValueString = newValueString; return true; }
1247 
1252  bool GetValueAsBool(bool* value) const AAX_OVERRIDE { if (value) { *value = false; } return true; }
1253  bool GetValueAsInt32(int32_t* /*value*/) const AAX_OVERRIDE { return false; }
1254  bool GetValueAsFloat(float* /*value*/) const AAX_OVERRIDE { return false; }
1255  bool GetValueAsDouble(double* /*value*/) const AAX_OVERRIDE { return false; }
1256  bool GetValueAsString(AAX_IString* /*value*/) const AAX_OVERRIDE { return false; }
1257  bool SetValueWithBool(bool /*value*/) AAX_OVERRIDE { return true; }
1258  bool SetValueWithInt32(int32_t /*value*/) AAX_OVERRIDE { return false; }
1259  bool SetValueWithFloat(float /*value*/) AAX_OVERRIDE { return false; }
1260  bool SetValueWithDouble(double /*value*/) AAX_OVERRIDE { return false; }
1261  bool SetValueWithString(const AAX_IString& value) AAX_OVERRIDE { mValueString = value; return true; }
1263 
1264  void SetType( AAX_EParameterType /*iControlType*/ ) AAX_OVERRIDE {};
1266 
1269 
1270  void SetTaperDelegate ( AAX_ITaperDelegateBase & /*inTaperDelegate*/, bool /*inPreserveValue*/ ) AAX_OVERRIDE {};
1271  void SetDisplayDelegate ( AAX_IDisplayDelegateBase & /*inDisplayDelegate*/ ) AAX_OVERRIDE {};
1272 
1277  void UpdateNormalizedValue(double /*newNormalizedValue*/) AAX_OVERRIDE {};
1279 
1280 protected:
1285 };
1286 
1287 
1288 
1289 
1290 #endif //AAX_CParameter_H
const char * AAX_CParamID
Parameter identifier.
Definition: AAX.h:352
#define AAX_OVERRIDE
override keyword macro
Definition: AAX.h:141
Declarations for cross-platform AAX_ASSERT, AAX_TRACE and related facilities.
#define AAX_ASSERT(condition)
Asserts that a condition is true and logs an error if the condition is false.
Definition: AAX_Assert.h:268
A generic AAX string class with similar functionality to std::string.
AAX_EParameterType
FIC stuff that I can't include without DAE library dependence.
Definition: AAX_Enums.h:833
@ AAX_eParameterType_Discrete
Definition: AAX_Enums.h:834
@ AAX_eParameterType_Continuous
Definition: AAX_Enums.h:835
int32_t AAX_EParameterOrientation
Typedef for a bitfield of AAX_EParameterOrientationBits values.
Definition: AAX_Enums.h:866
@ AAX_eParameterOrientation_Default
Definition: AAX_Enums.h:845
Interface allowing an AAX plug-in to interact with the host's automation system.
Defines the display behavior for a parameter.
The base interface for all normalizable plug-in parameters.
Defines the taper conversion behavior for a parameter.
Concrete implementation of AAX_IParameterValue.
Definition: AAX_CParameter.h:55
AAX_DEFAULT_MOVE_OPER(AAX_CParameterValue)
bool GetValueAsInt32(int32_t *value) const AAX_OVERRIDE
Retrieves the parameter's value as an int32_t.
Definition: AAX_CParameter.h:158
bool GetValueAsDouble(double *value) const AAX_OVERRIDE
Retrieves the parameter's value as a double.
Definition: AAX_CParameter.h:174
bool GetValueAsString(AAX_IString *value) const AAX_OVERRIDE
Retrieves the parameter's value as a string.
Definition: AAX_CParameter.h:182
Defaults
Definition: AAX_CParameter.h:57
@ eParameterDefaultMaxIdentifierLength
Definition: AAX_CParameter.h:59
@ eParemeterDefaultMaxIdentifierSize
Definition: AAX_CParameter.h:58
AAX_IParameterValue * Clone() const AAX_OVERRIDE
Clones the parameter object.
Definition: AAX_CParameter.h:102
void Set(const T &inValue)
Direct access to the template instance's value.
Definition: AAX_CParameter.h:98
bool GetValueAsBool(bool *value) const AAX_OVERRIDE
Retrieves the parameter's value as a bool.
Definition: AAX_CParameter.h:149
AAX_DEFAULT_DTOR_OVERRIDE(AAX_CParameterValue)
const T & Get() const
Direct access to the template instance's value.
Definition: AAX_CParameter.h:95
bool GetValueAsFloat(float *value) const AAX_OVERRIDE
Retrieves the parameter's value as a float.
Definition: AAX_CParameter.h:166
AAX_CParameterValue(AAX_CParamID identifier)
Constructs an AAX_CParameterValue object.
Definition: AAX_CParameter.h:128
AAX_DELETE(AAX_CParameterValue &operator=(const AAX_CParameterValue &))
AAX_CParamID Identifier() const AAX_OVERRIDE
Returns the parameter's unique identifier.
Definition: AAX_CParameter.h:103
AAX_DEFAULT_MOVE_CTOR(AAX_CParameterValue)
Generic implementation of an AAX_IParameter.
Definition: AAX_CParameter.h:238
bool SetValueWithString(const AAX_IString &value) AAX_OVERRIDE
Sets the parameter's value as a string.
Definition: AAX_CParameter.h:790
AAX_CParameterValue< T > mValue
Definition: AAX_CParameter.h:486
Type
Definition: AAX_CParameter.h:241
@ eParameterTypeUndefined
Definition: AAX_CParameter.h:242
@ eParameterTypeInt32
Definition: AAX_CParameter.h:244
@ eParameterTypeCustom
Definition: AAX_CParameter.h:246
@ eParameterTypeFloat
Definition: AAX_CParameter.h:245
@ eParameterTypeBool
Definition: AAX_CParameter.h:243
bool GetBoolFromNormalizedValue(double normalizedValue, bool *value) const AAX_OVERRIDE
Converts a normalized parameter value to a bool representing the corresponding real value.
Definition: AAX_CParameter.h:995
AAX_EParameterType GetType() const AAX_OVERRIDE
Returns the type of this parameter as an AAX_EParameterType.
Definition: AAX_CParameter.h:904
const AAX_CString & Name() const AAX_OVERRIDE
Returns the parameter's display name.
Definition: AAX_CParameter.h:599
AAX_EParameterOrientation mOrientation
Definition: AAX_CParameter.h:480
AAX_EParameterType mControlType
Definition: AAX_CParameter.h:479
AAX_CStringAbbreviations mNames
Definition: AAX_CParameter.h:476
AAX_DELETE(AAX_CParameter())
T mDefaultValue
Definition: AAX_CParameter.h:487
bool SetValueWithBool(bool value) AAX_OVERRIDE
Sets the parameter's value as a bool.
Definition: AAX_CParameter.h:758
AAX_IAutomationDelegate * mAutomationDelegate
Definition: AAX_CParameter.h:483
AAX_CParameter(AAX_CParamID identifier, const AAX_IString &name, T defaultValue, const AAX_ITaperDelegate< T > &taperDelegate, const AAX_IDisplayDelegate< T > &displayDelegate, bool automatable=false)
Constructs an AAX_CParameter object using the specified taper and display delegates.
Definition: AAX_CParameter.h:497
const AAX_CString & ShortenedName(int32_t iNumCharacters) const AAX_OVERRIDE
Returns the parameter's shortened display name.
Definition: AAX_CParameter.h:611
bool mNeedNotify
Definition: AAX_CParameter.h:484
double GetNormalizedValue() const AAX_OVERRIDE
Returns the normalized representation of the parameter's current real value.
Definition: AAX_CParameter.h:929
T GetDefaultValue() const
Returns the parameter's default value.
Definition: AAX_CParameter.h:820
bool GetNormalizedValueFromFloat(float value, double *normalizedValue) const AAX_OVERRIDE
Converts a float to a normalized parameter value.
Definition: AAX_CParameter.h:965
uint32_t mNumSteps
Definition: AAX_CParameter.h:478
bool GetValueAsFloat(float *value) const AAX_OVERRIDE
Retrieves the parameter's value as a float.
Definition: AAX_CParameter.h:726
void SetValue(T newValue)
Initiates a host request to set the parameter's value.
Definition: AAX_CParameter.h:625
~AAX_CParameter() AAX_OVERRIDE
Virtual destructor used to delete all locally allocated pointers.
Definition: AAX_CParameter.h:569
void Release() AAX_OVERRIDE
Signals the automation system that a control has been released.
Definition: AAX_CParameter.h:1131
AAX_DEFAULT_MOVE_CTOR(AAX_CParameter)
bool GetNormalizedValueFromBool(bool value, double *normalizedValue) const AAX_OVERRIDE
Converts a bool to a normalized parameter value.
Definition: AAX_CParameter.h:949
const AAX_IDisplayDelegate< T > * DisplayDelegate() const
Returns a reference to the parameter's display delegate.
Definition: AAX_CParameter.h:1096
Defaults
Definition: AAX_CParameter.h:249
@ eParameterDefaultNumStepsDiscrete
Definition: AAX_CParameter.h:250
@ eParameterDefaultNumStepsContinuous
Definition: AAX_CParameter.h:251
bool GetNormalizedValueFromInt32(int32_t value, double *normalizedValue) const AAX_OVERRIDE
Converts an integer to a normalized parameter value.
Definition: AAX_CParameter.h:957
bool GetValueAsBool(bool *value) const AAX_OVERRIDE
Retrieves the parameter's value as a bool.
Definition: AAX_CParameter.h:714
void SetTaperDelegate(AAX_ITaperDelegateBase &inTaperDelegate, bool inPreserveValue=true) AAX_OVERRIDE
Sets the parameter's taper delegate.
Definition: AAX_CParameter.h:1064
bool SetValueWithDouble(double value) AAX_OVERRIDE
Sets the parameter's value as a double.
Definition: AAX_CParameter.h:782
void SetDisplayDelegate(AAX_IDisplayDelegateBase &inDisplayDelegate) AAX_OVERRIDE
Sets the parameter's display delegate.
Definition: AAX_CParameter.h:1079
AAX_IParameterValue * CloneValue() const AAX_OVERRIDE
Clone the parameter's value to a new AAX_IParameterValue object.
Definition: AAX_CParameter.h:581
bool GetValueAsString(AAX_IString *value) const AAX_OVERRIDE
Retrieves the parameter's value as a string.
Definition: AAX_CParameter.h:738
bool GetNormalizedValueFromDouble(double value, double *normalizedValue) const AAX_OVERRIDE
Converts a double to a normalized parameter value.
Definition: AAX_CParameter.h:973
void SetStepValue(uint32_t iStep) AAX_OVERRIDE
Returns the current step for the current value of the parameter.
Definition: AAX_CParameter.h:888
T GetValue() const
Returns the parameter's value.
Definition: AAX_CParameter.h:707
AAX_EParameterOrientation GetOrientation() const AAX_OVERRIDE
Returns the orientation of this parameter.
Definition: AAX_CParameter.h:916
void UpdateNormalizedValue(double newNormalizedValue) AAX_OVERRIDE
Sets the parameter's state given a normalized value.
Definition: AAX_CParameter.h:657
AAX_DEFAULT_MOVE_OPER(AAX_CParameter)
void SetName(const AAX_CString &name) AAX_OVERRIDE
Sets the parameter's display name.
Definition: AAX_CParameter.h:593
uint32_t GetStepValue() const AAX_OVERRIDE
Returns the current step for the current value of the parameter.
Definition: AAX_CParameter.h:848
double GetNormalizedDefaultValue() const AAX_OVERRIDE
Returns the normalized representation of the parameter's real default value.
Definition: AAX_CParameter.h:806
void SetOrientation(AAX_EParameterOrientation iOrientation) AAX_OVERRIDE
Sets the orientation of this parameter.
Definition: AAX_CParameter.h:910
void SetToDefaultValue() AAX_OVERRIDE
Restores the state of this parameter to its default value.
Definition: AAX_CParameter.h:826
AAX_DELETE(AAX_CParameter(const AAX_CParameter &other))
void SetType(AAX_EParameterType iControlType) AAX_OVERRIDE
Sets the type of this parameter.
Definition: AAX_CParameter.h:898
void SetNormalizedDefaultValue(double normalizedDefault) AAX_OVERRIDE
Sets the parameter's default value using its normalized representation.
Definition: AAX_CParameter.h:799
const AAX_ITaperDelegate< T > * TaperDelegate() const
Returns a reference to the parameter's taper delegate.
Definition: AAX_CParameter.h:1090
double GetNormalizedValueFromStep(uint32_t iStep) const AAX_OVERRIDE
Returns the normalized value for a given step.
Definition: AAX_CParameter.h:854
void AddShortenedName(const AAX_CString &name) AAX_OVERRIDE
Sets the parameter's shortened display name.
Definition: AAX_CParameter.h:605
bool SetValueFromString(const AAX_CString &newValueString) AAX_OVERRIDE
Converts a string to a real parameter value and sets the parameter to this value.
Definition: AAX_CParameter.h:1054
bool GetInt32FromNormalizedValue(double normalizedValue, int32_t *value) const AAX_OVERRIDE
Converts a normalized parameter value to an integer representing the corresponding real value.
Definition: AAX_CParameter.h:1004
bool GetDoubleFromNormalizedValue(double normalizedValue, double *value) const AAX_OVERRIDE
Converts a normalized parameter value to a double representing the corresponding real value.
Definition: AAX_CParameter.h:1020
bool SetValueWithInt32(int32_t value) AAX_OVERRIDE
Sets the parameter's value as an int32_t.
Definition: AAX_CParameter.h:766
void ClearShortenedNames() AAX_OVERRIDE
Clears the internal list of shortened display names.
Definition: AAX_CParameter.h:617
AAX_ITaperDelegate< T > * mTaperDelegate
Definition: AAX_CParameter.h:481
bool SetValueWithFloat(float value) AAX_OVERRIDE
Sets the parameter's value as a float.
Definition: AAX_CParameter.h:774
uint32_t GetStepValueFromNormalizedValue(double normalizedValue) const AAX_OVERRIDE
Returns the step value for a normalized value of the parameter.
Definition: AAX_CParameter.h:871
void SetNumberOfSteps(uint32_t numSteps) AAX_OVERRIDE
Sets the number of discrete steps for this parameter.
Definition: AAX_CParameter.h:832
void SetNormalizedValue(double newNormalizedValue) AAX_OVERRIDE
Sets a parameter value using it's normalized representation.
Definition: AAX_CParameter.h:922
void SetAutomationDelegate(AAX_IAutomationDelegate *iAutomationDelegate) AAX_OVERRIDE
Sets the automation delegate (if one is required)
Definition: AAX_CParameter.h:1108
AAX_DELETE(AAX_CParameter &operator=(const AAX_CParameter &other))
bool GetValueString(AAX_CString *valueString) const AAX_OVERRIDE
Serializes the parameter value into a string.
Definition: AAX_CParameter.h:937
bool GetStringFromNormalizedValue(double normalizedValue, AAX_CString &valueString) const AAX_OVERRIDE
Converts a normalized parameter value to a string representing the corresponding real value.
Definition: AAX_CParameter.h:1028
bool GetFloatFromNormalizedValue(double normalizedValue, float *value) const AAX_OVERRIDE
Converts a normalized parameter value to a float representing the corresponding real value.
Definition: AAX_CParameter.h:1012
bool GetValueAsDouble(double *value) const AAX_OVERRIDE
Retrieves the parameter's value as a double.
Definition: AAX_CParameter.h:732
bool Automatable() const AAX_OVERRIDE
Returns true if the parameter is automatable, false if it is not.
Definition: AAX_CParameter.h:1102
AAX_CParamID Identifier() const AAX_OVERRIDE
Returns the parameter's unique identifier.
Definition: AAX_CParameter.h:587
bool GetNormalizedValueFromString(const AAX_CString &valueString, double *normalizedValue) const AAX_OVERRIDE
Converts a given string to a normalized parameter value.
Definition: AAX_CParameter.h:981
AAX_IDisplayDelegate< T > * mDisplayDelegate
Definition: AAX_CParameter.h:482
void SetDefaultValue(T newDefaultValue)
Set the parameter's default value.
Definition: AAX_CParameter.h:813
bool mAutomatable
Definition: AAX_CParameter.h:477
bool GetValueAsInt32(int32_t *value) const AAX_OVERRIDE
Retrieves the parameter's value as an int32_t.
Definition: AAX_CParameter.h:720
void Touch() AAX_OVERRIDE
Signals the automation system that a control has been touched.
Definition: AAX_CParameter.h:1123
uint32_t GetNumberOfSteps() const AAX_OVERRIDE
Returns the number of discrete steps used by the parameter.
Definition: AAX_CParameter.h:842
A stateless parameter implementation.
Definition: AAX_CParameter.h:1153
bool SetValueWithDouble(double) AAX_OVERRIDE
Sets the parameter's value as a double.
Definition: AAX_CParameter.h:1260
uint32_t GetStepValueFromNormalizedValue(double) const AAX_OVERRIDE
Returns the step value for a normalized value of the parameter.
Definition: AAX_CParameter.h:1222
const AAX_CString & Name() const AAX_OVERRIDE
Returns the parameter's display name.
Definition: AAX_CParameter.h:1181
bool GetValueAsInt32(int32_t *) const AAX_OVERRIDE
Retrieves the parameter's value as an int32_t.
Definition: AAX_CParameter.h:1253
void ClearShortenedNames() AAX_OVERRIDE
Clears the internal list of shortened display names.
Definition: AAX_CParameter.h:1184
double GetNormalizedDefaultValue() const AAX_OVERRIDE
Returns the normalized representation of the parameter's real default value.
Definition: AAX_CParameter.h:1216
bool GetStringFromNormalizedValue(double, AAX_CString &valueString) const AAX_OVERRIDE
Converts a normalized parameter value to a string representing the corresponding real value.
Definition: AAX_CParameter.h:1243
double GetNormalizedValue() const AAX_OVERRIDE
Returns the normalized representation of the parameter's current real value.
Definition: AAX_CParameter.h:1214
double GetNormalizedValueFromStep(uint32_t) const AAX_OVERRIDE
Returns the normalized value for a given step.
Definition: AAX_CParameter.h:1221
void SetTaperDelegate(AAX_ITaperDelegateBase &, bool) AAX_OVERRIDE
Sets the parameter's taper delegate.
Definition: AAX_CParameter.h:1270
const AAX_CString & ShortenedName(int32_t iNumCharacters) const AAX_OVERRIDE
Returns the parameter's shortened display name.
Definition: AAX_CParameter.h:1183
bool GetBoolFromNormalizedValue(double, bool *value) const AAX_OVERRIDE
Converts a normalized parameter value to a bool representing the corresponding real value.
Definition: AAX_CParameter.h:1239
AAX_IParameterValue * CloneValue() const AAX_OVERRIDE
Clone the parameter's value to a new AAX_IParameterValue object.
Definition: AAX_CParameter.h:1173
void AddShortenedName(const AAX_CString &name) AAX_OVERRIDE
Sets the parameter's shortened display name.
Definition: AAX_CParameter.h:1182
bool GetValueString(int32_t, AAX_CString *valueString) const AAX_OVERRIDE
Serializes the parameter value into a string, size hint included.
Definition: AAX_CParameter.h:1233
uint32_t GetStepValue() const AAX_OVERRIDE
Returns the current step for the current value of the parameter.
Definition: AAX_CParameter.h:1220
bool GetInt32FromNormalizedValue(double, int32_t *) const AAX_OVERRIDE
Converts a normalized parameter value to an integer representing the corresponding real value.
Definition: AAX_CParameter.h:1240
AAX_CStringAbbreviations mNames
Definition: AAX_CParameter.h:1277
AAX_EParameterType GetType() const AAX_OVERRIDE
Returns the type of this parameter as an AAX_EParameterType.
Definition: AAX_CParameter.h:1265
bool GetNormalizedValueFromBool(bool, double *normalizedValue) const AAX_OVERRIDE
Converts a bool to a normalized parameter value.
Definition: AAX_CParameter.h:1234
void UpdateNormalizedValue(double) AAX_OVERRIDE
Sets the parameter's state given a normalized value.
Definition: AAX_CParameter.h:1277
void SetNumberOfSteps(uint32_t) AAX_OVERRIDE
Sets the number of discrete steps for this parameter.
Definition: AAX_CParameter.h:1218
void SetDisplayDelegate(AAX_IDisplayDelegateBase &) AAX_OVERRIDE
Sets the parameter's display delegate.
Definition: AAX_CParameter.h:1271
AAX_EParameterOrientation GetOrientation() const AAX_OVERRIDE
Returns the orientation of this parameter.
Definition: AAX_CParameter.h:1268
bool GetNormalizedValueFromInt32(int32_t, double *normalizedValue) const AAX_OVERRIDE
Converts an integer to a normalized parameter value.
Definition: AAX_CParameter.h:1235
void Release() AAX_OVERRIDE
Signals the automation system that a control has been released.
Definition: AAX_CParameter.h:1206
bool SetValueWithString(const AAX_IString &value) AAX_OVERRIDE
Sets the parameter's value as a string.
Definition: AAX_CParameter.h:1261
AAX_CStatelessParameter(const AAX_IString &identifier, const AAX_IString &name, const AAX_IString &inValueString)
Definition: AAX_CParameter.h:1163
bool GetNormalizedValueFromString(const AAX_CString &, double *normalizedValue) const AAX_OVERRIDE
Converts a given string to a normalized parameter value.
Definition: AAX_CParameter.h:1238
bool GetValueAsFloat(float *) const AAX_OVERRIDE
Retrieves the parameter's value as a float.
Definition: AAX_CParameter.h:1254
bool GetStringFromNormalizedValue(double normalizedValue, int32_t, AAX_CString &valueString) const AAX_OVERRIDE
Converts a normalized parameter value to a string representing the corresponding real,...
Definition: AAX_CParameter.h:1244
void Touch() AAX_OVERRIDE
Signals the automation system that a control has been touched.
Definition: AAX_CParameter.h:1205
void SetNormalizedValue(double) AAX_OVERRIDE
Sets a parameter value using it's normalized representation.
Definition: AAX_CParameter.h:1213
void SetNormalizedDefaultValue(double) AAX_OVERRIDE
Sets the parameter's default value using its normalized representation.
Definition: AAX_CParameter.h:1215
void SetToDefaultValue() AAX_OVERRIDE
Restores the state of this parameter to its default value.
Definition: AAX_CParameter.h:1217
bool Automatable() const AAX_OVERRIDE
Returns true if the parameter is automatable, false if it is not.
Definition: AAX_CParameter.h:1191
bool SetValueWithInt32(int32_t) AAX_OVERRIDE
Sets the parameter's value as an int32_t.
Definition: AAX_CParameter.h:1258
AAX_CParamID Identifier() const AAX_OVERRIDE
Returns the parameter's unique identifier.
Definition: AAX_CParameter.h:1179
bool GetDoubleFromNormalizedValue(double, double *) const AAX_OVERRIDE
Converts a normalized parameter value to a double representing the corresponding real value.
Definition: AAX_CParameter.h:1242
bool GetNormalizedValueFromFloat(float, double *normalizedValue) const AAX_OVERRIDE
Converts a float to a normalized parameter value.
Definition: AAX_CParameter.h:1236
bool SetValueWithBool(bool) AAX_OVERRIDE
Sets the parameter's value as a bool.
Definition: AAX_CParameter.h:1257
AAX_CString mID
Definition: AAX_CParameter.h:1282
AAX_CStatelessParameter(AAX_CParamID identifier, const AAX_IString &name, const AAX_IString &inValueString)
Definition: AAX_CParameter.h:1155
bool SetValueWithFloat(float) AAX_OVERRIDE
Sets the parameter's value as a float.
Definition: AAX_CParameter.h:1259
bool SetValueFromString(const AAX_CString &newValueString) AAX_OVERRIDE
Converts a string to a real parameter value and sets the parameter to this value.
Definition: AAX_CParameter.h:1245
bool GetNormalizedValueFromDouble(double, double *normalizedValue) const AAX_OVERRIDE
Converts a double to a normalized parameter value.
Definition: AAX_CParameter.h:1237
bool GetValueAsString(AAX_IString *) const AAX_OVERRIDE
Retrieves the parameter's value as a string.
Definition: AAX_CParameter.h:1256
void SetAutomationDelegate(AAX_IAutomationDelegate *iAutomationDelegate) AAX_OVERRIDE
Sets the automation delegate (if one is required)
Definition: AAX_CParameter.h:1192
bool GetValueString(AAX_CString *valueString) const AAX_OVERRIDE
Serializes the parameter value into a string.
Definition: AAX_CParameter.h:1232
void SetStepValue(uint32_t) AAX_OVERRIDE
Returns the current step for the current value of the parameter.
Definition: AAX_CParameter.h:1223
void SetType(AAX_EParameterType) AAX_OVERRIDE
Sets the type of this parameter.
Definition: AAX_CParameter.h:1264
AAX_CString mValueString
Definition: AAX_CParameter.h:1284
void SetName(const AAX_CString &name) AAX_OVERRIDE
Sets the parameter's display name.
Definition: AAX_CParameter.h:1180
bool GetFloatFromNormalizedValue(double, float *) const AAX_OVERRIDE
Converts a normalized parameter value to a float representing the corresponding real value.
Definition: AAX_CParameter.h:1241
bool GetValueAsBool(bool *value) const AAX_OVERRIDE
Retrieves the parameter's value as a bool.
Definition: AAX_CParameter.h:1252
AAX_IAutomationDelegate * mAutomationDelegate
Definition: AAX_CParameter.h:1283
AAX_DEFAULT_DTOR_OVERRIDE(AAX_CStatelessParameter)
uint32_t GetNumberOfSteps() const AAX_OVERRIDE
Returns the number of discrete steps used by the parameter.
Definition: AAX_CParameter.h:1219
void SetOrientation(AAX_EParameterOrientation) AAX_OVERRIDE
Sets the orientation of this parameter.
Definition: AAX_CParameter.h:1267
bool GetValueAsDouble(double *) const AAX_OVERRIDE
Retrieves the parameter's value as a double.
Definition: AAX_CParameter.h:1255
A generic AAX string class with similar functionality to std::string
Definition: AAX_CString.h:46
const char * CString() const
const char * Get() const AAX_OVERRIDE
Helper class to store a collection of name abbreviations.
Definition: AAX_CString.h:175
void Clear()
Definition: AAX_CString.h:209
void Add(const AAX_CString &inAbbreviation)
Definition: AAX_CString.h:186
const AAX_CString & Primary() const
Definition: AAX_CString.h:184
void SetPrimary(const AAX_CString &inPrimary)
Definition: AAX_CString.h:183
const AAX_CString & Get(int32_t inNumCharacters) const
Definition: AAX_CString.h:192
Interface allowing an AAX plug-in to interact with the host's event system.
Definition: AAX_IAutomationDelegate.h:47
virtual AAX_Result PostTouchRequest(AAX_CParamID iParameterID)=0
virtual AAX_Result RegisterParameter(AAX_CParamID iParameterID)=0
virtual AAX_Result PostReleaseRequest(AAX_CParamID iParameterID)=0
virtual AAX_Result UnregisterParameter(AAX_CParamID iParameterID)=0
Defines the display behavior for a parameter.
Definition: AAX_IDisplayDelegate.h:53
Classes for parameter value string conversion.
Definition: AAX_IDisplayDelegate.h:69
virtual AAX_IDisplayDelegate * Clone() const =0
Constructs and returns a copy of the display delegate.
An abstract interface representing a parameter value of arbitrary type.
Definition: AAX_IParameter.h:45
The base interface for all normalizable plug-in parameters.
Definition: AAX_IParameter.h:140
A simple string container that can be passed across a binary boundary. This class,...
Definition: AAX_IString.h:41
Defines the taper conversion behavior for a parameter.
Definition: AAX_ITaperDelegate.h:73
Classes for conversion to and from normalized parameter values.
Definition: AAX_ITaperDelegate.h:89
virtual AAX_ITaperDelegate * Clone() const =0
Constructs and returns a copy of the taper delegate.