CustomViewCreator.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018-2019 pongasoft
 *
 * Licensed under the Apache License, Version 2.0 or the MIT license,
 * at your option. You may not use this file except in compliance with
 * one of these licenses. You may obtain copies of the licenses at:
 *
 * https://www.apache.org/licenses/LICENSE-2.0
 * https://opensource.org/licenses/MIT
 *
 * 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/uidescription/iviewcreator.h>
#include <vstgui4/vstgui/uidescription/uiviewcreator.h>
#include <vstgui4/vstgui/uidescription/uiviewfactory.h>
#include <vstgui4/vstgui/uidescription/uiattributes.h>
#include <vstgui4/vstgui/uidescription/detail/uiviewcreatorattributes.h>
#include <vstgui4/vstgui/lib/crect.h>
#include <vstgui4/vstgui/lib/ccolor.h>
#include <vstgui4/vstgui/lib/cbitmap.h>
#include <map>
#include <memory>
#include <functional>
#include <concepts>
#include <pongasoft/logging/logging.h>
#include <pongasoft/VST/GUI/Types.h>
#include <pongasoft/VST/GUI/Concepts.h>
#include <pongasoft/VST/GUI/LookAndFeel.h>
#include <pongasoft/Utils/Concepts.h>
#include <pongasoft/Utils/StringUtils.h>
#include <pongasoft/VST/Types.h>
 
namespace pongasoft::VST::GUI::Views {
 
using namespace VSTGUI;
 
//------------------------------------------------------------------------
// Implementation Note: Half of the API (the "getter"/"read" part of it)  is not used in Release mode because the
// editor code is built only during Debug mode (EDITOR_MODE is defined) and only the editor code is using it.
// As a result, it is conditionally compiled so that it doesn't use unnecessary space in Release mode.
//------------------------------------------------------------------------

class ViewAttribute
{
public:
  virtual ~ViewAttribute() = default;
 
  // Constructor
  explicit ViewAttribute(std::string iName) :
    fName(std::move(iName))
  {}

  virtual IViewCreator::AttrType getType() = 0;

  std::string getName() const
  {
    return fName;
  }

  virtual bool apply(CView *iView, const UIAttributes &iAttributes, const IUIDescription *iDescription) = 0;
 
#ifdef EDITOR_MODE
  virtual bool getAttributeValue(CView *iView, const IUIDescription *iDescription, std::string &oStringValue) const = 0;

  virtual bool getPossibleListValues(std::list<const std::string *> &iValues) const
  {
    return false;
  }
#endif
 
private:
  std::string fName;
};

template<CViewSubclass TView>
TView *createCustomView(CRect const &iSize,
                        const UIAttributes &iAttributes,
                        const IUIDescription * /* iDescription */) { return new TView(iSize); }

template<typename T>
using AttrValMap = std::map<std::string, T>;

template<typename T>
using AttrValInitList = std::initializer_list<typename AttrValMap<T>::value_type>;

template<typename TView>
class TCustomViewCreator : public ViewCreatorAdapter
{
private:
  template<typename T, typename TGetter, typename TSetter>
  class TAttribute : public ViewAttribute
  {
  public:
    using Getter = TGetter;
    using Setter = TSetter;
 
    // Constructor
    TAttribute(std::string const &iName, Getter iGetter, Setter iSetter) :
      ViewAttribute(iName),
#ifdef EDITOR_MODE
      fGetter{iGetter},
#endif
      fSetter{iSetter}
      { }
 
    // getType
    IViewCreator::AttrType getType() override
    {
      return IViewCreator::kUnknownType;
    }

    virtual bool fromString(IUIDescription const *iDescription, std::string const &iAttributeValue, T &oValue) const
    {
      return false;
    }

    bool apply(CView *iView, const UIAttributes &iAttributes, const IUIDescription *iDescription) override
    {
      auto *tv = dynamic_cast<TView *>(iView);
      if(tv != nullptr)
      {
        auto attributeValue = iAttributes.getAttributeValue(getName());
        if(attributeValue)
        {
          T value;
          if(fromString(iDescription, *attributeValue, value))
          {
            std::invoke(fSetter, tv, value);
            return true;
          }
        }
      }
      return false;
    }
 
#ifdef EDITOR_MODE
    virtual bool toString(IUIDescription const *iDescription, T const &iValue, std::string &oStringValue) const
    {
      return false;
    }
 

