IPlugEditorDelegate.h

Go to the documentation of this file.

/*
 ==============================================================================
 
 This file is part of the iPlug 2 library. Copyright (C) the iPlug 2 developers. 
 
 See LICENSE.txt for  more info.
 
 ==============================================================================
*/

#pragma once

#include <cassert>
#include <cstring>
#include <stdint.h>

#include "ptrlist.h"

#include "IPlugParameter.h"
#include "IPlugMidi.h"
#include "IPlugStructs.h"

BEGIN_IPLUG_NAMESPACE

class IEditorDelegate
{
public:
  IEditorDelegate(int nParams)
  {
    for (int i = 0; i < nParams; i++)
      AddParam();
  }
  
  virtual ~IEditorDelegate()
  {
    mParams.Empty(true);
  }
  
  IEditorDelegate(const IEditorDelegate&) = delete;
  IEditorDelegate& operator=(const IEditorDelegate&) = delete;
  
  IParam* AddParam() { return mParams.Add(new IParam()); }
  
  void RemoveParam(int idx) { return mParams.Delete(idx); }
  
  IParam* GetParam(int paramIdx) { return mParams.Get(paramIdx); }
    
  const IParam* GetParam(int paramIdx) const { return mParams.Get(paramIdx); }

  int NParams() const { return mParams.GetSize(); }
  
  virtual void* OpenWindow(void* pParent) { OnUIOpen(); return nullptr; }
  
  virtual void CloseWindow() { OnUIClose(); }

  virtual void OnParentWindowResize(int width, int height) { /* NO-OP*/ }
  
#pragma mark - Methods you may want to override...

  virtual void OnUIOpen() { SendCurrentParamValuesFromDelegate(); }
  
  virtual void OnUIClose() {};
  
  virtual void OnParamChange(int paramIdx, EParamSource source, int sampleOffset = -1)
  {
    Trace(TRACELOC, "idx:%i src:%s\n", paramIdx, ParamSourceStrs[source]);
    OnParamChange(paramIdx);
  }
  
  virtual void OnParamChange(int paramIdx) {}
  
  virtual void OnParamChangeUI(int paramIdx, EParamSource source = kUnknown) {};
  
  virtual void OnParamReset(EParamSource source)
  {
    for (int i = 0; i < NParams(); ++i)
    {
      OnParamChange(i, source);
      OnParamChangeUI(i, source);
    }
  }
  
  virtual void OnMidiMsgUI(const IMidiMsg& msg) {};
  
  virtual void OnSysexMsgUI(const ISysEx& msg) {};
  
  virtual bool OnMessage(int msgTag, int ctrlTag, int dataSize, const void* pData) { return false; }
  
  virtual void OnRestoreState() { SendCurrentParamValuesFromDelegate(); };
  
  virtual bool OnKeyDown(const IKeyPress& key) { return false; }

  virtual bool OnKeyUp(const IKeyPress& key) { return false; }
  
#pragma mark - Methods for sending values TO the user interface

  void SendCurrentParamValuesFromDelegate()
  {
    for (int i = 0; i < NParams(); ++i)
    {
      SendParameterValueFromDelegate(i, GetParam(i)->GetNormalized(), true);
    }
  }
  
  virtual void SendControlValueFromDelegate(int ctrlTag, double normalizedValue) {};
  
  virtual void SendControlMsgFromDelegate(int ctrlTag, int msgTag, int dataSize = 0, const void* pData = nullptr) { OnMessage(msgTag, ctrlTag, dataSize, pData); }
  
  virtual void SendArbitraryMsgFromDelegate(int msgTag, int dataSize = 0, const void* pData = nullptr) { OnMessage(msgTag, kNoTag, dataSize, pData); }
  
  virtual void SendMidiMsgFromDelegate(const IMidiMsg& msg) { OnMidiMsgUI(msg); }
  
  virtual void SendSysexMsgFromDelegate(const ISysEx& msg) { OnSysexMsgUI(msg); }
  
  virtual void SendParameterValueFromDelegate(int paramIdx, double value, bool normalized) { OnParamChangeUI(paramIdx, EParamSource::kDelegate); } // TODO: normalised?

#pragma mark - Methods for sending values FROM the user interface
  // The following methods are called from the user interface in order to set or query values of parameters in the class implementing IEditorDelegate
  
  virtual void DirtyParametersFromUI() {};
  
  virtual void BeginInformHostOfParamChangeFromUI(int paramIdx) = 0;
  
  virtual void SendParameterValueFromUI(int paramIdx, double normalizedValue)
  {
    assert(paramIdx < NParams());
    
    GetParam(paramIdx)->SetNormalized(normalizedValue);
    OnParamChangeUI(paramIdx, EParamSource::kUI);
  }
  
  virtual void EndInformHostOfParamChangeFromUI(int paramIdx) = 0;
  
  virtual bool EditorResizeFromUI(int viewWidth, int viewHeight, bool needsPlatformResize) { return false; }

  virtual void SendMidiMsgFromUI(const IMidiMsg& msg) {};

  virtual void SendSysexMsgFromUI(const ISysEx& msg) {};
  
  virtual void SendArbitraryMsgFromUI(int msgTag, int ctrlTag = kNoTag, int dataSize = 0, const void* pData = nullptr) {};
  
#pragma mark -

  virtual void DeferMidiMsg(const IMidiMsg& msg) {};
  
  virtual void DeferSysexMsg(const ISysEx& msg) {};

#pragma mark - Editor resizing
  void SetEditorSize(int width, int height) { mEditorWidth = width; mEditorHeight = height; }
  
  void SetSizeConstraints(int widthLo, int widthHi, int heightLo, int heightHi)
  {
    mMinWidth = std::min(widthLo, widthHi);
    mMaxWidth = std::max(widthLo, widthHi);
    mMinHeight = std::min(heightLo, heightHi);
    mMaxHeight = std::max(heightLo, heightHi);
  }

  int GetEditorWidth() const { return mEditorWidth; }
  
  int GetEditorHeight() const { return mEditorHeight; }
  
  int GetMinWidth() const { return mMinWidth; }
  int GetMaxWidth() const { return mMaxWidth; }
  int GetMinHeight() const { return mMinHeight; }
  int GetMaxHeight() const { return mMaxHeight; }

  bool ConstrainEditorResize(int& w, int& h) const
  {
    if(w >= mMinWidth && w <= mMaxWidth && h >= mMinHeight && h <= mMaxHeight)
    {
      return true;
    }
    else
    {
      w = Clip(w, mMinWidth, mMaxWidth);
      h = Clip(h, mMinHeight, mMaxHeight);
      return false;
    }
  }
  
  virtual bool SerializeEditorState(IByteChunk& chunk) const { return true; }
  
  virtual int UnserializeEditorState(const IByteChunk& chunk, int startPos)  { return startPos; }
  
  virtual void SetScreenScale(float scale) {}

  friend class IPlugAPP;
  friend class IPlugAAX;
  friend class IPlugVST2;
  friend class IPlugVST3;
  friend class IPlugVST3Controller;
  friend class IPlugVST3Processor;
  friend class IPlugAU;
  friend class IPlugAUv3;
  friend class IPlugWEB;
  friend class IPlugWAM;
  friend class IPlugAPIBase;
  friend class IPluginBase;

private:
  WDL_PtrList<IParam> mParams;

  int mEditorWidth = 0;
  int mEditorHeight = 0;
  int mMinWidth = 10, mMaxWidth = 100000, mMinHeight = 10, mMaxHeight = 100000;
};

END_IPLUG_NAMESPACE