GUIParamCxMgr.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_PARAM_CX_MGR_H__
#define __PONGASOFT_VST_GUI_PARAM_CX_MGR_H__

#include <pongasoft/VST/GUI/GUIState.h>
#include <unordered_map>

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

class GUIParamCxMgr
{
public:
  inline bool existsVst(ParamID iParamID) const { return fGUIState->existsVst(iParamID); }

  inline bool existsJmb(ParamID iParamID) const { return fGUIState->existsJmb(iParamID); }

  bool unregisterParam(ParamID iParamID);

  void unregisterAll();

  inline GUIRawVstParam registerRawVstParam(ParamID iParamID,
                                            Parameters::IChangeListener *iChangeListener = nullptr)
  {
    return __registerRawVstParam(iParamID, iChangeListener);
  }

  inline GUIRawVstParam registerRawVstCallback(ParamID iParamID,
                                               Parameters::ChangeCallback iChangeCallback,
                                               bool iInvokeCallback)
  {
    return maybeInvokeCallback(__registerRawVstParam(iParamID, iChangeCallback),
                               iChangeCallback,
                               iInvokeCallback);
  }

  template<typename T>
  inline GUIVstParam<T> registerVstParam(ParamID iParamID,
                                         Parameters::IChangeListener *iChangeListener = nullptr)
  {
    return __registerVstParam<T>(iParamID, iChangeListener);
  }

  template<typename T>
  inline GUIVstParam<T> registerVstCallback(ParamID iParamID,
                                            Parameters::ChangeCallback iChangeCallback,
                                            bool iInvokeCallback)
  {
    return maybeInvokeCallback(__registerVstParam<T>(iParamID, iChangeCallback),
                               iChangeCallback,
                               iInvokeCallback);
  }

  template<typename T>
  inline GUIVstParam<T> registerVstParam(VstParam<T> const &iParamDef,
                                         Parameters::IChangeListener *iChangeListener = nullptr)
  {
    return __registerVstParam(iParamDef, iChangeListener);
  }

  template<typename T>
  inline GUIVstParam<T> registerVstCallback(VstParam<T> const &iParamDef,
                                            Parameters::ChangeCallback iChangeCallback,
                                            bool iInvokeCallback)
  {
    return maybeInvokeCallback(__registerVstParam(iParamDef, iChangeCallback),
                               iChangeCallback,
                               iInvokeCallback);
  }

  template<typename T>
  bool registerVstCallback(VstParam<T> iParamDef,
                           Parameters::ChangeCallback1<GUIVstParam<T>> iChangeCallback,
                           bool iInvokeCallback);

  template<typename T>
  GUIJmbParam<T> registerJmbParam(GUIJmbParam<T> &iParamDef, Parameters::IChangeListener *iChangeListener)
  {
    DCHECK_F(iChangeListener != nullptr);
    fParamCxs[iParamDef.getParamID()] = std::move(iParamDef.connect(iChangeListener));
    return iParamDef;
  }

  template<typename T>
  GUIJmbParam<T> registerJmbCallback(GUIJmbParam<T> &iParamDef,
                                     Parameters::ChangeCallback iChangeCallback,
                                     bool iInvokeCallback)
  {
    DCHECK_F((bool) iChangeCallback);
    fParamCxs[iParamDef.getParamID()] = std::move(iParamDef.connect(iChangeCallback));
    if(iInvokeCallback)
      iChangeCallback();
    return iParamDef;
  }

  template<typename T>
  void registerJmbCallback(GUIJmbParam<T> &iParamDef,
                           Parameters::ChangeCallback1<GUIJmbParam<T>> iChangeCallback,
                           bool iInvokeCallback)
  {
    DCHECK_F((bool) iChangeCallback);
    auto callback = [&iParamDef, cb2 = std::move(iChangeCallback)] () { cb2(iParamDef); };
    registerJmbCallback(iParamDef, callback, iInvokeCallback);
  }


  template<typename T>
  GUIJmbParam<T> registerJmbParam(ParamID iParamID,
                                  Parameters::IChangeListener *iChangeListener = nullptr)
  {
    return __registerJmbParam<T>(iParamID, iChangeListener);
  }

  template<typename T>
  GUIJmbParam<T> registerJmbCallback(ParamID iParamID,
                                     Parameters::ChangeCallback iChangeCallback,
                                     bool iInvokeCallback)
  {
    return maybeInvokeCallback(__registerJmbParam<T>(iParamID, iChangeCallback),
                               iChangeCallback,
                               iInvokeCallback);
  }

  // getGUIState
  GUIState *getGUIState() const { return fGUIState; };

  void invokeAll();

  friend class GUI::GUIState;

protected:
  explicit GUIParamCxMgr(GUIState *iGUIState) : fGUIState{iGUIState}
  {
    DCHECK_F(fGUIState != nullptr);
  }

  template<typename Listener>
  std::unique_ptr<GUIRawVstParameter> __registerRawVstParameter(ParamID iParamID, Listener iListener);

  // __registerRawVstParam
  template<typename Listener>
  GUIRawVstParam __registerRawVstParam(ParamID iParamID, Listener iListener);

  // __registerVstParam
  template<typename T, typename Listener>
  GUIVstParam<T> __registerVstParam(ParamID iParamID, Listener iListener);

