CustomView.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018-2019 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 <vstgui4/vstgui/lib/cview.h>
#include <map>
#include <pongasoft/VST/GUI/GUIState.h>
#include <pongasoft/VST/GUI/Params/ParamAware.hpp>
#include <pongasoft/VST/GUI/Views/CustomViewFactory.h>
#include "CustomViewCreator.h"
#include "StateAware.h"
#include "CustomViewLifecycle.h"

namespace pongasoft::VST::GUI::Views {

using namespace VSTGUI;
using namespace Params;

class CustomView : public CView, public ParamAware, public ICustomViewLifecycle
{
public:
  // Constructor
  explicit CustomView(const CRect &iSize);

  // Deleting for now... not sure there is an actual use for it
  CustomView(const CustomView &c) = delete;

  CColor const &getBackColor() const { return fBackColor; }

  void setBackColor(CColor const &iColor);

  void setCustomViewTag (TagID iTag) { fTag = iTag; }

  TagID getCustomViewTag () const { return fTag; }

  void setEditorMode(bool iEditorMode);

  bool getEditorMode() const;

#if EDITOR_MODE

  virtual void onEditorModeChanged() {}
#endif

  void draw(CDrawContext *iContext) override;

  virtual void drawBackColor(CDrawContext *iContext);

  void drawStyleChanged();

  void onParameterChange(ParamID iParamID) override;

  inline void markDirty() { setDirty(true); }

  void afterApplyAttributes() override
  {
    unregisterAll();
    registerParameters();
    markDirty();
  }

public:
  CLASS_METHODS_NOCOPY(CustomView, CControl)

protected:
  using CView::sizeToFit; // fixes overload hiding warning

  void sizeToFit(CCoord iWidth, CCoord iHeight)
  {
    CRect vs(getViewSize());
    vs.setWidth(iWidth);
    vs.setHeight(iHeight);
    setViewSize(vs, true);
    setMouseableArea(vs);
  }

  bool sizeToFit(BitmapPtr iBitmap, int iFrameCount = 1)
  {
    if(iBitmap)
    {
      sizeToFit(iBitmap->getWidth(), iBitmap->getHeight() / iFrameCount);
      return true;
    }
    return false;
  }

protected:
  ParamID fTag;
#if EDITOR_MODE
  bool fEditorMode{false};
#endif
  CColor fBackColor;

public:
  class Creator : public TCustomViewCreator<CustomView>
  {
  public:
    explicit Creator(char const *iViewName = nullptr, char const *iDisplayName = nullptr) :
      TCustomViewCreator<CustomView>(iViewName, iDisplayName)
    {
      registerTagAttribute("custom-view-tag", &CustomView::getCustomViewTag, &CustomView::setCustomViewTag);
#if EDITOR_MODE
      registerBooleanAttribute("editor-mode", &CustomView::getEditorMode, &CustomView::setEditorMode);
#endif
      registerColorAttribute(UIViewCreator::kAttrBackColor, &CustomView::getBackColor, &CustomView::setBackColor);
    }
  };
};

template<typename TView, typename TGUIState>
class StateAwareView : public TView, public StateAware<TGUIState>
{
  // ensures that TView is a subclass of CView
  static_assert(std::is_convertible<TView *, CView*>::value, "TView must be a subclass of CView");

  // ensures that TGUIState is a subclass of GUIState
  static_assert(std::is_convertible<TGUIState *, GUIState*>::value, "TGUIState must be a subclass of GUIState");

public:
  // Constructor
  template<typename... Args>
  explicit StateAwareView(const CRect &iSize, Args&& ...args) : TView(iSize, std::forward<Args>(args)...) {}

protected:
  void initState(GUIState *iGUIState) override
  {
    TView::initState(iGUIState);
    StateAware<TGUIState>::initState(iGUIState);
  }
};

template<typename TGUIState>
using StateAwareCustomView = StateAwareView<CustomView, TGUIState>;

template<typename TView>
class CustomViewAdapter : public TView, public ParamAware, public ICustomViewLifecycle
{
  // ensures that TView is a subclass of CView
  static_assert(std::is_convertible<TView *, CView*>::value, "TView must be a subclass of CView");

public:
  // Constructor
  template<typename... Args>
  explicit CustomViewAdapter(const CRect &iSize, Args&& ...args) : TView(iSize, std::forward<Args>(args)...), fTag{UNDEFINED_PARAM_ID} {}

