GUIParamCxMgr.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 <pongasoft/VST/GUI/GUIState.h>
#include <vector>
 
namespace pongasoft::VST::GUI::Params {

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

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

  void unregisterAll();
 
  //------------------------------------------------------------------------
  // Base Param
  //------------------------------------------------------------------------
 
  // registerBaseParam / ParamID / IChangeListener
  IGUIParam registerBaseParam(ParamID iParamID, Parameters::IChangeListener *iChangeListener = nullptr);
 
  // registerBaseCallback / ParamID / ChangeCallback
  inline IGUIParam registerBaseCallback(ParamID iParamID,
                                        Parameters::ChangeCallback iChangeCallback,
                                        bool iInvokeCallback)
  {
    return __registerCallback(registerBaseParam(iParamID), std::move(iChangeCallback), iInvokeCallback);
  }
 
  // registerBaseCallback / ParamID / ChangeCallback1<IGUIParam>
  inline IGUIParam registerBaseCallback(ParamID iParamID,
                                        Parameters::ChangeCallback1<IGUIParam> iChangeCallback,
                                        bool iInvokeCallback)
  {
    return __registerCallback1(registerBaseParam(iParamID), std::move(iChangeCallback), iInvokeCallback);
  }
 
  //------------------------------------------------------------------------
  // Optional Param
  //------------------------------------------------------------------------
 
  // registerOptionalParam / ParamID / IChangeListener
  template<typename T>
  GUIOptionalParam<T> registerOptionalParam(ParamID iParamID,
                                            Parameters::IChangeListener *iChangeListener = nullptr);
 
  // registerOptionalCallback / ParamID / ChangeCallback
  template<typename T>
  inline GUIOptionalParam<T> registerOptionalCallback(ParamID iParamID,
                                                      Parameters::ChangeCallback iChangeCallback,
                                                      bool iInvokeCallback) {
    return __registerCallback(registerOptionalParam<T>(iParamID), std::move(iChangeCallback), iInvokeCallback);
  }
 
  // registerOptionalCallback / ParamID / ChangeCallback1<GUIOptionalParam<T>>
  template<typename T>
  inline GUIOptionalParam<T> registerOptionalCallback(ParamID iParamID,
                                                      Parameters::ChangeCallback1<GUIOptionalParam<T>> iChangeCallback,
                                                      bool iInvokeCallback) {
    return __registerCallback1(registerOptionalParam<T>(iParamID), std::move(iChangeCallback), iInvokeCallback);
  }
 
  //------------------------------------------------------------------------
  // Optional Discrete Param
  //------------------------------------------------------------------------
 
  // registerOptionalDiscreteParam / ParamID / IChangeListener
  GUIOptionalParam<int32> registerOptionalDiscreteParam(ParamID iParamID,
                                                        int32 iStepCount,
                                                        Parameters::IChangeListener *iChangeListener = nullptr);
 
  // registerOptionalDiscreteCallback / ParamID / ChangeCallback
  inline GUIOptionalParam<int32> registerOptionalDiscreteCallback(ParamID iParamID,
                                                                  int32 iStepCount,
                                                                  Parameters::ChangeCallback iChangeCallback,
                                                                  bool iInvokeCallback) {
    return __registerCallback(registerOptionalDiscreteParam(iParamID, iStepCount), std::move(iChangeCallback), iInvokeCallback);
  }
 
  // registerOptionalDiscreteCallback / ParamID / ChangeCallback1<GUIOptionalParam<int32>>
  inline GUIOptionalParam<int32> registerOptionalDiscreteCallback(ParamID iParamID,
                                                                  int32 iStepCount,
                                                                  Parameters::ChangeCallback1<GUIOptionalParam<int32>> iChangeCallback,
                                                                  bool iInvokeCallback) {
    return __registerCallback1(registerOptionalDiscreteParam(iParamID, iStepCount), std::move(iChangeCallback), iInvokeCallback);
  }
 
  //------------------------------------------------------------------------
  // Raw Vst Param
  //------------------------------------------------------------------------
 
   // registerRawVstParam / ParamID / IChangeListener
  GUIRawVstParam registerRawVstParam(ParamID iParamID,
                                     Parameters::IChangeListener *iChangeListener = nullptr);
 
