ParamAware.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018-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 <vstgui/lib/cview.h>
 
#include <pongasoft/VST/Parameters.h>
 
#include <utility>
#include "GUIRawVstParameter.h"
#include "GUIJmbParameter.h"
#include "GUIVstParameter.h"
#include "GUIOptionalParam.h"
 
namespace pongasoft::VST::GUI {
 
class GUIState;
 
namespace Params {
 
class GUIParamCxMgr;

class ParamAware : public Parameters::IChangeListener
{
public:
  virtual ~ParamAware();
 
  //------------------------------------------------------------------------
  // Base Param
  //------------------------------------------------------------------------

  IGUIParam registerBaseParam(ParamID iParamID, bool iSubscribeToChanges = true);

  IGUIParam registerBaseCallback(ParamID iParamID,
                                 Parameters::ChangeCallback iChangeCallback,
                                 bool iInvokeCallback);

  IGUIParam registerBaseCallback(ParamID iParamID,
                                 Parameters::ChangeCallback1<IGUIParam> iChangeCallback,
                                 bool iInvokeCallback);
 
  //------------------------------------------------------------------------
  // Optional Param
  //------------------------------------------------------------------------

  template<typename T>
  GUIOptionalParam<T> registerOptionalParam(ParamID iParamID,
                                            bool iSubscribeToChanges = true);

  template<typename T>
  GUIOptionalParam<T> registerOptionalCallback(ParamID iParamID,
                                               Parameters::ChangeCallback iChangeCallback,
                                               bool iInvokeCallback = false);

  template<typename T>
  GUIOptionalParam<T> registerOptionalCallback(ParamID iParamID,
                                               Parameters::ChangeCallback1<GUIOptionalParam<T>> iChangeCallback,
                                               bool iInvokeCallback = false);
 
  //------------------------------------------------------------------------
  // Optional Discrete Param
  //------------------------------------------------------------------------

  GUIOptionalParam<int32> registerOptionalDiscreteParam(ParamID iParamID,
                                                        int32 iStepCount,
                                                        bool iSubscribeToChanges = true);

  GUIOptionalParam<int32> registerOptionalDiscreteCallback(ParamID iParamID,
                                                           int32 iStepCount,
                                                           Parameters::ChangeCallback iChangeCallback,
                                                           bool iInvokeCallback = false);

  GUIOptionalParam<int32> registerOptionalDiscreteCallback(ParamID iParamID,
                                                           int32 iStepCount,
                                                           Parameters::ChangeCallback1<GUIOptionalParam<int32>> iChangeCallback,
                                                           bool iInvokeCallback = false);
 
  //------------------------------------------------------------------------
  // Raw Vst Param / ParamID
  //------------------------------------------------------------------------

  GUIRawVstParam registerRawVstParam(ParamID iParamID, bool iSubscribeToChanges = true);

  GUIRawVstParam registerRawVstCallback(ParamID iParamID,
                                        Parameters::ChangeCallback iChangeCallback,
                                        bool iInvokeCallback = false);

  GUIRawVstParam registerRawVstCallback(ParamID iParamID,
                                        Parameters::ChangeCallback1<GUIRawVstParam> iChangeCallback,
                                        bool iInvokeCallback = false);
 
 
  //------------------------------------------------------------------------
  // Raw Vst Param / param definition (RawVstParam)
  //------------------------------------------------------------------------

  inline GUIRawVstParam registerParam(RawVstParam const &iParamDef, bool iSubscribeToChanges = true) {
    return registerRawVstParam(iParamDef->fParamID, iSubscribeToChanges);
  }

  inline GUIRawVstParam registerCallback(RawVstParam const &iParamDef,
                                         Parameters::ChangeCallback iChangeCallback,
                                         bool iInvokeCallback = false) {
    return registerRawVstCallback(iParamDef->fParamID, std::move(iChangeCallback), iInvokeCallback);
  }

  inline GUIRawVstParam registerCallback(RawVstParam const &iParamDef,
                                         Parameters::ChangeCallback1<GUIRawVstParam> iChangeCallback,
                                         bool iInvokeCallback = false) {
    return registerRawVstCallback(iParamDef->fParamID, std::move(iChangeCallback), iInvokeCallback);
  }
 
