GUIVstParameter.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018-2020 pongasoft
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * 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 "IGUIParameter.h"
#include "GUIRawVstParameter.h"
#include <pongasoft/VST/ParamConverters.h>
#include <pongasoft/VST/ParamDef.h>
#include <pongasoft/Utils/Operators.h>

namespace pongasoft::VST::GUI::Params {

template<typename T>
class GUIVstParameter : public ITGUIParameter<T>
{
public:
  using ParamType = T;
  using EditorType = typename ITGUIParameter<T>::ITEditor;

public:
  class Editor : public EditorType
  {
  public:
    inline explicit Editor(GUIRawVstParamEditor iRawEditor,
                           std::shared_ptr<IParamConverter<T>> iConverter) :
      fRawEditor{std::move(iRawEditor)},
      fConverter{std::move(iConverter)}
    {
    }

    ~Editor() override { rollback(); }

    // disabling copy
    Editor(Editor const &) = delete;
    Editor& operator=(Editor const &) = delete;

    tresult setValue(ParamType const &iValue) override
    {
      return fRawEditor->setValue(fConverter->normalize(iValue));
    }

    bool updateValue(ParamType const &iValue) override
    {
      return fRawEditor->updateValue(fConverter->normalize(iValue));
    }

    /*
     * Call when you are done with the modifications.
     * This has no effect if rollback() has already been called
     */
    tresult commit() override
    {
      return fRawEditor->commit();
    }

    // importing superclass commit methods
    using EditorType::commit;

    tresult rollback() override
    {
      return fRawEditor->rollback();
    }

  private:
    GUIRawVstParamEditor fRawEditor;
    std::shared_ptr<IParamConverter<T>> fConverter;
  };

public:
  // Constructor
  GUIVstParameter(std::shared_ptr<GUIRawVstParameter> iRawParameter,
                  std::shared_ptr<IParamConverter<T>> iConverter) :
    fRawParameter{std::move(iRawParameter)},
    fConverter{std::move(iConverter)}
  {
    DCHECK_NOTNULL_F(fRawParameter.get());
    DCHECK_NOTNULL_F(fConverter.get());
    // DLOG_F(INFO, "VSTParameter::VSTParameter(%d)", fRawParameter->getParamID());
  }

  // Destructor
  ~GUIVstParameter()
  {
    // DLOG_F(INFO, "VSTParameter::~VSTParameter(%d)", fRawParameter->getParamID());
  }

  // getParamID
  ParamID getParamID() const override
  {
    return fRawParameter->getParamID();
  }

  // accessValue
  tresult accessValue(typename ITGUIParameter<T>::ValueAccessor const &iGetter) const override
  {
    iGetter(getValue());
    return kResultOk;
  }

  ParamType getValue() const
  {
    return fConverter->denormalize(fRawParameter->getValue());
  }

  ParamValue getNormalizedValue() const
  {
    return fRawParameter->getValue();
  }

  bool update(ParamType const &iValue) override
  {
    // Implementation note: because ParamType may not define `operator!=` we use the normalized value instead
    auto currentNormalizedValue = getNormalizedValue();
    auto newNormalizedValued = fConverter->normalize(iValue);
    if(currentNormalizedValue != newNormalizedValued)
    {
      if(setNormalizedValue(newNormalizedValued) == kResultOk)
        return true;
    }
    return false;
  }

  tresult setValue(ParamType const &iValue) override
  {
    return fRawParameter->setValue(fConverter->normalize(iValue));
  }

  tresult setNormalizedValue(ParamValue const &iNormalizedValue)
  {
    return fRawParameter->setValue(iNormalizedValue);
  }

  tresult resetToDefault() override
  {
    return fRawParameter->resetToDefault();
  }

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

  void toString(String128 oString)
  {
    fRawParameter->toString(oString);
  }

  Steinberg::String toString()
  {
    return fRawParameter->toString();
  }

  // toUTF8String
  std::string toUTF8String(int32 iPrecision) const override
  {
    return fConverter->toString(getValue(), iPrecision);
  }

  std::unique_ptr<EditorType> edit() override
  {
    return std::make_unique<Editor>(fRawParameter->edit(), fConverter);
  }

  using ITGUIParameter<T>::edit;

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

  std::unique_ptr<FObjectCx> connect(Parameters::ChangeCallback iChangeCallback) const override
  {
    return fRawParameter->connect(std::move(iChangeCallback));
  }