    bool getAttributeValue(CView *iView, const IUIDescription *iDescription, std::string &oStringValue) const override
    {
      auto *tv = dynamic_cast<TView *>(iView);
      if(tv != nullptr)
      {
        auto value = std::invoke(fGetter, tv);
        return toString(iDescription, value, oStringValue);
      }
      return false;
    }
 
  private:
    Getter fGetter;
#endif
 
  private:
    Setter fSetter;
  };

  template<typename T>
  using ByValAttribute = TAttribute<T, T (TView::*)() const, void (TView::*)(T)>;

  template<typename T>
  using ByRefAttribute = TAttribute<T, T const &(TView::*)() const, void (TView::*)(T const &)>;

  class TagAttribute : public ByValAttribute<TagID>
  {
  public:
    TagAttribute(std::string const &iName,
                 ByValAttribute<TagID>::Getter iGetter,
                 ByValAttribute<TagID>::Setter iSetter) :
      ByValAttribute<TagID>(iName, iGetter, iSetter) {}
 
    // getType
    IViewCreator::AttrType getType() override
    {
      return IViewCreator::kTagType;
    }
 
    // fromString
    bool fromString(IUIDescription const *iDescription, std::string const &iAttributeValue, TagID &oValue) const override
    {
      if(iAttributeValue.length() != 0)
      {
        auto tag = static_cast<TagID>(iDescription->getTagForName(iAttributeValue.c_str()));
        if(tag == UNDEFINED_TAG_ID)
        {
          char *endPtr = nullptr;
          tag = static_cast<TagID>(strtol(iAttributeValue.c_str(), &endPtr, 10));
          if(endPtr == iAttributeValue.c_str())
          {
            return false;
          }
        }
        oValue = tag;
      }
      else
        // when selecting "NONE" iAttributeValue is an empty string
        oValue = UNDEFINED_PARAM_ID;
 
      return true;
    }
 
#ifdef EDITOR_MODE
    // toString
    bool toString(IUIDescription const *iDescription, const TagID &iValue, std::string &oStringValue) const override
    {
      if(iValue != UNDEFINED_TAG_ID)
      {
        UTF8StringPtr controlTag = iDescription->lookupControlTagName(iValue);
        if(controlTag)
        {
          oStringValue = controlTag;
          return true;
        }
      }
 
      return false;
    }
#endif
  };

  template<Utils::IntegralOrEnum TInt>
  class IntegerAttribute : public ByValAttribute<TInt>
  {
  public:
    using Getter = ByValAttribute<TInt>::Getter;
    using Setter = ByValAttribute<TInt>::Setter;
 
    // Constructor
    IntegerAttribute(std::string const &iName, Getter iGetter, Setter iSetter) :
      ByValAttribute<TInt>(iName, iGetter, iSetter) {}
 
    // getType
    IViewCreator::AttrType getType() override
    {
      return IViewCreator::kIntegerType;
    }
 
    // fromString
    bool fromString(IUIDescription const *iDescription, std::string const &iAttributeValue, TInt &oValue) const override
    {
      char *endPtr = nullptr;
      auto value = static_cast<TInt>(strtol(iAttributeValue.c_str(), &endPtr, 10));
      if(endPtr == iAttributeValue.c_str())
      {
        DLOG_F(WARNING, "could not convert <%s> to an integer", iAttributeValue.c_str());
        return false;
      }
      oValue = value;
      return true;
    }
 
#ifdef EDITOR_MODE
    // toString
    bool toString(IUIDescription const *iDescription, const TInt &iValue, std::string &oStringValue) const override
    {
      std::stringstream str;
      str << iValue;
      oStringValue = str.str();
      return true;
    }
#endif
  };

  template<std::floating_point TFloat>
  class FloatAttribute : public ByValAttribute<TFloat>
  {
  public:
    using Getter = ByValAttribute<TFloat>::Getter;
    using Setter = ByValAttribute<TFloat>::Setter;
 
    // Constructor
    FloatAttribute(std::string const &iName, Getter iGetter, Setter iSetter) :
      ByValAttribute<TFloat>(iName, iGetter, iSetter) {}
 
    // getType
    IViewCreator::AttrType getType() override
    {
      return IViewCreator::kFloatType;
    }
 
