qml_engine_functions.hpp

#pragma once
 
#include <ossia/dataflow/dataflow_fwd.hpp>
#include <ossia/dataflow/value_port.hpp>
#include <ossia/detail/hash_map.hpp>
#include <ossia/network/base/node_functions.hpp>
#include <ossia/network/common/path.hpp>
 
#include <ossia-qt/js_utilities.hpp>
 
#include <QObject>
#include <QQmlContext>
#include <QQmlEngine>
 
#include <functional>
#include <mutex>
#include <span>
 
#include <verdigris>
 
namespace ossia
{
struct value_port;
namespace net
{
class device_base;
}
}
namespace ossia::qt
{
using qml_device_cache = ossia::small_vector<ossia::net::device_base*, 4>;
using qml_device_push_function
    = smallfun::function<void(ossia::net::parameter_base&, const ossia::value_port&)>;
 
class OSSIA_EXPORT qml_engine_functions : public QObject
{
  W_OBJECT(qml_engine_functions)
public:
  qml_engine_functions(
      const qml_device_cache& state, qml_device_push_function push, QQmlEngine& engine, QObject* parent)
      : QObject{parent}
      , on_push{std::move(push)}
      , m_engine{engine}
      , m_devices{state}
  {
  }
 
  ~qml_engine_functions() override;
 
  QVariant read(const QString& address);
  W_SLOT(read);
  void write(const QString& address, const QVariant& value);
  W_SLOT(write);
  void exec(const QString& code) E_SIGNAL(OSSIA_EXPORT, exec, code);
  void compute(const QString& code, const QString& cb)
      E_SIGNAL(OSSIA_EXPORT, compute, code, cb);
  void system(const QString& code) E_SIGNAL(OSSIA_EXPORT, system, code);

  QVariant asArray(QVariant) const noexcept;
  W_SLOT(asArray)
  QVariant asColor(QVariant) const noexcept;
  W_SLOT(asColor)
  QVariant asVec2(QVariant) const noexcept;
  W_SLOT(asVec2)
  QVariant asVec3(QVariant) const noexcept;
  W_SLOT(asVec3)
  QVariant asVec4(QVariant) const noexcept;
  W_SLOT(asVec4)
 
  QJSValue toValue(QJSValue) const noexcept;
  W_SLOT(toValue)
 
  static ossia::net::node_base*
  find_node(qml_device_cache& devices, std::string_view name);

  ossia::net::node_base* find(const QString& address);

  void setDevice(ossia::net::device_base*);

  void setDevices(qml_device_cache devices);
  void addDevice(ossia::net::device_base* device);
  void removeDevice(ossia::net::device_base* device);

  void disable();
 
private:
  using device_span = std::span<ossia::net::device_base* const>;

  struct resolved_address
  {
    const ossia::destination_t& destination;
    device_span scope;
  };

  resolved_address find_address(const QString&);
 
  qml_device_push_function on_push;
  QQmlEngine& m_engine;
 
  ossia::hash_map<QString, ossia::destination_t> m_address_cache;
  ossia::value_port m_port_cache;
 
protected:
  void clear_address_cache() { m_address_cache.clear(); }

  std::recursive_mutex m_mutex;
  qml_device_cache m_devices;
  ossia::net::device_base* m_own_device{};
  bool m_enabled{true};
};
 
class OSSIA_EXPORT qml_device_engine_functions : public qml_engine_functions
{
  W_OBJECT(qml_device_engine_functions)
 
public:
  using qml_engine_functions::qml_engine_functions;
  ~qml_device_engine_functions();

  void addNode(QString address, QString type);
  W_SLOT(addNode)
 
  void removeNode(QString address, QString type);
  W_SLOT(removeNode)
 
  
  using tree_editor = std::function<void(std::function<void()>)>;
  void setTreeEditor(tree_editor);
 
private:
  void editTree(std::function<void(ossia::net::node_base& root)> edit);
 
  tree_editor m_tree_editor;
};
}