GUIValParameter.h

Go to the documentation of this file.

/*
 * Copyright (c) 2019-2020 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/Metaprogramming.h>
#include "GUIParamCx.h"
 
namespace pongasoft::VST::GUI::Params {
 
using namespace Steinberg::Vst;

template<typename T>
class GUIValParameter: public ITGUIParameter<T>, public FObject
{
  // Since this parameter is used by GUIOptionalParam parameter it should satisfy the same rules
  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 ParamType = T;
  using EditorType = typename ITGUIParameter<T>::ITEditor;
 
  using FObject::update; // fixes overload hiding warning
 
public:
  // Constructor
  explicit GUIValParameter(ParamID iParamID, ParamType const &iDefaultValue) :
    fParamID{iParamID},
    fDefaultValue{iDefaultValue},
    fValue(iDefaultValue)
  {
//    DLOG_F(INFO, "GUIValParameter(%p)", this);
  };
 
  // Destructor
  ~GUIValParameter() override
  {
//    DLOG_F(INFO, "~GUIValParameter(%p)", this);
  }
 
  // getParamID
  ParamID getParamID() const override { return fParamID; }
  void setParamID(ParamID iParamID) { fParamID = iParamID; }
 
  inline int32 getStepCount() const override { return 0; }

  bool update(ParamType const &iValue) override
  {
    // Implementation note: because this method is declared virtual the compiler must instantiate it
    // even if never called and will generate an error if the ParamType does not define operator!=, so we
    // need to account for this case
    if constexpr(Utils::is_operator_not_eq_defined<ParamType>)
    {
      if(fValue != iValue)
      {
        if(setValue(iValue) == kResultOk)
          return true;
      }
    }
    else
    {
      if(setValue(iValue) == kResultOk)
        return true;
    }
    return false;
  }

  std::unique_ptr<EditorType> edit() override
  {
    return std::make_unique<DefaultEditorImpl<T>>(this, getValue());
  }

  template<class ValueModifier>
  bool updateIf(ValueModifier const &iValueModifier)
  {
    if(iValueModifier(&fValue))
    {
      changed();
      return true;
    }
    return false;
  }

  tresult setValue(ParamType const &iValue) override
  {
    fValue = iValue;
    changed();
    return kResultOk;
  }

  tresult resetToDefault() override
  {
    return update(fDefaultValue);
  }
 
  // accessValue
  tresult accessValue(typename ITGUIParameter<T>::ValueAccessor const &iGetter) const override
  {
    iGetter(fValue);
    return kResultOk;
  }
 
  // getValue
  inline ParamType const &getValue() const { return fValue; }
 
  // getValue
  inline ParamType &getValue() { return fValue; }
 
  // toUTF8String
  std::string toUTF8String(int32 iPrecision) const override
  {
    return VstUtils::toUTF8String(getValue(), iPrecision);
  }

  std::unique_ptr<FObjectCx> connect(Parameters::IChangeListener *iChangeListener) const override
  {
    return std::make_unique<GUIParamCx>(getParamID(), const_cast<GUIValParameter *>(this), iChangeListener);
  }

  std::unique_ptr<FObjectCx> connect(Parameters::ChangeCallback iChangeCallback) const override
  {
    return std::make_unique<FObjectCxCallback>(const_cast<GUIValParameter *>(this), iChangeCallback);
  }
 
  // asDiscreteParameter
  std::shared_ptr<GUIDiscreteParameter> asDiscreteParameter(int32 iStepCount) override;
 
protected:
  ParamID fParamID;
  T fDefaultValue;
  T fValue;
};

class GUIDiscreteValParameter : public GUIValParameter<int32>
{
public:
  GUIDiscreteValParameter(ParamID iParamID, int32 iDefaultValue, int32 iStepCount) :
    GUIValParameter(iParamID, iDefaultValue),
    fStepCount(iStepCount)
  {
    DCHECK_F(fStepCount > 0);
  }
 
  // getStepCount
  int32 getStepCount() const override { return fStepCount; }
 
protected:
  int32 fStepCount;
};
 
//------------------------------------------------------------------------
// GUIValParameter::asDiscreteParameter
//------------------------------------------------------------------------
template<typename T>
std::shared_ptr<GUIDiscreteParameter> GUIValParameter<T>::asDiscreteParameter(int32 iStepCount)
{
  if(iStepCount > 0)
  {
    if constexpr(Utils::is_static_cast_defined<int32, T> && Utils::is_static_cast_defined<T, int32>)
    {
      return VstUtils::make_sfo<GUIDiscreteValParameter>(fParamID, static_cast<int32>(fValue), iStepCount);
    }
  }
  return nullptr;
}
 
}