    // fromString
    bool fromString(IUIDescription const *iDescription, std::string const &iAttributeValue, TFloat &oValue) const override
    {
      TFloat value;
      if(Utils::stringToFloat<TFloat>(iAttributeValue, value))
      {
        oValue = value;
        return true;
      }
      DLOG_F(WARNING, "could not convert <%s> to a float", iAttributeValue.c_str());
      return false;
    }
 
#ifdef EDITOR_MODE
    // toString
    bool toString(IUIDescription const *iDescription, const TFloat &iValue, std::string &oStringValue) const override
    {
      std::stringstream str;
      str << iValue;
      oStringValue = str.str();
      return true;
    }
#endif
  };

  class ColorAttribute : public ByRefAttribute<CColor>
  {
  public:
 
    // Constructor
    ColorAttribute(std::string const &iName,
                   ByRefAttribute<CColor>::Getter iGetter,
                   ByRefAttribute<CColor>::Setter iSetter) :
      ByRefAttribute<CColor>(iName, iGetter, iSetter) {}
 
    // getType
    IViewCreator::AttrType getType() override
    {
      return IViewCreator::kColorType;
    }
 
    // fromString
    bool fromString(IUIDescription const *iDescription, std::string const &iAttributeValue, CColor &oValue) const override
    {
      CColor color;
      if(UIViewCreator::stringToColor(&iAttributeValue, color, iDescription))
      {
        oValue = color;
        return true;
      }
      return false;
    }
 
#ifdef EDITOR_MODE
    // toString
    bool toString(IUIDescription const *iDescription, const CColor &iValue, std::string &oStringValue) const override
    {
      return UIViewCreator::colorToString(iValue, oStringValue, iDescription);
    }
#endif
  };

  class GradientAttribute : public ByValAttribute<GradientPtr>
  {
  public:
 
    // Constructor
    GradientAttribute(std::string const &iName,
                   ByValAttribute<GradientPtr>::Getter iGetter,
                   ByValAttribute<GradientPtr>::Setter iSetter) :
      ByValAttribute<GradientPtr>(iName, iGetter, iSetter) {}
 
    // getType
    IViewCreator::AttrType getType() override
    {
      return IViewCreator::kGradientType;
    }
 
    // fromString
    bool fromString(IUIDescription const *iDescription, std::string const &iAttributeValue, GradientPtr &oValue) const override
    {
      auto gradient = iDescription->getGradient(iAttributeValue.c_str());
      if(gradient)
      {
        oValue = gradient;
        return true;
      }
      return false;
    }
 
#ifdef EDITOR_MODE
    // toString
    bool toString(IUIDescription const *iDescription, GradientPtr const &iValue, std::string &oStringValue) const override
    {
      if(iValue)
      {
        auto name = iDescription->lookupGradientName(iValue);
        if(name)
        {
          oStringValue = name;
          return true;
        }
 
      }
      return false;
    }
#endif
  };

  class BooleanAttribute : public ByValAttribute<bool>
  {
  public:
    // Constructor
    BooleanAttribute(std::string const &iName,
                     ByValAttribute<bool>::Getter iGetter,
                     ByValAttribute<bool>::Setter iSetter) :
      ByValAttribute<bool>(iName, iGetter, iSetter) {}
 
    // getType
    IViewCreator::AttrType getType() override
    {
      return IViewCreator::kBooleanType;
    }
 
    // fromString
    bool fromString(IUIDescription const *iDescription, std::string const &iAttributeValue, bool &oValue) const override
    {
      if(iAttributeValue == "true")
      {
        oValue = true;
        return true;
      }
 
      if(iAttributeValue == "false")
      {
        oValue = false;
        return true;
      }
 
      return false;
    }
 
#ifdef EDITOR_MODE
    // toString
    bool toString(IUIDescription const *iDescription, const bool &iValue, std::string &oStringValue) const override
    {
      oStringValue = iValue ? "true" : "false";
      return true;
    }
#endif
  };

  class BitmapAttribute : public ByValAttribute<BitmapPtr>
  {
  public:
    // Constructor
    BitmapAttribute(std::string const &iName,
                    ByValAttribute<BitmapPtr>::Getter iGetter,
                    ByValAttribute<BitmapPtr>::Setter iSetter) :
      ByValAttribute<BitmapPtr>(iName, iGetter, iSetter) {}
 
    // getType
    IViewCreator::AttrType getType() override
    {
      return IViewCreator::kBitmapType;
    }
 
