IGUIParameter.h

Go to the documentation of this file.

/*
 * Copyright (c) 2019-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 <pluginterfaces/vst/vsttypes.h>
#include <pluginterfaces/base/ftypes.h>
#include <memory>
#include <pongasoft/VST/Parameters.h>
#include <pongasoft/VST/FObjectCx.h>

namespace pongasoft::VST::GUI::Params {

using namespace Steinberg;
using namespace Steinberg::Vst;

// forward declaration required for compilation
template<typename T> class ITGUIParameter;

using GUIDiscreteParameter = ITGUIParameter<int32>;

//------------------------------------------------------------------------
// IGUIParameter
//------------------------------------------------------------------------
class IGUIParameter : public std::enable_shared_from_this<IGUIParameter>
{
public:
  class Editor
  {
  public:
    virtual tresult commit() = 0;

    virtual tresult rollback() = 0;

    virtual ~Editor() = default;
  };

public:
  virtual ParamID getParamID() const = 0;

  virtual int32 getStepCount() const = 0;

  virtual std::string toUTF8String(int32 iPrecision) const = 0;

  virtual tresult resetToDefault() = 0;

  virtual std::unique_ptr<FObjectCx> connect(Parameters::IChangeListener *iChangeListener) const = 0;

  virtual std::unique_ptr<FObjectCx> connect(Parameters::ChangeCallback iChangeCallback) const = 0;

public:
  template<typename T>
  std::shared_ptr<ITGUIParameter<T>> cast();

  virtual std::shared_ptr<GUIDiscreteParameter> asDiscreteParameter(int32 iStepCount) = 0;
};

//------------------------------------------------------------------------
// ITGUIParameter<T>
//------------------------------------------------------------------------
template<typename T>
class ITGUIParameter : public IGUIParameter
{
public:
  using ParamType = T;

  using ValueAccessor = std::function<void(T const &)>;

public:
  class ITEditor : public IGUIParameter::Editor
  {
  public:
    virtual tresult setValue(ParamType const &iValue) = 0;

    virtual bool updateValue(ParamType const &iValue) = 0;

    using IGUIParameter::Editor::commit;

    virtual tresult commit(ParamType const &iValue)
    {
      auto res = setValue(iValue);
      if(res == kResultOk)
        return commit();
      else
        return res;
    };
  };

public:
  virtual tresult accessValue(ValueAccessor const &iGetter) const = 0;

  virtual bool update(ParamType const &iValue) = 0;

  virtual tresult setValue(ParamType const &iValue) = 0;

  virtual std::unique_ptr<ITEditor> edit() = 0;

  virtual std::unique_ptr<ITEditor> edit(ParamType const &iValue)
  {
    auto editor = edit();
    editor->setValue(iValue);
    return editor;
  }
};

//------------------------------------------------------------------------
// DefaultEditorImpl
//------------------------------------------------------------------------
template<typename T>
class DefaultEditorImpl : public ITGUIParameter<T>::ITEditor
{
public:
  // Constructor
  explicit DefaultEditorImpl(ITGUIParameter<T> *iGUIParameter, T const &iDefaultValue) :
    fGUIParameter{iGUIParameter},
    fInitialValue{iDefaultValue}
  {
  }

  // Destructor
  ~DefaultEditorImpl() override { rollback(); }

  // updateValue
  bool updateValue(T const &iValue) override
  {
    if(fDoneEditing)
      return false;
    return fGUIParameter->update(iValue);
  }

  // setValue
  tresult setValue(T const &iValue) override
  {
    if(fDoneEditing)
      return kResultFalse;
    fGUIParameter->update(iValue);
    return kResultOk;
  }

  using ITGUIParameter<T>::ITEditor::commit;

  // commit
  tresult commit() override
  {
    if(fDoneEditing)
      return kResultFalse;
    fDoneEditing = true;
    return kResultOk;
  }

  // rollback
  tresult rollback() override
  {
    auto res = setValue(fInitialValue);
    fDoneEditing = true;
    return res;
  }

private:
  ITGUIParameter<T> *fGUIParameter;
  T fInitialValue;
  bool fDoneEditing{false};
};

//------------------------------------------------------------------------
// IGUIParam
//------------------------------------------------------------------------
class IGUIParam
{
public:
  IGUIParam(std::shared_ptr<IGUIParameter> iPtr = nullptr) : // NOLINT (not marked explicit on purpose)
    fPtr{std::move(iPtr)}
  {}

  inline bool exists() const { return (bool) fPtr; }

  inline ParamID getParamID() const { DCHECK_F(exists()); return fPtr->getParamID(); }

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

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

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

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

  std::unique_ptr<FObjectCx> connect(Parameters::ChangeCallback iChangeCallback) const { DCHECK_F(exists()); return fPtr->connect(std::move(iChangeCallback)); }

private:
  std::shared_ptr<IGUIParameter> fPtr;
};


}