GUIState.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018-2020 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 "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>
#include <pongasoft/VST/GUI/Params/GUIJmbParameter.h>
#include <pongasoft/VST/MessageProducer.h>
#include "ParamAwareViews.h"
#include "IDialogHandler.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);

  // getPluginParameters
  Parameters const &getPluginParameters() const { return fPluginParameters; }

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

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

  inline bool existsJmb(ParamID iParamID) const { return fJmbParams.find(iParamID) != fJmbParams.cend()
                                                         ||
                                                         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>
  inline 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<typename TView>
  inline ParamAwareView<TView> *makeParamAware(TView *iView) {
    return fParamAwareViews.makeParamAware(iView, this);
  }

  template<typename TView>
  [[deprecated("Since 4.0.0 - Use makeParamAware instead")]]
  inline ParamAwareView<TView> *registerConnectionFor(TView *iView) {
    return makeParamAware<TView>(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;

  // 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{};

  // 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 TPluginParameters>
class GUIPluginState : public GUIState
{
  // ensures that TPluginParameters is a subclass of Parameters
  static_assert(std::is_convertible<TPluginParameters*, Parameters*>::value, "TPluginParameters must be a subclass of Parameters");

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