    // fromString
    bool fromString(IUIDescription const *iDescription, std::string const &iAttributeValue, BitmapPtr &oValue) const override
    {
      BitmapPtr bitmap;
      if(UIViewCreator::stringToBitmap(&iAttributeValue, bitmap, iDescription))
      {
        oValue = bitmap;
        return true;
      }
      return false;
    }
 
#ifdef EDITOR_MODE
    // toString
    bool toString(IUIDescription const *iDescription, BitmapPtr const &iValue, std::string &oStringValue) const override
    {
      if(iValue)
        return UIViewCreator::bitmapToString(iValue, oStringValue, iDescription);
      else
        return false;
    }
#endif
  };

  class FontAttribute : public ByValAttribute<FontPtr>
  {
  public:
    // Constructor
    FontAttribute(std::string const &iName,
                  ByValAttribute<FontPtr>::Getter iGetter,
                  ByValAttribute<FontPtr>::Setter iSetter) :
      ByValAttribute<FontPtr>(iName, iGetter, iSetter) {}
 
    // getType
    IViewCreator::AttrType getType() override
    {
      return IViewCreator::kFontType;
    }
 
    // fromString
    bool fromString(IUIDescription const *iDescription, std::string const &iAttributeValue, FontPtr &oValue) const override
    {
      auto font = iDescription->getFont(iAttributeValue.c_str());
      if(font)
      {
        oValue = font;
        return true;
      }
      return false;
    }
 
#ifdef EDITOR_MODE
    // toString
    bool toString(IUIDescription const *iDescription, FontPtr const &iValue, std::string &oStringValue) const override
    {
      if(iValue)
      {
        auto fontName = iDescription->lookupFontName(iValue);
        if(fontName)
        {
          oStringValue = fontName;
          return true;
        }
      }
      return false;
    }
#endif
  };

  class MarginAttribute : public ByRefAttribute<Margin>
  {
  public:
    MarginAttribute(std::string const &iName,
                    ByRefAttribute<Margin>::Getter iGetter,
                    ByRefAttribute<Margin>::Setter iSetter) :
      ByRefAttribute<Margin>(iName, iGetter, iSetter) {}
 
    // fromString
    bool fromString(IUIDescription const *iDescription, std::string const &iAttributeValue, Margin &oValue) const override
    {
      auto parts = Utils::splitFloats<CCoord>(iAttributeValue, ',');
 
      if(parts.empty())
        return false;
 
      // look for nan in the array
      if(std::find_if(parts.cbegin(), parts.cend(), [] (auto f) {return std::isnan(f);}) != parts.cend())
        return false;
 
      if(parts.size() == 1)
      {
        oValue = Margin{parts[0]};
      }
      else
      {
        if(parts.size() < 4)
          return false;
 
        oValue = Margin{parts[0], parts[1], parts[2], parts[3]};
      }
 
      return true;
    }
 
#ifdef EDITOR_MODE
    // toString
    bool toString(IUIDescription const *iDescription, const Margin &iValue, std::string &oStringValue) const override
    {
      std::stringstream str;
      if(iValue.fTop == iValue.fRight && iValue.fTop == iValue.fBottom && iValue.fTop == iValue.fLeft)
        str << iValue.fTop;
      else
      {
        str << iValue.fTop;
        str << ",";
        str << iValue.fRight;
        str << ",";
        str << iValue.fBottom;
        str << ",";
        str << iValue.fLeft;
      }
      oStringValue = str.str();
      return true;
    }
#endif
  };

  class RangeAttribute : public ByRefAttribute<Range>
  {
  public:
    RangeAttribute(std::string const &iName,
                   ByRefAttribute<Range>::Getter iGetter,
                   ByRefAttribute<Range>::Setter iSetter) :
      ByRefAttribute<Range>(iName, iGetter, iSetter) {}
 
    // fromString
    bool fromString(IUIDescription const *iDescription, std::string const &iAttributeValue, Range &oValue) const override
    {
      auto parts = Utils::splitFloats<CCoord>(iAttributeValue, ',');
 
      if(parts.empty())
        return false;
 
      // look for nan in the array
      if(std::find_if(parts.cbegin(), parts.cend(), [] (auto f) {return std::isnan(f);}) != parts.cend())
        return false;
 
      if(parts.size() == 1)
        oValue = Range{parts[0]};
      else
        oValue = Range{parts[0], parts[1]};
 
      return true;
    }
 
#ifdef EDITOR_MODE
    // toString
    bool toString(IUIDescription const *iDescription, const Range &iValue, std::string &oStringValue) const override
    {
      std::stringstream str;
      if(iValue.fFrom == iValue.fTo)
        str << iValue.fFrom;
      else
      {
        str << iValue.fFrom;
        str << ",";
        str << iValue.fTo;
      }
      oStringValue = str.str();
      return true;
    }
#endif
  };

