GUIState.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018-2020 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/Parameters.h>
#include "pongasoft/VST/MessageHandler.h"
#include <pongasoft/VST/GUI/Params/VstParameters.h>
#include <pongasoft/VST/GUI/Params/GUIVstParameter.h>
#include <pongasoft/VST/GUI/Params/IGUIParameter.hpp> // IDE flagged as non used. Ignore! Do not remove!
#include <pongasoft/VST/GUI/Params/GUIJmbParameter.h>
#include <pongasoft/VST/MessageProducer.h>
#include <pongasoft/VST/GUI/Concepts.h>
#include "ParamAwareViews.h"
#include "IDialogHandler.h"
#include "TransportControlHandler.h"
 
namespace pongasoft::VST {
 
namespace Debug { class ParamDisplay; }
namespace GUI {
 
using namespace Params;
 
namespace Params {
class GUIParamCxMgr;
}
 
class GUIState : public IMessageProducer, public IDialogHandler
{
public:
  // Constructor
  explicit GUIState(Parameters const &iPluginParameters);

  virtual tresult init(VstParametersSPtr iVstParameters,
                       IMessageProducer *iMessageProducer,
                       IDialogHandler *iDialogHandler,
                       ITransportControl *iTransportControl);
 
  // getPluginParameters
  Parameters const &getPluginParameters() const { return fPluginParameters; }

  template<typename T>
  GUIJmbParam<T> add(JmbParam<T> iParamDef);

  bool existsVst(ParamID iParamID) const { return fVstParameters && fVstParameters->exists(iParamID); }

  bool existsJmb(ParamID iParamID) const { return fJmbParams.contains(iParamID)
                                                  ||
                                                  fPluginParameters.getJmbParamDef(iParamID) != nullptr; }

  std::shared_ptr<IGUIParameter> findParam(ParamID iParamID) const;

  std::shared_ptr<GUIRawVstParameter> getRawVstParameter(ParamID iParamID) const
  {
    if(existsVst(iParamID))
      return std::make_shared<GUIRawVstParameter>(iParamID,
                                                  fVstParameters,
                                                  fPluginParameters.getRawVstParamDef(iParamID));
    else
      return nullptr;
  }
 
  // getRawVstParamDef
  std::shared_ptr<RawVstParamDef> getRawVstParamDef(ParamID iParamID) const
  {
    return fPluginParameters.getRawVstParamDef(iParamID);
  }
 
  // getGUIVstParameter
  template<typename T>
  std::shared_ptr<GUIVstParameter<T>> getGUIVstParameter(ParamID iParamID) const;
 
  // getGUIVstParameter
  template<typename T>
  std::shared_ptr<GUIVstParameter<T>> getGUIVstParameter(VstParam<T> iParamDef) const {
    return iParamDef ? getGUIVstParameter<T>(iParamDef->fParamID) : nullptr;
  }

  std::unique_ptr<FObjectCx> connect(ParamID iParamID, Parameters::IChangeListener *iChangeListener) const
  {
    auto ptr = findParam(iParamID);
    if(ptr)
      return ptr->connect(iChangeListener);
    else
      return nullptr;
  }

  std::unique_ptr<FObjectCx> connect(ParamID iParamID, Parameters::ChangeCallback iChangeCallback) const
  {
    auto ptr = findParam(iParamID);
    if(ptr)
      return ptr->connect(iChangeCallback);
    else
      return nullptr;
  }

  template<CViewSubclass TView>
  ParamAwareView<TView> *makeParamAware(TView *iView) {
    return fParamAwareViews.makeParamAware(iView, this);
  }

  std::shared_ptr<IGUIJmbParameter> getJmbParameter(ParamID iParamID) const;

  virtual tresult readRTState(IBStreamer &iStreamer);

  virtual tresult readGUIState(IBStreamer &iStreamer);

  virtual tresult writeGUIState(IBStreamer &oStreamer) const;

  std::unique_ptr<GUIParamCxMgr> createParamCxMgr();

  tresult handleMessage(Message const &iMessage) { return fMessageHandler.handleMessage(iMessage); }

  template<typename T>
  tresult broadcast(JmbParam<T> const &iParamDef, T const &iMessage);
 
  // getAllRegistrationOrder
  std::vector<ParamID> const &getAllRegistrationOrder() const { return fAllRegistrationOrder; }

  virtual tresult handleGUIStateUpgrade(int16 iDeprecatedVersion, int16 iVersion) const { return kResultTrue; }

  bool showDialog(std::string iTemplateName) override;

  bool dismissDialog() override;

  ITransportControl *findTransportControl() const { return fTransportControl; }

  TransportControlHandler getTransportControlHandler() const { return TransportControlHandler{findTransportControl()}; }
 
  // gives access for debug
  friend class Debug::ParamDisplay;
 
protected:
  // the parameters
  Parameters const &fPluginParameters;
 
