GUIValParameter.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 <pongasoft/logging/logging.h>
#include <pongasoft/Utils/Metaprogramming.h>
#include "GUIParamCx.h"

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

using namespace Steinberg::Vst;

template<typename T>
class GUIValParameter: public ITGUIParameter<T>, public FObject
{
public:
  using ParamType = T;
  using EditorType = typename ITGUIParameter<T>::ITEditor;

  using FObject::update; // fixes overload hiding warning

public:
  // Constructor
  explicit GUIValParameter(ParamID iParamID, ParamType const &iDefaultValue) :
    fParamID{iParamID},
    fValue(iDefaultValue)
  {
//    DLOG_F(INFO, "GUIValParameter(%p)", this);
  };

  // Constructor
  explicit GUIValParameter(ParamID iParamID, ParamType &&iDefaultValue) :
    fParamID{iParamID},
    fValue(std::move(iDefaultValue))
  {
//    DLOG_F(INFO, "GUIValParameter(%p)", this);
  };

  // Destructor
  ~GUIValParameter() override
  {
//    DLOG_F(INFO, "~GUIValParameter(%p)", this);
  }

  // getParamID
  ParamID getParamID() const override { return fParamID; }
  void setParamID(ParamID iParamID) { fParamID = iParamID; }

  inline int32 getStepCount() const override { return 0; }

  bool update(ParamType const &iValue) override
  {
    // Implementation note: because this method is declared virtual the compiler must instantiate it
    // even if never called and will generate an error if the ParamType does not define operator!=, so we
    // need to account for this case
    if constexpr(Utils::is_operator_not_eq_defined<ParamType>)
    {
      if(fValue != iValue)
      {
        if(setValue(iValue) == kResultOk)
          return true;
      }
    }
    else
    {
      if(setValue(iValue) == kResultOk)
        return true;
    }
    return false;
  }

  std::unique_ptr<EditorType> edit() override
  {
    return std::make_unique<DefaultEditorImpl<T>>(this, getValue());
  }

  template<class ValueModifier>
  bool updateIf(ValueModifier const &iValueModifier)
  {
    if(iValueModifier(&fValue))
    {
      changed();
      return true;
    }
    return false;
  }

  tresult setValue(ParamType const &iValue) override
  {
    fValue = iValue;
    changed();
    return kResultOk;
  }

  tresult setValue(ParamType &&iValue)
  {
    fValue = std::move(iValue);
    changed();
    return kResultOk;
  }

  // accessValue
  tresult accessValue(typename ITGUIParameter<T>::ValueAccessor const &iGetter) const override
  {
    iGetter(fValue);
    return kResultOk;
  }

  // getValue
  inline ParamType const &getValue() const { return fValue; }

  // getValue
  inline ParamType &getValue() { return fValue; }

  // toUTF8String
  std::string toUTF8String(int32 iPrecision) const override
  {
    return VstUtils::toUTF8String(getValue(), iPrecision);
  }

  std::unique_ptr<FObjectCx> connect(Parameters::IChangeListener *iChangeListener) const override
  {
    return std::make_unique<GUIParamCx>(getParamID(), const_cast<GUIValParameter *>(this), iChangeListener);
  }

  std::unique_ptr<FObjectCx> connect(Parameters::ChangeCallback iChangeCallback) const override
  {
    return std::make_unique<FObjectCxCallback>(const_cast<GUIValParameter *>(this), iChangeCallback);
  }

  // asDiscreteParameter
  std::shared_ptr<GUIDiscreteParameter> asDiscreteParameter(int32 iStepCount) override;

protected:
  ParamID fParamID;
  T fValue;
};

class GUIDiscreteValParameter : public GUIValParameter<int32>
{
public:
  GUIDiscreteValParameter(ParamID iParamID, int32 iDefaultValue, int32 iStepCount) :
    GUIValParameter(iParamID, iDefaultValue),
    fStepCount(iStepCount)
  {
    DCHECK_F(fStepCount > 0);
  }

  // getStepCount
  int32 getStepCount() const override { return fStepCount; }

protected:
  int32 fStepCount;
};

//------------------------------------------------------------------------
// GUIValParameter::asDiscreteParameter
//------------------------------------------------------------------------
template<typename T>
std::shared_ptr<GUIDiscreteParameter> GUIValParameter<T>::asDiscreteParameter(int32 iStepCount)
{
  if(iStepCount > 0)
  {
    if constexpr(Utils::is_static_cast_defined<int32, T> && Utils::is_static_cast_defined<T, int32>)
    {
      return VstUtils::make_sfo<GUIDiscreteValParameter>(fParamID, static_cast<int32>(fValue), iStepCount);
    }
  }
  return nullptr;
}

}