  // __registerVstParam
  template<typename T, typename Listener>
  GUIVstParam<T> __registerVstParam(VstParam<T> const &iParamDef, Listener iListener);

  // __registerJmbParam
  template<typename T, typename Listener>
  GUIJmbParam<T> __registerJmbParam(ParamID iParamID, Listener iListener);

  // maybeInvokeCallback
  template<typename TParam>
  inline TParam &&maybeInvokeCallback(TParam &&iParam, Parameters::ChangeCallback &iCallback, bool iInvokeCallback)
  {
    if(iInvokeCallback && iParam.exists() && iCallback)
     iCallback();
    return std::forward<TParam>(iParam);
  }

private:
  // the gui state
  GUIState *fGUIState;

  // Maintains the connections for the listeners... will be automatically discarded in the destructor
  std::unordered_map<ParamID, std::unique_ptr<FObjectCx>> fParamCxs;
};

//------------------------------------------------------------------------
// GUIParamCxMgr::__registerRawVstParameter
//------------------------------------------------------------------------
template<typename Listener>
std::unique_ptr<GUIRawVstParameter> GUIParamCxMgr::__registerRawVstParameter(ParamID iParamID, Listener iListener)
{
  auto param = fGUIState->getRawVstParameter(iParamID);

  if(!param)
  {
    DLOG_F(WARNING, "vst param [%d] not found", iParamID);
    return nullptr;
  }

  if(iListener)
  {
    fParamCxs[iParamID] = param->connect(iListener);
  }
  else
  {
    unregisterParam(iParamID);
  }

  return param;
}

//------------------------------------------------------------------------
// GUIParamCxMgr::__registerRawVstParam
//------------------------------------------------------------------------
template<typename Listener>
GUIRawVstParam GUIParamCxMgr::__registerRawVstParam(ParamID iParamID, Listener iListener)
{
  auto param = __registerRawVstParameter(iParamID, iListener);

  if(!param)
  {
    return GUIRawVstParam{};
  }

  return GUIRawVstParam{std::move(param)};
}


//------------------------------------------------------------------------
// GUIParamCxMgr::__registerVstParam
//------------------------------------------------------------------------
template<typename T, typename Listener>
GUIVstParam<T> GUIParamCxMgr::__registerVstParam(VstParam<T> const &iParamDef, Listener iListener)
{
  auto param = __registerRawVstParameter(iParamDef->fParamID, iListener);

  if(param)
    return GUIVstParam<T>{std::make_unique<GUIVstParameter<T>>(std::move(param), iParamDef)};
  else
    return GUIVstParam<T>{};
}

//------------------------------------------------------------------------
// GUIParamCxMgr::__registerVstParam
//------------------------------------------------------------------------
template<typename T, typename Listener>
GUIVstParam<T> GUIParamCxMgr::__registerVstParam(ParamID iParamID, Listener iListener)
{
  if(iListener)
  {
    auto param = fGUIState->getGUIVstParameter<T>(iParamID);

    if(param)
    {
      fParamCxs[iParamID] = param->connect(iListener);
      return GUIVstParam<T>{std::move(param)};
    }
  }

  unregisterParam(iParamID);
  return GUIVstParam<T>{};
}

//------------------------------------------------------------------------
// GUIParamCxMgr::__registerJmbParam
//------------------------------------------------------------------------
template<typename T, typename Listener>
GUIJmbParam<T> GUIParamCxMgr::__registerJmbParam(ParamID iParamID, Listener iListener)
{
  auto param = fGUIState->getJmbParameter(iParamID);

  if(!param)
  {
    DLOG_F(WARNING, "jmb param [%d] not found", iParamID);
    return nullptr;
  }

  auto res = dynamic_cast<GUIJmbParameter<T> *>(param);
  if(res)
  {
    if(iListener)
      fParamCxs[iParamID] = std::move(res->connect(iListener));
    else
      unregisterParam(iParamID);
  }
  else
  {
    DLOG_F(WARNING, "jmb param [%d] is not of the requested type", iParamID);
    unregisterParam(iParamID);
  }

  return res;
}

//------------------------------------------------------------------------
// GUIParamCxMgr::registerVstCallback
//------------------------------------------------------------------------
template<typename T>
bool GUIParamCxMgr::registerVstCallback(VstParam<T> iParamDef,
                                        Parameters::ChangeCallback1<GUIVstParam<T>> iChangeCallback,
                                        bool iInvokeCallback)
{
  auto paramID = iParamDef->fParamID;

  if(iChangeCallback)
  {
    auto param = fGUIState->getGUIVstParameter<T>(paramID);

    if(param)
    {
      // Implementation note:
      // 1) using std::make_unique results in an error on std::move(callback) because unique_ptr
      // cannot be copied...
      // 2) we need to access the ptr afterwards to call connect
      auto ptr = std::make_shared<GUIVstParam<T>>(std::move(param));

      auto callback = [ptr, cb1 = std::move(iChangeCallback)] () {
        cb1(*ptr);
      };

      fParamCxs[paramID] = ptr->connect(callback);

      if(iInvokeCallback)
        callback();

      return true;
    }
  }

  unregisterParam(paramID);
  return false;
}

}
}
}
}

#endif //__PONGASOFT_VST_GUI_PARAM_CX_MGR_H__