  class VectorStringAttribute : public ByRefAttribute<std::vector<std::string>>
  {
    using super_type = ByRefAttribute<std::vector<std::string>>;
 
  public:
    // Constructor
    VectorStringAttribute(std::string const &iName,
                          super_type::Getter iGetter,
                          super_type::Setter iSetter,
                          char iDelimiter = ',',
                          bool iSkipEmptyEntries = false) :
      super_type(iName, iGetter, iSetter),
      fDelimiter{iDelimiter},
      fSkipEmptyEntries{iSkipEmptyEntries}
    {}
 
    // fromString
    bool fromString(IUIDescription const *iDescription,
                    std::string const &iAttributeValue,
                    std::vector<std::string> &oValue) const override
    {
      oValue = Utils::splitString(iAttributeValue, fDelimiter, fSkipEmptyEntries);
      return true;
    }
 
#ifdef EDITOR_MODE
    // toString
    bool toString(IUIDescription const *iDescription,
                  const std::vector<std::string> &iValue,
                  std::string &oStringValue) const override
    {
      oStringValue.clear();
      int i = 0;
      for(auto &entry : iValue)
      {
        if(i > 0)
          oStringValue += fDelimiter;
        if(!entry.empty() || !fSkipEmptyEntries)
        {
          oStringValue += entry;
          i++;
        }
      }
      return true;
    }
#endif
 
  protected:
    char fDelimiter;
    bool fSkipEmptyEntries;
  };

  template<typename T>
  class ListAttribute : public ByValAttribute<T>
  {
    using super_type = ByValAttribute<T>;
 
  public:
    // Constructor
    ListAttribute(std::string const &iName,
                  super_type::Getter iGetter,
                  super_type::Setter iSetter,
                  AttrValInitList<T> const &iAttributeValues) :
      super_type(iName, iGetter, iSetter),
      fAttributeValuesMap(iAttributeValues)
#ifdef EDITOR_MODE
      ,fAttributeValuesList{iAttributeValues}
#endif
    {
    }
 
    // getType
    IViewCreator::AttrType getType() override
    {
      return IViewCreator::kListType;
    }
 
    // fromString
    bool fromString(IUIDescription const *iDescription,
                    std::string const &iAttributeValue,
                    T &oValue) const override
    {
      if(fAttributeValuesMap.find(iAttributeValue) != fAttributeValuesMap.cend())
      {
        oValue = fAttributeValuesMap.at(iAttributeValue);
        return true;
      }
 
      DLOG_F(WARNING, "Attribute value '%s' is not valid for '%s'", iAttributeValue.c_str(), ViewAttribute::getName().c_str());
      return false;
    }
 
#ifdef EDITOR_MODE
    // toString
    bool toString(IUIDescription const *iDescription,
                  T const &iValue,
                  std::string &oStringValue) const override
    {
      auto pos = std::find_if(std::begin(fAttributeValuesList),
                              std::end(fAttributeValuesList),
                              [&iValue](auto entry) -> bool {
                                return entry.second == iValue;
                              });
      if(pos != std::end(fAttributeValuesList))
      {
        oStringValue = pos->first;
        return true;
      }
 
      return false;
    }
 
    // getPossibleListValues
    bool getPossibleListValues(std::list<const std::string *> &iValues) const override
    {
      for(auto const &p : fAttributeValuesList)
      {
        iValues.emplace_back(&p.first);
      }
      return true;
    }
#endif
 
  protected:
    AttrValMap<T> const fAttributeValuesMap;
#ifdef EDITOR_MODE
    std::vector<typename AttrValMap<T>::value_type> const fAttributeValuesList;
#endif
  };
 
public:
  // Constructor
  explicit TCustomViewCreator(char const *iViewName = nullptr,
                              char const *iDisplayName = nullptr,
                              char const *iBaseViewName = VSTGUI::UIViewCreator::kCView) :
    fViewName{iViewName},
    fDisplayName{iDisplayName},
    fBaseViewName{iBaseViewName},
    fAttributes{}
  {
    // this allows for inheritance!
    if(iViewName != nullptr && iDisplayName != nullptr)
      VSTGUI::UIViewFactory::registerViewCreator(*this);
  }
 