  // asDiscreteParameter
  std::shared_ptr<GUIDiscreteParameter> asDiscreteParameter(int32 iStepCount) override
  {
    return fRawParameter->asDiscreteParameter(iStepCount);
  }

private:
  std::shared_ptr<GUIRawVstParameter> fRawParameter;
  std::shared_ptr<IParamConverter<T>> fConverter;
};

//------------------------------------------------------------------------
// GUIVstParam - wrapper to make writing the code much simpler and natural
//------------------------------------------------------------------------
template<typename T>
class GUIVstParam: public Utils::Operators::Dereferenceable<GUIVstParam<T>>
{
public:
  using ParamType = T;
  using EditorType = typename GUIVstParameter<T>::ITEditor;
  using Editor = std::unique_ptr<EditorType>;

public:
  class Value {
  public:
    constexpr T const *operator ->() const { return &fValue; }
    friend class GUIVstParam<T>;
  private:
    explicit Value(T const &iValue) : fValue{iValue} {}
    T fValue;
  };

public:
  // Constructor
  GUIVstParam(std::shared_ptr<GUIVstParameter<T>> iPtr = nullptr) : // NOLINT (not marked explicit on purpose)
    fPtr{std::move(iPtr)}
  {}

  GUIVstParam<T> &operator=(GUIVstParam<T> const &iOther) = default;

  // exists
  inline bool exists() const { return (bool) fPtr; }

  // getParamID
  inline ParamID getParamID() const { DCHECK_F(exists()); return fPtr->getParamID(); }

  inline T getValue() const { DCHECK_F(exists()); return fPtr->getValue(); }

  inline T value() const { DCHECK_F(exists()); return fPtr->getValue(); }

  inline ParamValue getNormalizedValue() const { DCHECK_F(exists()); return fPtr->getNormalizedValue(); }

  bool update(T const &iValue) { DCHECK_F(exists()); return fPtr->update(iValue); }

  tresult setValue(T const &iValue) { DCHECK_F(exists()); return fPtr->setValue(iValue); }

  tresult setNormalizedValue(ParamValue const &iNormalizedValue) { DCHECK_F(exists()); return fPtr->setNormalizedValue(iNormalizedValue); }

  inline tresult resetToDefault() { DCHECK_F(exists()); return fPtr->resetToDefault(); }

  template<typename V>
  tresult copyValueFrom(GUIVstParam<V> const &iParam) { DCHECK_F(exists()); return setNormalizedValue(iParam.getNormalizedValue()); }

  tresult copyValueFrom(GUIRawVstParam const &iParam) { DCHECK_F(exists()); return setNormalizedValue(iParam.getValue()); }

  inline int32 getStepCount() const { DCHECK_F(exists()); return fPtr->getStepCount(); }

  void toString(String128 oString) { DCHECK_F(exists()); fPtr->toString(oString); }

  Steinberg::String toString() { DCHECK_F(exists()); return fPtr->toString(); }

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

  Editor edit() { DCHECK_F(exists()); return fPtr->edit(); }

  Editor edit(T const &iValue) { DCHECK_F(exists()); return fPtr->edit(iValue); }

  constexpr T operator *() const { DCHECK_F(exists()); return fPtr->getValue(); }

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

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

  inline GUIVstParam<T> &operator=(T const &iValue) { DCHECK_F(exists()); fPtr->setValue(iValue); return *this; }

//  friend constexpr bool operator==(GUIVstParam<T> const &lhs, GUIVstParam<T> const &rhs) { return lhs.fPtr->getNormalizedValue() == rhs.fPtr->getNormalizedValue(); }

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

  inline std::unique_ptr<FObjectCx> connect(Parameters::ChangeCallback iChangeCallback) const { DCHECK_F(exists()); return fPtr->connect(std::move(iChangeCallback)); }

private:
  std::shared_ptr<GUIVstParameter<T>> fPtr;
};


//------------------------------------------------------------------------
// GUIRawVstParameter::asVstParameter
//------------------------------------------------------------------------
template<typename T>
std::shared_ptr<GUIVstParameter<T>> GUIRawVstParameter::asVstParameter()
{
  auto vstParamDef = std::dynamic_pointer_cast<VstParamDef<T>>(fParamDef);
  if(vstParamDef && vstParamDef->fConverter)
    return std::make_shared<GUIVstParameter<T>>(std::dynamic_pointer_cast<GUIRawVstParameter>(shared_from_this()),
                                                vstParamDef->fConverter);
  else
    return nullptr;
}

//------------------------------------------------------------------------
// shortcut notations
//------------------------------------------------------------------------
template<typename T>
using GUIVstParamEditor = std::unique_ptr<typename GUIVstParameter<T>::EditorType>;

using GUIVstBooleanParam = GUIVstParam<bool>;
using GUIVstPercentParam = GUIVstParam<Percent>;

}