ParamAware.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018-2019 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 <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;
};

}
}