  // Destructor
  ~TCustomViewCreator() override
  {
    // we simply clear the map since it holds shared pointers which will be discarded when they are no longer
    // held by another object
    fAttributes.clear();
  }
 
  // getViewName
  IdStringPtr getViewName() const override
  {
    return fViewName;
  }
 
  // getDisplayName
  UTF8StringPtr getDisplayName() const override
  {
    return fDisplayName;
  }
 
  // getBaseViewName
  IdStringPtr getBaseViewName() const override
  {
    return fBaseViewName;
  }

  template<CViewSubclass XView>
  void registerAttributes(TCustomViewCreator<XView> const &iOther)
  {
    for(auto attribute : iOther.fAttributes)
    {
      registerAttribute(attribute.second);
    }
 
    if(std::string(fBaseViewName) == std::string(VSTGUI::UIViewCreator::kCView))
      fBaseViewName = iOther.fBaseViewName;
  }

  void registerColorAttribute(std::string const &iName,
                              ColorAttribute::Getter iGetter,
                              ColorAttribute::Setter iSetter)
  {
    registerAttribute<ColorAttribute>(iName, iGetter, iSetter);
  }

  void registerGradientAttribute(std::string const &iName,
                                 GradientAttribute::Getter iGetter,
                                 GradientAttribute::Setter iSetter)
  {
    registerAttribute<GradientAttribute>(iName, iGetter, iSetter);
  }

  void registerBitmapAttribute(std::string const &iName,
                               BitmapAttribute::Getter iGetter,
                               BitmapAttribute::Setter iSetter)
  {
    registerAttribute<BitmapAttribute>(iName, iGetter, iSetter);
  }

  void registerFontAttribute(std::string const &iName,
                             FontAttribute::Getter iGetter,
                             FontAttribute::Setter iSetter)
  {
    registerAttribute<FontAttribute>(iName, iGetter, iSetter);
  }

  void registerMarginAttribute(std::string const &iName,
                               MarginAttribute::Getter iGetter,
                               MarginAttribute::Setter iSetter)
  {
    registerAttribute<MarginAttribute>(iName, iGetter, iSetter);
  }

  void registerRangeAttribute(std::string const &iName,
                               RangeAttribute::Getter iGetter,
                               RangeAttribute::Setter iSetter)
  {
    registerAttribute<RangeAttribute>(iName, iGetter, iSetter);
  }

  void registerVectorStringAttribute(std::string const &iName,
                                     VectorStringAttribute::Getter iGetter,
                                     VectorStringAttribute::Setter iSetter,
                                     char iDelimiter = ',',
                                     bool iSkipEmptyEntries = false)
  {
    registerAttribute<VectorStringAttribute>(iName, iGetter, iSetter, iDelimiter, iSkipEmptyEntries);
  }

  template<typename T>
  void registerListAttribute(std::string const &iName,
                             ListAttribute<T>::Getter iGetter,
                             ListAttribute<T>::Setter iSetter,
                             AttrValInitList<T> const &iAttributeValues)
  {
    registerAttribute<ListAttribute<T>>(iName, iGetter, iSetter, iAttributeValues);
  }

  void registerTagAttribute(std::string const &iName,
                            TagAttribute::Getter iGetter,
                            TagAttribute::Setter iSetter)
  {
    registerAttribute<TagAttribute>(iName, iGetter, iSetter);
  }

  template<Utils::IntegralOrEnum TInt>
  void registerIntegerAttribute(std::string const &iName,
                                IntegerAttribute<TInt>::Getter iGetter,
                                IntegerAttribute<TInt>::Setter iSetter)
  {
    registerAttribute<IntegerAttribute<TInt>>(iName, iGetter, iSetter);
  }

  void registerIntAttribute(std::string const &iName,
                            IntegerAttribute<int32_t>::Getter iGetter,
                            IntegerAttribute<int32_t>::Setter iSetter)
  {
    registerIntegerAttribute<int32_t>(iName, iGetter, iSetter);
  }

  void registerFloatAttribute(std::string const &iName,
                              FloatAttribute<float>::Getter iGetter,
                              FloatAttribute<float>::Setter iSetter)
  {
    registerAttribute<FloatAttribute<float>>(iName, iGetter, iSetter);
  }

