GUIRawVstParameter.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018 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
 */
#ifndef __PONGASOFT_VST_GUI_RAW_PARAMETER_H__
#define __PONGASOFT_VST_GUI_RAW_PARAMETER_H__

#include <pongasoft/VST/Parameters.h>
#include "VstParameters.h"
#include "GUIParamCx.h"

#include <string>

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

class GUIRawVstParameter
{
public:
  class Editor
  {
  public:
    Editor(ParamID iParamID, VstParametersSPtr iVstParameters);

    // disabling copy
    Editor(Editor const &) = delete;
    Editor& operator=(Editor const &) = delete;

    tresult setValue(ParamValue iValue);

    /*
     * Call when you are done with the modifications.
     * This has no effect if rollback() has already been called
     */
    tresult commit();

    /*
     * Shortcut to set the value prior to commit
     * Call when you are done with the modifications.
     * This has no effect if rollback() has already been called
     */
    inline tresult commit(ParamValue iValue)
    {
      setValue(iValue);
      return commit();
    }

    tresult rollback();

    inline ~Editor()
    {
      // DLOG_F(INFO, "~RawParameter::Editor(%d)", fParamID);
      rollback();
    }

  private:
    ParamID fParamID;
    VstParametersSPtr fVstParameters;

    ParamValue fInitialParamValue;
    bool fIsEditing;
  };

public:
  // Constructor
  GUIRawVstParameter(ParamID iParamID, VstParametersSPtr iVstParameters);

  // Destructor
  ~GUIRawVstParameter() = default;
//  {
//    DLOG_F(INFO, "RawParameter::~RawParameter(%d)", fParamID);
//  }

  // getParamID
  inline ParamID getParamID() const
  {
    return fParamID;
  }

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

  inline int32 getStepCount() const { return fVstParameters->getParameterInfo(fParamID)->stepCount; }

  void toString(String128 oString)
  {
    auto parameter = fVstParameters->getParameterObject(fParamID);
    if(parameter)
      parameter->toString(getValue(), oString);
  }

  String toString()
  {
    String128 s;
    toString(s);
    return String(s);
  }

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

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

  std::unique_ptr<Editor> edit(ParamValue iValue)
  {
    auto editor = edit();
    editor->setValue(iValue);
    return editor;
  }

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

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

private:
  ParamID fParamID;
  VstParametersSPtr fVstParameters{};
};

//-------------------------------------------------------------------------------
// GUIRawVstParam - wrapper to make writing the code much simpler and natural
//-------------------------------------------------------------------------------
class GUIRawVstParam
{
public:
  GUIRawVstParam() : fPtr{nullptr} {}

  // move constructor
  explicit GUIRawVstParam(std::unique_ptr<GUIRawVstParameter> &&iPtr) : fPtr{std::move(iPtr)} {}

  // delete copy constructor
  GUIRawVstParam(GUIRawVstParam &iPtr) = delete;

  // move copy constructor
  GUIRawVstParam(GUIRawVstParam &&iPtr) noexcept : fPtr{std::move(iPtr.fPtr)} {}

  // move assignment constructor
  GUIRawVstParam &operator=(GUIRawVstParam &&iPtr) noexcept { fPtr = std::move(iPtr.fPtr); return *this; }

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

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

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

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

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

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

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

  String toString() { return fPtr->toString(); }

  std::unique_ptr<GUIRawVstParameter::Editor> edit() { return fPtr->edit(); }

  std::unique_ptr<GUIRawVstParameter::Editor> edit(ParamValue const &iValue) { return fPtr->edit(iValue); }

  // allow to use the param as the underlying ParamType (ex: "if(param)" in the case ParamType is bool))
  inline operator ParamValue() const { return fPtr->getValue(); } // NOLINT

  // allow to write param = 3 instead of param.setValue(3)
  inline void operator=(ParamValue const &iValue) { fPtr->setValue(iValue); }

  // allow to write param1 == param2
  inline bool operator==(const GUIRawVstParam &rhs) const { return fPtr->getValue() == rhs.fPtr->getValue(); }

  // allow to write param1 != param2
  inline bool operator!=(const GUIRawVstParam &rhs) const { return fPtr->getValue() != rhs.fPtr->getValue(); }

private:
  std::unique_ptr<GUIRawVstParameter> fPtr;
};

//------------------------------------------------------------------------
// shortcut notations
//------------------------------------------------------------------------
using GUIRawVstParamEditor = std::unique_ptr<GUIRawVstParameter::Editor>;

}
}
}
}

#endif //__PONGASOFT_VST_GUI_RAW_PARAMETER_H__