  // registerRawVstCallback / ParamID / ChangeCallback
  inline GUIRawVstParam registerRawVstCallback(ParamID iParamID,
                                               Parameters::ChangeCallback iChangeCallback,
                                               bool iInvokeCallback)
  {
    return __registerCallback(registerRawVstParam(iParamID), std::move(iChangeCallback), iInvokeCallback);
  }
 
  // registerRawVstCallback / ParamID / ChangeCallback1<GUIRawVstParam>
  inline GUIRawVstParam registerRawVstCallback(ParamID iParamID,
                                               Parameters::ChangeCallback1<GUIRawVstParam> iChangeCallback,
                                               bool iInvokeCallback)
  {
    return __registerCallback1(registerRawVstParam(iParamID), std::move(iChangeCallback), iInvokeCallback);
  }
 
  //------------------------------------------------------------------------
  // Vst Param (Typed)
  //------------------------------------------------------------------------
 
  // registerVstParam / ParamID / IChangeListener
  template<typename T>
  GUIVstParam<T> registerVstParam(ParamID iParamID,
                                  Parameters::IChangeListener *iChangeListener = nullptr);
 
  // registerVstParam / ParamID / ChangeCallback
  template<typename T>
  inline GUIVstParam<T> registerVstCallback(ParamID iParamID,
                                            Parameters::ChangeCallback iChangeCallback,
                                            bool iInvokeCallback)
  {
    return __registerCallback(registerVstParam<T>(iParamID), std::move(iChangeCallback), iInvokeCallback);
  }
 
  // registerVstParam / ParamID / ChangeCallback1<GUIVstParam<T>>
  template<typename T>
  inline GUIVstParam<T> registerVstCallback(ParamID iParamID,
                                            Parameters::ChangeCallback1<GUIVstParam<T>> iChangeCallback,
                                            bool iInvokeCallback)
  {
    return __registerCallback1(registerVstParam<T>(iParamID), std::move(iChangeCallback), iInvokeCallback);
  }
 
  //------------------------------------------------------------------------
  // Jmb Param (Typed)
  //------------------------------------------------------------------------
 
  // registerJmbParam / ParamID / IChangeListener
  template<typename T>
  GUIJmbParam<T> registerJmbParam(ParamID iParamID,
                                  Parameters::IChangeListener *iChangeListener = nullptr);
 
  // registerJmbParam / ParamID / ChangeCallback
  template<typename T>
  inline GUIJmbParam<T> registerJmbCallback(ParamID iParamID,
                                            Parameters::ChangeCallback iChangeCallback,
                                            bool iInvokeCallback)
  {
    return __registerCallback(registerJmbParam<T>(iParamID), std::move(iChangeCallback), iInvokeCallback);
  }
 
  // registerJmbParam / ParamID / ChangeCallback1<GUIJmbParam<T>>
  template<typename T>
  inline GUIJmbParam<T> registerJmbCallback(ParamID iParamID,
                                            Parameters::ChangeCallback1<GUIJmbParam<T>> iChangeCallback,
                                            bool iInvokeCallback)
  {
    return __registerCallback1(registerJmbParam<T>(iParamID), std::move(iChangeCallback), iInvokeCallback);
  }
 
  // getGUIState
  inline GUIState *getGUIState() const { return fGUIState; };

  void invokeAll();
 
  friend class GUI::GUIState;
 
protected:
  explicit GUIParamCxMgr(GUIState *iGUIState) : fGUIState{iGUIState}
  {
    DCHECK_F(fGUIState != nullptr);
  }
 
  template<typename TParam>
  inline TParam __registerListener(TParam iParam, Parameters::IChangeListener *iChangeListener)
  {
    if(iParam.exists() && iChangeListener)
      fParamCxs.emplace_back(iParam.connect(iChangeListener));
    return iParam;
  }
 
  template<typename TParam>
  TParam __registerCallback(TParam iParam, Parameters::ChangeCallback iCallback, bool iInvokeCallback);
 
  template<typename TParam>
  TParam __registerCallback1(TParam iParam, Parameters::ChangeCallback1<TParam> iCallback, bool iInvokeCallback);
 
private:
  // the gui state
  GUIState *fGUIState;
 
  // Maintains the connections for the listeners and callbacks... will be automatically discarded in the destructor
  std::vector<std::unique_ptr<FObjectCx>> fParamCxs{};
};
 
}
 
// Include template implementation code
#include "GUIParamCxMgr.hpp"