GUIVstParameter.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018 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
 */
#ifndef __PONGASOFT_VST_GUI_PARAMETER_H__
#define __PONGASOFT_VST_GUI_PARAMETER_H__

#include "GUIRawVstParameter.h"
#include <pongasoft/VST/ParamConverters.h>
#include <pongasoft/VST/ParamDef.h>

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

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

public:
  class Editor
  {
  public:
    inline explicit Editor(std::unique_ptr<GUIRawVstParameter::Editor> iRawEditor,
                           std::shared_ptr<VstParamDef<T>> iVstParamDef) :
      fRawEditor{std::move(iRawEditor)},
      fVstParamDef{std::move(iVstParamDef)}
    {
    }

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

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

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

    /*
     * Shortcut to set the value prior to commit
     * Call when you are done with the modifications.
     * This has no effect if rollback() has already been called
     */
    inline tresult commit(ParamType const &iValue)
    {
      setValue(iValue);
      return commit();
    }

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

  private:
    std::unique_ptr<GUIRawVstParameter::Editor> fRawEditor;
    std::shared_ptr<VstParamDef<T>> fVstParamDef;
  };

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

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

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

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

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

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

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

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

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

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

  std::unique_ptr<Editor> edit(ParamType iValue)
  {
    auto editor = edit();
    editor->setValue(iValue);
    return editor;
  }

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

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

private:
  std::shared_ptr<GUIRawVstParameter> fRawParameter;
  std::shared_ptr<VstParamDef<T>> fVstParamDef;
};

//------------------------------------------------------------------------
// GUIVstParam - wrapper to make writing the code much simpler and natural
//------------------------------------------------------------------------
template<typename T>
class GUIVstParam
{
public:
  GUIVstParam() : fPtr{nullptr} {}

  // move constructor
  explicit GUIVstParam(std::unique_ptr<GUIVstParameter<T>> &&iPtr) : fPtr{std::move(iPtr)} {}

  // delete copy constructor
  GUIVstParam(GUIVstParam<T> &iPtr) = delete;

  // move copy constructor
  GUIVstParam(GUIVstParam<T> &&iPtr) noexcept : fPtr{std::move(iPtr.fPtr)} {}

  // move assignment constructor
  GUIVstParam<T> &operator=(GUIVstParam<T> &&iPtr) noexcept { fPtr = std::move(iPtr.fPtr); return *this; }

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

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

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

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

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

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

  tresult copyValueFrom(GUIVstParam<T> const &iParam) { return setNormalizedValue(iParam.getNormalizedValue()); }

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

  String toString() { return fPtr->toString(); }

  std::unique_ptr<typename GUIVstParameter<T>::Editor> edit() { return fPtr->edit(); }

  std::unique_ptr<typename GUIVstParameter<T>::Editor> edit(T const &iValue) { return fPtr->edit(iValue); }

  // allow to use the param as the underlying ParamType (ex: "if(param)" in the case ParamType is bool))
  inline operator T() const { return fPtr->getValue(); } // NOLINT

  // allow to write param = 3 instead of param.setValue(3)
  inline void operator=(T const &iValue) { fPtr->setValue(iValue); }

  // allow to write param1 == param2
  inline bool operator==(const GUIVstParam<T> &rhs) const { return fPtr->getNormalizedValue() == rhs.fPtr->getNormalizedValue(); }

  // allow to write param1 != param2
  inline bool operator!=(const GUIVstParam &rhs) const { return fPtr->getNormalizedValue() != rhs.fPtr->getNormalizedValue(); }

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

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

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

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

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

}
}
}
}

#endif // __PONGASOFT_VST_GUI_PARAMETER_H__