  // raw vst parameters
  VstParametersSPtr fVstParameters{};
 
  // param aware views
  ParamAwareViews fParamAwareViews{};
 
  // message producer (to send messages)
  IMessageProducer *fMessageProducer{};
 
  // handles messages (receive messages)
  MessageHandler fMessageHandler{};
 
  // handles show/dismiss dialog window
  IDialogHandler *fDialogHandler{};
 
  // Exposed to state to manage transport control
  ITransportControl *fTransportControl{};
 
  // contains all the (serializable) registered parameters (unique ID, will be checked on add)
  std::map<ParamID, std::shared_ptr<IGUIJmbParameter>> fJmbParams{};
 
  // order in which the parameters were registered
  std::vector<ParamID> fAllRegistrationOrder{};
 
protected:
  // setParamNormalized
  tresult setParamNormalized(NormalizedState const *iNormalizedState);
 
  // add serializable parameter to the structures
  void addJmbParam(std::shared_ptr<IGUIJmbParameter> iParameter);
 
  // allocateMessage
  IPtr<IMessage> allocateMessage() override;
 
  // sendMessage
  tresult sendMessage(IPtr<IMessage> iMessage) override;
 
  virtual tresult readDeprecatedGUIState(uint16 iDeprecatedVersion,
                                         IBStreamer &iStreamer,
                                         NormalizedState::SaveOrder const &iLatestSaveOrder);

  virtual tresult readGUIState(NormalizedState::SaveOrder const &iSaveOrder, IBStreamer &iStreamer);
};

template<typename T>
concept GUIStateSubclass = std::derived_from<T, GUIState>;

template<ParametersSubclass TPluginParameters>
class GUIPluginState : public GUIState
{
public:
  using PluginParameters = TPluginParameters;
 
public:
  explicit GUIPluginState(PluginParameters const &iPluginParameters) :
    GUIState{iPluginParameters},
    fParams{iPluginParameters}
  { }
 
public:
  PluginParameters const &fParams;
};
 
//------------------------------------------------------------------------
// GUIState::add
//------------------------------------------------------------------------
template<typename T>
GUIJmbParam<T> GUIState::add(JmbParam<T> iParamDef)
{
  auto guiParam = iParamDef->newGUIParam();
  addJmbParam(guiParam);
  return GUIJmbParam<T>(std::dynamic_pointer_cast<GUIJmbParameter<T>>(guiParam));
}
 
//------------------------------------------------------------------------
// GUIState::broadcast
//------------------------------------------------------------------------
template<typename T>
tresult GUIState::broadcast(JmbParam<T> const &iParamDef, const T &iMessage)
{
  if(!iParamDef->fShared)
  {
    DLOG_F(WARNING, "broadcast ignored: parameter [%d] is not marked shared", iParamDef->fParamID);
    return kResultFalse;
  }
 
  tresult res = kResultOk;
 
  auto message = allocateMessage();
 
  if(message)
  {
    Message m{message.get()};
 
    // sets the message ID
    m.setMessageID(iParamDef->fParamID);
 
    // serialize the content
    if(iParamDef->writeToMessage(iMessage, m) == kResultOk)
      res |= sendMessage(message);
    else
      res = kResultFalse;
  }
  else
    res = kResultFalse;
 
  return res;
}
 
//------------------------------------------------------------------------
// GUIState::getGUIVstParameter
//------------------------------------------------------------------------
template<typename T>
std::shared_ptr<GUIVstParameter<T>> GUIState::getGUIVstParameter(ParamID iParamID) const
{
  std::shared_ptr<GUIRawVstParameter> param = getRawVstParameter(iParamID);
 
  if(!param)
  {
    DLOG_F(WARNING, "vst param [%d] not found", iParamID);
    return nullptr;
  }
 
  auto res = param->asVstParameter<T>();
 
  if(res)
    return res;
  else
  {
    DLOG_F(WARNING, "vst param [%d] is not of the requested type", iParamID);
    return nullptr;
  }
}
 
 
}
}
 
//------------------------------------------------------------------------
// Implementation note: because of the circular dependency between
// JmbParamDef and IGUIJmbParameter, this templated method is defined
// here in GUIState.h since GUIState.cpp is the primary user of this
// method.
//------------------------------------------------------------------------
namespace pongasoft::VST {
//------------------------------------------------------------------------
// JmbParamDef<T>::newGUIParam
//------------------------------------------------------------------------
template<typename T>
std::shared_ptr<GUI::Params::IGUIJmbParameter> JmbParamDef<T>::newGUIParam()
{
  auto ptr = std::dynamic_pointer_cast<JmbParamDef<T>>(IParamDef::shared_from_this());
  return VstUtils::make_sfo<GUI::Params::GUIJmbParameter<T>>(ptr);
}
}