GUIOptionalParam.h

Go to the documentation of this file.

/*
 * Copyright (c) 2019 pongasoft
 *
 * Licensed under the Apache License, Version 2.0 or the MIT license,
 * at your option. You may not use this file except in compliance with
 * one of these licenses. You may obtain copies of the licenses at:
 *
 * https://www.apache.org/licenses/LICENSE-2.0
 * https://opensource.org/licenses/MIT
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 *
 * @author Yan Pujante
 */
#pragma once
 
#include <pluginterfaces/vst/vsttypes.h>
#include <pongasoft/logging/logging.h>
#include <pongasoft/Utils/Operators.h>
#include "IGUIParameter.h"
#include "GUIVstParameter.h"
#include "GUIJmbParameter.h"
#include "GUIValParameter.h"
 
namespace pongasoft::VST::GUI::Params {
 
using namespace Steinberg::Vst;

template<typename T>
class GUIOptionalParam: public Utils::Operators::Dereferenceable<GUIOptionalParam<T>>
{
  static_assert(std::is_default_constructible_v<T>, "T must have a default/empty constructor: T()");
  static_assert(std::is_copy_constructible_v<T>, "T must have a copy constructor: T(T const &)");
  static_assert(std::is_copy_assignable_v<T>, "T must be copy assignable: T& operator=(T const &)");
 
public:
  using class_type = GUIOptionalParam<T>;
  using ParamType = T;
  using EditorType = typename ITGUIParameter<T>::ITEditor;
  using Editor = std::unique_ptr<EditorType>;
 
public:
  class Value {
  public:
    constexpr T const *operator ->() const { return &fValue; }
    friend class GUIOptionalParam<T>;
  private:
    explicit Value(T const &iValue) : fValue{iValue} {}
    T fValue;
  };
 
public:
  // Constructor
  GUIOptionalParam() :
    fParameter{VstUtils::make_sfo<GUIValParameter<T>>(UNDEFINED_PARAM_ID, T{})} {}
 
  // Constructor
  explicit GUIOptionalParam(T const &iDefaultValue) :
    fParameter{VstUtils::make_sfo<GUIValParameter<T>>(UNDEFINED_PARAM_ID, iDefaultValue)} {}
 
  // Constructor
  explicit GUIOptionalParam(std::shared_ptr<ITGUIParameter<T>> iParameter) : fParameter{std::move(iParameter) } {
    DCHECK_F(fParameter != nullptr);
  }

  inline bool exists() const { return true; }

  inline ParamID getParamID() const { return fParameter->getParamID(); }

  inline ParamType getValue() const
  {
    ParamType res;
    fParameter->accessValue([&res](auto const &iValue) { res = iValue; });
    return res;
  }

  inline ParamType value() const { return getValue(); }

  inline bool update(ParamType const &iValue)
  {
    return fParameter->update(iValue);
  }

  inline tresult setValue(ParamType const &iValue)
  {
    return fParameter->setValue(iValue);
  }

   inline tresult resetToDefault() { fParameter->resetToDefault(); }

  inline std::unique_ptr<EditorType> edit()
  {
    return fParameter->edit();
  }

  inline std::unique_ptr<EditorType> edit(ParamType const &iValue)
  {
    return fParameter->edit(iValue);
  }

  inline int32 getStepCount() const { return fParameter->getStepCount(); }

  constexpr ParamType operator *() const { return getValue(); }

  constexpr Value operator ->() const { return Value{getValue()}; }

  [[deprecated("Since 4.1.0 -  use operator* or value() instead (ex: if(*param) {...} or if(param.value() {...})")]]
  inline operator ParamType() const { return getValue(); } // NOLINT

  inline GUIOptionalParam &operator=(T const &iValue) { update(iValue); return *this; }

  inline std::string toUTF8String(int32 iPrecision) const { return fParameter->toUTF8String(iPrecision); }

  inline std::unique_ptr<FObjectCx> connect(Parameters::IChangeListener *iChangeListener) const
  {
    return fParameter->connect(iChangeListener);
  }

  inline std::unique_ptr<FObjectCx> connect(Parameters::ChangeCallback iChangeCallback) const
  {
    return fParameter->connect(iChangeCallback);
  }
 
private:
  std::shared_ptr<ITGUIParameter<ParamType>> fParameter;
};
 
 
template<typename T>
using GUIOptionalParamEditor = std::unique_ptr<typename GUIOptionalParam<T>::EditorType>;
 
using GUIRawOptionalParam = GUIOptionalParam<ParamValue>;
using GUIRawOptionalParamEditor = GUIOptionalParamEditor<ParamValue>;
 
}