  //------------------------------------------------------------------------
  // Shortcut Vst Param bool/Percent
  //------------------------------------------------------------------------
 
  // shortcut for BooleanParameter (will be removed => not very useful)
  [[deprecated("Since 4.0.0 -  use registerVstParam<bool> directly")]]
  GUIVstParam<bool> registerVstBooleanParam(ParamID iParamID, bool iSubscribeToChanges = true);
 
  // shortcut for PercentParameter (will be removed => not very useful)
  [[deprecated("Since 4.0.0 -  use registerVstParam<Percent> directly")]]
  GUIVstParam<Percent> registerVstPercentParam(ParamID iParamID, bool iSubscribeToChanges = true);
 
  //------------------------------------------------------------------------
  // Vst Param (Typed) / ParamID
  //------------------------------------------------------------------------

  template<typename T>
  GUIVstParam<T> registerVstParam(ParamID iParamID, bool iSubscribeToChanges = true);

  template<typename T>
  GUIVstParam<T> registerVstCallback(ParamID iParamID,
                                     Parameters::ChangeCallback iChangeCallback,
                                     bool iInvokeCallback = false);

  template<typename T>
  GUIVstParam<T> registerVstCallback(ParamID iParamID,
                                     Parameters::ChangeCallback1<GUIVstParam<T>> iChangeCallback,
                                     bool iInvokeCallback = false);
 
  //------------------------------------------------------------------------
  // Vst Param (Typed) / param definition (VstParam<T>)
  //------------------------------------------------------------------------

  template<typename T>
  inline GUIVstParam<T> registerParam(VstParam<T> const &iParamDef, bool iSubscribeToChanges = true) {
    return registerVstParam<T>(iParamDef->fParamID, iSubscribeToChanges);
  }

  template<typename T>
  inline GUIVstParam<T> registerCallback(VstParam<T> const &iParamDef,
                                         Parameters::ChangeCallback iChangeCallback,
                                         bool iInvokeCallback = false) {
    return registerVstCallback<T>(iParamDef->fParamID, std::move(iChangeCallback), iInvokeCallback);
  }

  template<typename T>
  inline GUIVstParam<T> registerCallback(VstParam<T> const &iParamDef,
                                         Parameters::ChangeCallback1<GUIVstParam<T>> iChangeCallback,
                                         bool iInvokeCallback = false) {
    return registerVstCallback<T>(iParamDef->fParamID, std::move(iChangeCallback), iInvokeCallback);
  }
 
  //------------------------------------------------------------------------
  // Jmb Param (Typed) / ParamID
  //------------------------------------------------------------------------

  template<typename T>
  GUIJmbParam<T> registerJmbParam(ParamID iParamID, bool iSubscribeToChanges = true);

  template<typename T>
  GUIJmbParam<T> registerJmbCallback(ParamID iParamID,
                                     Parameters::ChangeCallback iChangeCallback,
                                     bool iInvokeCallback = false);

  template<typename T>
  GUIJmbParam<T> registerJmbCallback(ParamID iParamID,
                                     Parameters::ChangeCallback1<GUIJmbParam<T>> iChangeCallback,
                                     bool iInvokeCallback = false);
 
  //------------------------------------------------------------------------
  // Jmb Param (Typed) / Param definition (JmbParam<T>)
  //------------------------------------------------------------------------

  template<typename T>
  inline GUIJmbParam<T> registerParam(JmbParam<T> const &iParamDef, bool iSubscribeToChanges = true) {
    return registerJmbParam<T>(iParamDef->fParamID, iSubscribeToChanges);
  }

  template<typename T>
  inline GUIJmbParam<T> registerCallback(JmbParam<T> const &iParamDef,
                                         Parameters::ChangeCallback iChangeCallback,
                                         bool iInvokeCallback = false) {
    return registerJmbCallback<T>(iParamDef->fParamID, std::move(iChangeCallback), iInvokeCallback);
 
  }

  template<typename T>
  inline GUIJmbParam<T> registerCallback(JmbParam<T> const &iParamDef,
                                         Parameters::ChangeCallback1<GUIJmbParam<T>> iChangeCallback,
                                         bool iInvokeCallback = false) {
    return registerJmbCallback<T>(iParamDef->fParamID, std::move(iChangeCallback), iInvokeCallback);
  }
 
