GUIParamCxAware.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 <pongasoft/VST/Parameters.h>
#include "GUIRawVstParameter.h"
#include "GUIJmbParameter.h"
#include "GUIVstParameter.h"

namespace pongasoft {
namespace VST {
namespace GUI {

class GUIState;

namespace Params {

class GUIParamCxMgr;

class GUIParamCxAware : public Parameters::IChangeListener
{
public:
  virtual ~GUIParamCxAware();

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

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

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

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

  bool __internal__registerRawVstControl(int32_t iParamID, ParamValue &oControlValue, GUIRawVstParam &oGUIRawVstParam);

  // shortcut for BooleanParameter
  GUIVstParam<bool> registerVstBooleanParam(ParamID iParamID, bool iSubscribeToChanges = true);

  // shortcut for PercentParameter
  GUIVstParam<Percent> registerVstPercentParam(ParamID iParamID, bool iSubscribeToChanges = true);

  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>
  bool __internal__registerVstControl(int32_t iParamID, T &oControlValue, GUIVstParam<T> &oParam);

  bool __internal__registerVstControl(int32_t iParamID, ParamValue &oControlValue, GUIRawVstParam &oParam);

  template<typename T>
  GUIVstParam<T> registerParam(VstParam<T> const &iParamDef, bool iSubscribeToChanges = true);

  template<typename T>
  GUIVstParam<T> registerCallback(VstParam<T> const &iParamDef,
                                  Parameters::ChangeCallback iChangeCallback,
                                  bool iInvokeCallback = false);

  template<typename T>
  bool registerCallback(VstParam<T> const &iParamDef,
                        Parameters::ChangeCallback1<GUIVstParam<T>> iChangeCallback,
                        bool iInvokeCallback = false);

  template<typename T>
  GUIJmbParam<T> registerParam(GUIJmbParam<T> &iParamDef);

  template<typename T>
  GUIJmbParam<T> registerCallback(GUIJmbParam<T> &iParamDef,
                                  Parameters::ChangeCallback iChangeCallback,
                                  bool iInvokeCallback = false);

  template<typename T>
  bool registerCallback(GUIJmbParam<T> &iParamDef,
                        Parameters::ChangeCallback1<GUIJmbParam<T>> iChangeCallback,
                        bool iInvokeCallback = false);

  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);

  virtual void initState(GUIState *iGUIState);

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

  void unregisterAll();

  bool unregisterParam(ParamID iParamID);

  GUIRawVstParam unregisterParam(GUIRawVstParam const &iParam);

  template<typename T>
  GUIVstParam<T> unregisterParam(GUIVstParam<T> const &iParam);

  template<typename T>
  GUIJmbParam<T> unregisterParam(GUIJmbParam<T> const &iParam);

  void onParameterChange(ParamID iParamID) override {}

  void invokeAll();

protected:
  // Access to parameters
  std::unique_ptr<GUIParamCxMgr> fParamCxMgr{};
};

template<typename TView>
class ViewGUIParamCxAware : public GUIParamCxAware
{
public:
  // required because we implement other registerCallback methods
  using GUIParamCxAware::registerCallback;

  // defining the change listener callback
  using ChangeListener = std::function<void(TView *, ParamID)>;

  // Constructor
  explicit ViewGUIParamCxAware(TView *iView) : fView(iView), fListener{} {}

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

  template<typename T>
  inline bool 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 GUIParamCxAware::registerCallback<T>(iParamDef, std::move(callback), iInvokeCallback);
  }

  template<typename T>
  inline bool 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 GUIParamCxAware::registerCallback<T>(iParam, std::move(callback), iInvokeCallback);
  }

  // onParameterChange => delegate to listener
  void onParameterChange(ParamID iParamID) override
  {
    if(fListener)
      fListener(fView, iParamID);
  }

protected:
  TView *fView;
  ChangeListener fListener;
};

}
}
}
}