GUIRawVstParameter.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 "IGUIParameter.h"
#include <pongasoft/VST/Parameters.h>
#include <pongasoft/Utils/Operators.h>
#include "VstParameters.h"
#include "GUIParamCx.h"
 
#include <string>
 
namespace pongasoft::VST::GUI::Params {
 
template<typename T>
class GUIVstParameter;

class GUIRawVstParameter : public ITGUIParameter<ParamValue>
{
public:
  using ParamType = ParamValue;
  using EditorType = ITGUIParameter<ParamValue>::ITEditor;
 
public:
  class Editor : public EditorType
  {
  public:
    Editor(ParamID iParamID, VstParametersSPtr iVstParameters);
 
    ~Editor() override { rollback(); }
 
    // disabling copy
    Editor(Editor const &) = delete;
    Editor& operator=(Editor const &) = delete;

    tresult setValue(ParamValue const &iValue) override;

    bool updateValue(ParamValue const &iValue) override;
 
    /*
     * Call when you are done with the modifications.
     * This has no effect if rollback() has already been called
     */
    tresult commit() override;
 
    // importing superclass commit methods
    using EditorType::commit;

    tresult rollback() override;
 
  private:
    ParamID fParamID;
    VstParametersSPtr fVstParameters;
 
    ParamValue fInitialParamValue;
    bool fIsEditing;
  };
 
public:
  // Constructor
  GUIRawVstParameter(ParamID iParamID,
                     VstParametersSPtr iVstParameters,
                     std::shared_ptr<RawVstParamDef> iParamDef);
 
  // Destructor
  ~GUIRawVstParameter() = default;
//  {
//    DLOG_F(INFO, "RawParameter::~RawParameter(%d)", fParamID);
//  }
 
  // getParamID
  inline ParamID getParamID() const override
  {
    return fParamID;
  }
 
  // accessValue
  tresult accessValue(ValueAccessor const &iGetter) const override
  {
    iGetter(getValue());
    return kResultOk;
  }

  inline ParamValue getValue() const
  {
    return fVstParameters->getParamNormalized(fParamID);
  }

  inline int32 getStepCount() const override
  {
    auto parameterInfo = fVstParameters->getParameterInfo(fParamID);
    if(parameterInfo)
      return parameterInfo->stepCount;
    else
      return 0;
  }

  void toString(String128 oString)
  {
    fParamDef->toString(getValue(), oString);
  }

  Steinberg::String toString()
  {
    String128 s;
    toString(s);
    return Steinberg::String(s);
  }
 
  // toUTF8String
  std::string toUTF8String(int32 iPrecision) const override
  {
    return fParamDef->toUTF8String(getValue(), iPrecision);
  }

  bool update(ParamValue const &iValue) override
  {
    auto const previousValue = getValue();
    if(previousValue != iValue)
    {
      setValue(iValue);
      return true;
    }
    return false;
  }

  inline tresult setValue(ParamValue const &iValue) override
  {
    Editor editor(fParamID, fVstParameters);
    editor.setValue(iValue);
    return editor.commit();
  }

  tresult resetToDefault() override
  {
    return setValue(fParamDef->fDefaultValue);
  }

  std::unique_ptr<EditorType> edit() override
  {
    return std::make_unique<Editor>(fParamID, fVstParameters);
  }

  using ITGUIParameter<ParamValue>::edit;

  std::unique_ptr<FObjectCx> connect(Parameters::IChangeListener *iChangeListener) const override
  {
    return fVstParameters->connect(fParamID, iChangeListener);
  }

  std::unique_ptr<FObjectCx> connect(Parameters::ChangeCallback iChangeCallback) const override
  {
    return fVstParameters->connect(fParamID, std::move(iChangeCallback));
  }

  template<typename T>
  std::shared_ptr<GUIVstParameter<T>> asVstParameter();

  std::shared_ptr<GUIDiscreteParameter> asDiscreteParameter(int32 iStepCount) override;
 
private:
  ParamID fParamID;
  VstParametersSPtr fVstParameters;
  std::shared_ptr<RawVstParamDef> fParamDef;
};
 
//-------------------------------------------------------------------------------
// GUIRawVstParam - wrapper to make writing the code much simpler and natural
//-------------------------------------------------------------------------------
class GUIRawVstParam : public Utils::Operators::Dereferenceable<GUIRawVstParam>
{
public:
  using ParamType = ParamValue;
  using EditorType = GUIRawVstParameter::EditorType;
  using Editor = std::unique_ptr<EditorType>;
 
public:
  // Constructor
  GUIRawVstParam(std::shared_ptr<GUIRawVstParameter> iPtr = nullptr) : // NOLINT (not marked explicit on purpose)
    fPtr{std::move(iPtr)}
  {}

  GUIRawVstParam &operator=(GUIRawVstParam const &iOther) = default;
 
  // exists
  inline bool exists() const { return (bool) fPtr; }
 
  // getParamID
  inline ParamID getParamID() const { DCHECK_F(exists()); return fPtr->getParamID(); }

  inline ParamValue getValue() const { DCHECK_F(exists()); return fPtr->getValue(); }

  inline ParamValue value() const { DCHECK_F(exists()); return fPtr->getValue(); }

  bool update(ParamValue const &iValue) { DCHECK_F(exists()); return fPtr->update(iValue); }

  tresult setValue(ParamValue const &iValue) { DCHECK_F(exists()); return fPtr->setValue(iValue); }

  inline tresult resetToDefault() { DCHECK_F(exists()); return fPtr->resetToDefault(); }

  tresult copyValueFrom(GUIRawVstParam const &iParam) { DCHECK_F(exists()); return setValue(iParam.getValue()); }

  inline int32 getStepCount() const { DCHECK_F(exists()); return fPtr->getStepCount(); }

  void toString(String128 oString) { fPtr->toString(oString); }

  Steinberg::String toString() { DCHECK_F(exists()); return fPtr->toString(); }

  Editor edit() { DCHECK_F(exists()); return fPtr->edit(); }

  Editor edit(ParamValue const &iValue) { DCHECK_F(exists()); return fPtr->edit(iValue); }

  inline ParamValue operator *() const { DCHECK_F(exists()); return fPtr->getValue(); }

  [[deprecated("Since 4.1.0 -  use operator* or .value() instead (ex: if(*param) {...} or if(param.value()) {...}")]]
  inline operator ParamValue() const { DCHECK_F(exists()); return fPtr->getValue(); } // NOLINT

  inline GUIRawVstParam &operator=(ParamValue const &iValue) { DCHECK_F(exists()); fPtr->setValue(iValue); return *this; }

  inline std::string toUTF8String(int32 iPrecision) const { DCHECK_F(exists()); return fPtr->toUTF8String(iPrecision); }

  inline std::unique_ptr<FObjectCx> connect(Parameters::IChangeListener *iChangeListener) const { DCHECK_F(exists()); return fPtr->connect(iChangeListener); }

  inline std::unique_ptr<FObjectCx> connect(Parameters::ChangeCallback iChangeCallback) const { DCHECK_F(exists()); return fPtr->connect(std::move(iChangeCallback)); }
 
private:
  std::shared_ptr<GUIRawVstParameter> fPtr;
};
 
//------------------------------------------------------------------------
// shortcut notations
//------------------------------------------------------------------------
using GUIRawVstParamEditor = std::unique_ptr<GUIRawVstParameter::EditorType>;
 
}