  //------------------------------------------------------------------------
  // Jmb Param (Typed) / Param (GUIJmbParam<T>)
  //------------------------------------------------------------------------

  template<typename T>
  inline GUIJmbParam<T> registerParam(GUIJmbParam<T> &iParam, bool iSubscribeToChanges = true) {
    return registerJmbParam<T>(iParam.getParamID(), iSubscribeToChanges);
  }

  template<typename T>
  inline GUIJmbParam<T> registerCallback(GUIJmbParam<T> &iParam,
                                         Parameters::ChangeCallback iChangeCallback,
                                         bool iInvokeCallback = false) {
    return registerJmbCallback<T>(iParam.getParamID(), std::move(iChangeCallback), iInvokeCallback);
  }

  template<typename T>
  inline GUIJmbParam<T> registerCallback(GUIJmbParam<T> &iParam,
                                         Parameters::ChangeCallback1<GUIJmbParam<T>> iChangeCallback,
                                         bool iInvokeCallback = false) {
    return registerJmbCallback<T>(iParam.getParamID(), std::move(iChangeCallback), iInvokeCallback);
  }

  virtual void initState(GUIState *iGUIState);

  virtual void registerParameters()
  {
    // subclasses implements this method
  }

  void unregisterAll();

   [[deprecated("Since 4.0.0 - If you need this kind of granularity, maintain your own connections")]]
  bool unregisterParam(ParamID iParamID) { return false; }

  [[deprecated("Since 4.0.0 - If you need this kind of granularity, maintain your own connections")]]
  GUIRawVstParam unregisterParam(GUIRawVstParam const &iParam) { return iParam; }

  template<typename T>
  [[deprecated("Since 4.0.0 - If you need this kind of granularity, maintain your own connections")]]
  GUIVstParam<T> unregisterParam(GUIVstParam<T> const &iParam) { return iParam; }

  template<typename T>
  [[deprecated("Since 4.0.0 - If you need this kind of granularity, maintain your own connections")]]
  GUIJmbParam<T> unregisterParam(GUIJmbParam<T> const &iParam) { return iParam; }

  void onParameterChange(ParamID iParamID) override {}

  void invokeAll();
 
protected:
  // Access to parameters
  std::unique_ptr<GUIParamCxMgr> fParamCxMgr{};
};

template<typename TView>
class ParamAwareView : public ParamAware
{
  // ensures that TView is a subclass of CView
  static_assert(std::is_convertible<TView *, VSTGUI::CView*>::value, "TView must be a subclass of CView");
 
public:
  // required because we implement other registerCallback methods
  using ParamAware::registerCallback;
 
  // defining the change listener callback
  using ChangeListener = std::function<void(TView *, ParamID)>;
 
  // Constructor
  explicit ParamAwareView(TView *iView) : fView(iView), fListener{} {}

  void registerListener(ChangeListener iListener)
  {
    fListener = std::move(iListener);
  }

  template<typename T>
  inline GUIVstParam<T> registerCallback(VstParam<T> const &iParamDef,
                                         Parameters::ChangeCallback2<TView, GUIVstParam<T>> iChangeCallback,
                                         bool iInvokeCallback = false)
  {
    auto callback = [view = this->fView, cb2 = std::move(iChangeCallback)] (GUIVstParam<T> &iParam) {
      cb2(view, iParam);
    };
 
    return ParamAware::registerCallback<T>(iParamDef, std::move(callback), iInvokeCallback);
  }

  template<typename T>
  inline GUIJmbParam<T> registerCallback(GUIJmbParam<T> &iParam,
                                         Parameters::ChangeCallback2<TView, GUIJmbParam<T>> iChangeCallback,
                                         bool iInvokeCallback = false)
  {
    auto callback = [view = this->fView, cb2 = std::move(iChangeCallback)] (GUIJmbParam<T> &iParam) {
      cb2(view, iParam);
    };
 
    return ParamAware::registerCallback<T>(iParam, std::move(callback), iInvokeCallback);
  }

  void onParameterChange(ParamID iParamID) override
  {
    if(fListener)
      fListener(fView, iParamID);
  }
 
protected:
  TView *fView;
  ChangeListener fListener;
};
 
}
}