  inline void markDirty() { TView::setDirty(true); }

  void setCustomViewTag (TagID iTag) { fTag = iTag; }

  TagID getCustomViewTag () const { return fTag; }

  void setEditorMode(bool iEditorMode)
  {
#if EDITOR_MODE
    if(fEditorMode != iEditorMode)
    {
      fEditorMode = iEditorMode;
      onEditorModeChanged();
    }
#endif

    // when not in editor mode, this does nothing...
  }

  bool getEditorMode() const
  {
#if EDITOR_MODE
    return fEditorMode;
#else
    return false;
#endif
  }

#if EDITOR_MODE
  virtual void onEditorModeChanged() {}
#endif

  void onParameterChange(ParamID iParamID) override { markDirty(); };

  void afterApplyAttributes() override
  {
    unregisterAll();
    registerParameters();
    markDirty();
  }

protected:
  TagID fTag;
#if EDITOR_MODE
  bool fEditorMode{false};
#endif

public:
  using creator_super_type = TCustomViewCreator<CustomViewAdapter>;

  class Creator : public creator_super_type
  {
  public:
    explicit Creator(char const *iViewName = nullptr, char const *iDisplayName = nullptr) :
      creator_super_type(iViewName, iDisplayName)
    {
      creator_super_type::registerTagAttribute("custom-view-tag", &CustomViewAdapter::getCustomViewTag, &CustomViewAdapter::setCustomViewTag);
#if EDITOR_MODE
      creator_super_type::registerBooleanAttribute("editor-mode", &CustomViewAdapter::getEditorMode, &CustomViewAdapter::setEditorMode);
#endif
    }
  };
};

template<typename TView, typename TGUIState>
class StateAwareCustomViewAdapter : public CustomViewAdapter<TView>, public StateAware<TGUIState>
{
  // ensures that TView is a subclass of CView
  static_assert(std::is_convertible<TView *, CView*>::value, "TView must be a subclass of CView");

  // ensures that TGUIState is a subclass of GUIState
  static_assert(std::is_convertible<TGUIState *, GUIState*>::value, "TGUIState must be a subclass of GUIState");

public:
  // Constructor
  template<typename... Args>
  explicit StateAwareCustomViewAdapter(const CRect &iSize, Args&& ...args) :
    CustomViewAdapter<TView>(iSize, std::forward<Args>(args)...) {}

protected:
  // initState - overridden to extract fParams
  void initState(GUIState *iGUIState) override
  {
    ParamAware::initState(iGUIState);
    StateAware<TGUIState>::initState(iGUIState);
  }
};

template<typename TView, typename TGUIState>
class [[deprecated("Since 4.0.0 - Use StateAwareView instead")]] PluginView : public StateAwareView<TView, TGUIState>
{
public:
  explicit PluginView(const CRect &iSize) : StateAwareView<TView, TGUIState>(iSize) {}
};

template<typename TGUIState>
class [[deprecated("Since 4.0.0 - Use StateAwareCustomView instead")]] PluginCustomView : public StateAwareCustomView<TGUIState>
{
public:
  explicit PluginCustomView(const CRect &iSize) : StateAwareCustomView<TGUIState>(iSize) {}
};

template<typename TView, typename TGUIState>
class [[deprecated("Since 4.0.0 - Use StateAwareCustomViewAdapter instead")]] PluginCustomViewAdapter : public StateAwareCustomViewAdapter<TView, TGUIState>
{
public:
  template<typename... Args>
  explicit PluginCustomViewAdapter(const CRect &iSize, Args &&... args) :
    StateAwareCustomViewAdapter<TView, TGUIState>(iSize, std::forward<Args>(args)...)
  {}
};

}