GUIState.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 "pongasoft/VST/MessageHandler.h"
#include <pongasoft/VST/GUI/Params/VstParameters.h>
#include <pongasoft/VST/GUI/Params/GUIVstParameter.h>
#include <pongasoft/VST/GUI/Params/GUIJmbParameter.h>
#include <pongasoft/VST/MessageProducer.h>
#include "ViewCxMgr.h"

namespace pongasoft {
namespace VST {
namespace Debug { class ParamDisplay; }
namespace GUI {

using namespace Params;

namespace Params {
class GUIParamCxMgr;
}

class GUIState : public IMessageProducer
{
public:
  // Constructor
  explicit GUIState(Parameters const &iPluginParameters);

  virtual tresult init(VstParametersSPtr iVstParameters, IMessageProducer *iMessageProducer);

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

  std::unique_ptr<GUIRawVstParameter> getRawVstParameter(ParamID iParamID) const
  {
    if(existsVst(iParamID))
      return std::make_unique<GUIRawVstParameter>(iParamID, fVstParameters);
    else
      return nullptr;
  }

  // getRawVstParamDef
  std::shared_ptr<RawVstParamDef> getRawVstParamDef(ParamID iParamID) const
  {
    return fPluginParameters.getRawVstParamDef(iParamID);
  }

  // getGUIVstParameter
  template<typename T>
  std::unique_ptr<GUIVstParameter<T>> getGUIVstParameter(ParamID iParamID) const;

  // getGUIVstParameter
  template<typename T>
  inline std::unique_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
  {
    return fVstParameters ? fVstParameters->connect(iParamID, iChangeListener) : nullptr;
  }

  std::unique_ptr<FObjectCx> connect(ParamID iParamID, Parameters::ChangeCallback iChangeCallback) const
  {
    return fVstParameters ? fVstParameters->connect(iParamID, std::move(iChangeCallback)) : nullptr;
  }

  template<typename TView>
  inline ViewGUIParamCxAware<TView> *registerConnectionFor(TView *iView) {
    return fViewCxMgr.registerConnectionFor(iView, this);
  }

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

  // gives access for debug
  friend class Debug::ParamDisplay;

protected:
  // the parameters
  Parameters const &fPluginParameters;

  // raw vst parameters
  VstParametersSPtr fVstParameters{};

  // view connection mgr
  ViewCxMgr fViewCxMgr{};

  // message producer (to send messages)
  IMessageProducer *fMessageProducer{};

  // handles messages (receive messages)
  MessageHandler fMessageHandler{};

  // contains all the (serializable) registered parameters (unique ID, will be checked on add)
  std::map<ParamID, std::unique_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::unique_ptr<IGUIJmbParameter> iParameter);

  // allocateMessage
  IPtr<IMessage> allocateMessage() override;

  // sendMessage
  tresult sendMessage(IPtr<IMessage> iMessage) override;
};

template<typename 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 rawPtr = new GUIJmbParameter<T>(iParamDef);
  std::unique_ptr<IGUIJmbParameter> guiParam{rawPtr};
  addJmbParam(std::move(guiParam));
  if(iParamDef->fShared && iParamDef->fSerializer)
  {
    switch(iParamDef->fOwner)
    {
      case IJmbParamDef::Owner::kRT:
        fMessageHandler.registerHandler(iParamDef->fParamID, rawPtr);
        break;

      case IJmbParamDef::Owner::kGUI:
        rawPtr->setMessageProducer(this);
        break;

      default:
        // not reached
        DLOG_F(ERROR, "not reached");
        break;
    }
  }
  return rawPtr;
}

//------------------------------------------------------------------------
// 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::unique_ptr<GUIVstParameter<T>> GUIState::getGUIVstParameter(ParamID iParamID) const
{
  auto param = getRawVstParameter(iParamID);

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

  auto rawParamDef = getRawVstParamDef(iParamID);

  auto paramDef = std::dynamic_pointer_cast<VstParamDef<T>>(rawParamDef);

  if(paramDef)
  {
    return std::make_unique<GUIVstParameter<T>>(std::move(param), paramDef);
  }
  else
  {
    DLOG_F(WARNING, "vst param [%d] is not of the requested type", iParamID);
    return nullptr;
  }
}


}
}
}