Utils.hpp

#pragma once

#include <QString>
#include <QVariant>

#include "GraphTypes.hpp"
#include "ShowcaseTypes.hpp"
#include "Export.hpp"
#include "Events.hpp"

#include <MultiTouch/MultiTouch.hpp>
#include <MultiWidgets/Widget.hpp>

namespace Showcase
{
  template <typename T> class ValueStream;

namespace Utils
{
  enum {
    OBJECT_GENERIC = 0x1,
    OBJECT_MENU = 0x1 << 1,
    OBJECT_EXCLUDE_FROM_SNAPSHOT = 0x1 << 2,
    OBJECT_ANNOTATION = 0x1 << 3
  };

  SHOWCASE_API QString protocol(const NodeId& id);
  SHOWCASE_API bool hasProtocol(const QString& url);
  SHOWCASE_API bool hasProtocol(const QString& url, const QString& protocol);
  SHOWCASE_API QString toString(const QVariant& variant);
  SHOWCASE_API QVariant readJson(const QString& path);

  SHOWCASE_API QByteArray formAssetKey(const QByteArray & refenceKey,
                                       const QByteArray & propertyKey);
  SHOWCASE_API QByteArray assetPrefix();

  SHOWCASE_API QString assetSearchPathName();

  SHOWCASE_API bool hasProtocol(const GraphNode& node, const QString& protocol);
  SHOWCASE_API bool hasProtocol(const NodeId& id, const QString& protocol);
  SHOWCASE_API QByteArray withoutProtocol(const NodeId& id);
  SHOWCASE_API QString constructFullFilePath(const QString& fullPath, const QString& relative);
  SHOWCASE_API void addCSSfile(const QString& path);
  SHOWCASE_API void removeCSSfile(const QString& path);

  SHOWCASE_API QByteArray pinnedWidgetCSSClass();
  SHOWCASE_API QByteArray pinToggleEventName();
  SHOWCASE_API QByteArray mouseModeCSSClass();
  SHOWCASE_API QByteArray mouseModeToggleEventName();
  SHOWCASE_API float uiHideScale();

  SHOWCASE_API QString temporaryWidgetCSSClass();

  SHOWCASE_API float getHandOrientation(const MultiTouch::Hand & hand);
  SHOWCASE_API float getHandInteractionOrientation(MultiWidgets::Widget & widget);

  SHOWCASE_API Nimble::Rect filteredChildrenRect(const MultiWidgets::Widget & w);
  SHOWCASE_API Nimble::Rect filteredWidgetSceneBounds(const MultiWidgets::Widget & w);

  template <typename T>
  struct IsGraphEvent {
    static const bool value = std::is_same<T, PropertyEvent>::value ||
                              std::is_same<T, NodeEvent>::value;
  };


  template <typename StreamType,
            typename T = typename StreamType::ValueType,
            typename = typename std::enable_if<std::is_base_of<ValueStream<T>, StreamType>::value>::type
            >
  void forEachSync(std::shared_ptr<StreamType> stream,
                   const std::function<void(const T&)>& f, int max=-1)
  {
    static_assert(IsGraphEvent<T>::value, "This function is only safe to"
                                          "use with NodeEvent or PropertyEvent.");

    static std::function<bool(const T&)> test = [](const T& ev) {
      return ev.isPending();
    };

    if(max < 0) {
      const int blockSize = 1000;
      int handled;
      do {
        handled = stream->forEachSync(f, blockSize, test);
      } while (handled == blockSize);
    } else {
      stream->forEachSync(f, max, test);
    }
  }

  template <typename T>
  FactoryKey<T> registerFactory(FactoryMap<T>& factories, const QString& name,
                                ShowcaseFactoryPtr<T> factory)
  {
    auto it = factories.find(name);
    if(it != factories.end()) {
      return factories.end();
    }
    return factories.insert(std::make_pair(name, factory)).first;
  }

  template <typename T>
  bool unregisterFactory(FactoryMap<T>& factories, FactoryKey<T> key)
  {
    if(key == factories.end()) {
      return false;
    }
    factories.erase(key);
    return true;
  }

  template<typename T>
  Radiant::IntrusivePtr<T> parentOfType(const MultiWidgets::Widget & w)
  {
    auto parent = w.parent();
    while(parent) {
      auto candidate = parent.dynamic_pointer_cast<T>();
      if(candidate)
        return candidate;
      parent = parent->parent();
    }
    return nullptr;
  }
}
}