  void registerDoubleAttribute(std::string const &iName,
                               FloatAttribute<double>::Getter iGetter,
                               FloatAttribute<double>::Setter iSetter)
  {
    registerAttribute<FloatAttribute<double>>(iName, iGetter, iSetter);
  }

  void registerBooleanAttribute(std::string const &iName,
                                BooleanAttribute::Getter iGetter,
                                BooleanAttribute::Setter iSetter)
  {
    registerAttribute<BooleanAttribute>(iName, iGetter, iSetter);
  }

  CView *create(const UIAttributes &attributes, const IUIDescription *description) const override
  {
#ifdef JAMBA_DEBUG_LOGGING
    DLOG_F(INFO, "CustomViewCreator<%s>::create()", getViewName());
#endif
 
    return createCustomView<TView>(CRect(0, 0, 0, 0), attributes, description);
  }

  bool apply(CView *view, const UIAttributes &attributes, const IUIDescription *description) const override
  {
    auto *tv = dynamic_cast<TView *>(view);
 
    if(tv == nullptr)
      return false;
 
    for(auto attribute : fAttributes)
    {
      attribute.second->apply(tv, attributes, description);
    }
 
    return true;
  }
 
  // getAttributeNames
  bool getAttributeNames(std::list<std::string> &attributeNames) const override
  {
    for(auto attribute : fAttributes)
    {
      attributeNames.emplace_back(attribute.first);
    }
    return true;
  }
 
  // getAttributeType
  AttrType getAttributeType(const std::string &attributeName) const override
  {
    auto iter = fAttributes.find(attributeName);
    if(iter != fAttributes.cend())
    {
      return iter->second->getType();
    }
    return kUnknownType;
  }
 
#ifdef EDITOR_MODE
  bool getAttributeValue(CView *iView,
                         const std::string &iAttributeName,
                         std::string &oStringValue,
                         const IUIDescription *iDescription) const override
  {
    auto *cdv = dynamic_cast<TView *>(iView);
 
    if(cdv == nullptr)
      return false;
 
    auto iter = fAttributes.find(iAttributeName);
    if(iter != fAttributes.cend())
    {
      return iter->second->getAttributeValue(cdv, iDescription, oStringValue);
    }
 
    return false;
  }

  bool getPossibleListValues(const std::string &iAttributeName, std::list<const std::string *> &iValues) const override
  {
    auto iter = fAttributes.find(iAttributeName);
    if(iter != fAttributes.cend())
    {
      return iter->second->getPossibleListValues(iValues);
    }
    return false;
  }
#endif
 
private:
 
  // somehow this is required...
  template<typename XView>
  friend class TCustomViewCreator;

  void registerAttribute(std::shared_ptr<ViewAttribute> iAttribute)
  {
    // making sure there are no duplicates (cannot use loguru here!)
#ifndef NDEBUG
    assert(fAttributes.find(iAttribute->getName()) == fAttributes.cend());
#endif
    fAttributes[iAttribute->getName()] = std::move(iAttribute);
  }

  template<typename TViewAttribute, typename... Args>
  void registerAttribute(std::string const &iName,
                         TViewAttribute::Getter iGetter,
                         TViewAttribute::Setter iSetter,
                         Args&& ...iArgs)
  {
    std::shared_ptr<ViewAttribute> cva;
    cva.reset(new TViewAttribute(iName, iGetter, iSetter, std::forward<Args>(iArgs)...));
    registerAttribute(cva);
  }
 
 
  char const *fViewName;
  char const *fDisplayName;
  char const *fBaseViewName;
 
  // use a map of shared pointers so that they can easily be copied (see registerAttributes)
  std::map<std::string, std::shared_ptr<ViewAttribute>> fAttributes;
};
 
namespace impl {
  template<typename T>
  concept HasCreator =
    requires { typename T::Creator; } && std::default_initializable<typename T::Creator>; }

template<typename TView, typename TBaseView = void>
class CustomViewCreator : public TCustomViewCreator<TView>
{
public:
  explicit CustomViewCreator(char const *iViewName = nullptr,
                             char const *iDisplayName = nullptr,
                             char const *iBaseViewName = VSTGUI::UIViewCreator::kCView) :
    TCustomViewCreator<TView>(iViewName, iDisplayName, iBaseViewName)
  {
    if constexpr(impl::HasCreator<TBaseView>)
      TCustomViewCreator<TView>::registerAttributes(typename TBaseView::Creator());
  }
};
 
}