Jamba C++ API  4.3.0
GUIOptionalParam.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2019 pongasoft
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
5  * use this file except in compliance with the License. You may obtain a copy of
6  * the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13  * License for the specific language governing permissions and limitations under
14  * the License.
15  *
16  * @author Yan Pujante
17  */
18 #pragma once
19 
20 #include <pluginterfaces/vst/vsttypes.h>
21 #include <pongasoft/logging/logging.h>
23 #include "IGUIParameter.h"
24 #include "GUIVstParameter.h"
25 #include "GUIJmbParameter.h"
26 #include "GUIValParameter.h"
27 
29 
30 using namespace Steinberg::Vst;
31 
47 template<typename T>
48 class GUIOptionalParam: public Utils::Operators::Dereferenceable<GUIOptionalParam<T>>
49 {
50  static_assert(std::is_default_constructible_v<T>, "T must have a default/empty constructor: T()");
51  static_assert(std::is_copy_constructible_v<T>, "T must have a copy constructor: T(T const &)");
52  static_assert(std::is_copy_assignable_v<T>, "T must be copy assignable: T& operator=(T const &)");
53 
54 public:
56  using ParamType = T;
58 
59 public:
64  class Value {
65  public:
66  constexpr T const *operator ->() const { return &fValue; }
67  friend class GUIOptionalParam<T>;
68  private:
69  explicit Value(T const &iValue) : fValue{iValue} {}
70  T fValue;
71  };
72 
73 public:
74  // Constructor
76  fParameter{VstUtils::make_sfo<GUIValParameter<T>>(UNDEFINED_PARAM_ID, T{})} {}
77 
78  // Constructor
79  explicit GUIOptionalParam(T const &iDefaultValue) :
80  fParameter{VstUtils::make_sfo<GUIValParameter<T>>(UNDEFINED_PARAM_ID, iDefaultValue)} {}
81 
82  // Constructor
83  explicit GUIOptionalParam(std::shared_ptr<ITGUIParameter<T>> iParameter) : fParameter{std::move(iParameter) } {
84  DCHECK_F(fParameter != nullptr);
85  }
86 
89  inline bool exists() const { return true; }
90 
93  inline ParamID getParamID() const { return fParameter->getParamID(); }
94 
98  inline ParamType getValue() const
99  {
100  ParamType res;
101  fParameter->accessValue([&res](auto const &iValue) { res = iValue; });
102  return res;
103  }
104 
106  inline ParamType value() const { return getValue(); }
107 
110  inline bool update(ParamType const &iValue)
111  {
112  return fParameter->update(iValue);
113  }
114 
117  inline tresult setValue(ParamType const &iValue)
118  {
119  return fParameter->setValue(iValue);
120  }
121 
124  inline std::unique_ptr<EditorType> edit()
125  {
126  return fParameter->edit();
127  }
128 
131  inline std::unique_ptr<EditorType> edit(ParamType const &iValue)
132  {
133  return fParameter->edit(iValue);
134  }
135 
138  inline int32 getStepCount() const { return fParameter->getStepCount(); }
139 
141  constexpr ParamType operator *() const { return getValue(); }
142 
144  constexpr Value operator ->() const { return Value{getValue()}; }
145 
151  [[deprecated("Since 4.1.0 - use operator* or value() instead (ex: if(*param) {...} or if(param.value() {...})")]]
152  inline operator ParamType() const { return getValue(); } // NOLINT
153 
156  inline GUIOptionalParam &operator=(T const &iValue) { update(iValue); return *this; }
157 
160  inline std::unique_ptr<FObjectCx> connect(Parameters::IChangeListener *iChangeListener) const
161  {
162  return fParameter->connect(iChangeListener);
163  }
164 
167  inline std::unique_ptr<FObjectCx> connect(Parameters::ChangeCallback iChangeCallback) const
168  {
169  return fParameter->connect(iChangeCallback);
170  }
171 
172 private:
173  std::shared_ptr<ITGUIParameter<ParamType>> fParameter;
174 };
175 
176 
177 template<typename T>
178 using GUIOptionalParamEditor = std::unique_ptr<typename GUIOptionalParam<T>::EditorType>;
179 
182 
183 }
std::unique_ptr< FObjectCx > connect(Parameters::ChangeCallback iChangeCallback) const
Creates a connection between this parameter and the callback: whenever the parameter changes,...
Definition: GUIOptionalParam.h:167
ParamType value() const
Synonym to getValue()
Definition: GUIOptionalParam.h:106
std::function< void()> ChangeCallback
A callback that will be invoked for changes.
Definition: Parameters.h:55
Represents a gui parameter with its underlying backing type T (aka ParamType).
Definition: IGUIParameter.h:33
std::unique_ptr< typename GUIOptionalParam< T >::EditorType > GUIOptionalParamEditor
Definition: GUIOptionalParam.h:178
T fValue
Definition: GUIOptionalParam.h:70
std::unique_ptr< FObjectCx > connect(Parameters::IChangeListener *iChangeListener) const
Creates a connection between this parameter and the change listener: whenever the parameter changes,...
Definition: GUIOptionalParam.h:160
Implements all the various equality and relational operators for the type T which is assumed to encap...
Definition: Operators.h:54
constexpr ParamType operator *() const
allow writing *param to access the underlying value (or in other words, *param is the same param....
Definition: GUIOptionalParam.h:141
Definition: GUIState.h:36
GUIOptionalParam()
Definition: GUIOptionalParam.h:75
ParamID getParamID() const
Each parameter has a unique ID returned by this method.
Definition: GUIOptionalParam.h:93
tresult setValue(ParamType const &iValue)
Unconditionally sets the value of the parameter to the value provided.
Definition: GUIOptionalParam.h:117
GUIOptionalParam(T const &iDefaultValue)
Definition: GUIOptionalParam.h:79
GUIOptionalParamEditor< ParamValue > GUIRawOptionalParamEditor
Definition: GUIOptionalParam.h:181
typename ITGUIParameter< ParamValue >::ITEditor EditorType
Definition: GUIOptionalParam.h:57
std::unique_ptr< EditorType > edit()
Creates an editor to modify the parameter in a transactional fashion.
Definition: GUIOptionalParam.h:124
int32 getStepCount() const
When a parameter is a discrete parameter (which means its underlying backing type is an int32 with va...
Definition: GUIOptionalParam.h:138
GUIOptionalParam & operator=(T const &iValue)
Allow to write param = 3 instead of param.update(3) for example.
Definition: GUIOptionalParam.h:156
bool update(ParamType const &iValue)
First check if the value provided (iValue) is different from the current value and if that is the cas...
Definition: GUIOptionalParam.h:110
GUIOptionalParam(std::shared_ptr< ITGUIParameter< T >> iParameter)
Definition: GUIOptionalParam.h:83
ParamType getValue() const
Definition: GUIOptionalParam.h:98
ParamValue ParamType
Definition: GUIOptionalParam.h:56
bool exists() const
Always return true because by definition an optional parameter always exist.
Definition: GUIOptionalParam.h:89
Defines the API for the editor which can be obtained by calling ITGUIParameter::edit().
Definition: IGUIParameter.h:232
std::shared_ptr< ITGUIParameter< ParamType > > fParameter
Definition: GUIOptionalParam.h:173
constexpr T const * operator ->() const
Definition: GUIOptionalParam.h:66
The purpose of this class is to copy the value so that it can be accessed via -> thus allowing to wri...
Definition: GUIOptionalParam.h:64
std::unique_ptr< EditorType > edit(ParamType const &iValue)
Shortcut api which creates an editor followed by ITEditor::setValue(ParamType const &) to set the par...
Definition: GUIOptionalParam.h:131
constexpr Value operator ->() const
allow writing param->x to access the underlying value when T is a struct or class
Definition: GUIOptionalParam.h:144
constexpr ParamID UNDEFINED_PARAM_ID
Constant used throughout the code to test whether the ParamID represents a valid id or an undefined o...
Definition: Types.h:47
Value(T const &iValue)
Definition: GUIOptionalParam.h:69
Interface to implement to receive parameter changes.
Definition: Parameters.h:43
Represents an optional parameter (Jmb, Vst or no param at all).
Definition: GUIOptionalParam.h:48