LayerHelpers.hpp

#pragma once
#include <Process/Dataflow/Port.hpp>
#include <Process/Dataflow/PortFactory.hpp>
#include <Process/Dataflow/PortItem.hpp>
#include <Process/Process.hpp>
#include <Process/ProcessContext.hpp>
 
#include <score/application/GUIApplicationContext.hpp>
 
#include <ossia/network/value/value_conversion.hpp>
 
#include <Process/Commands/SetControlValue.hpp>
 
#include <score/command/Dispatchers/MultiOngoingCommandDispatcher.hpp>
 
#include <QElapsedTimer>
#include <QGraphicsItem>
#include <QGraphicsSceneMouseEvent>
#include <QGuiApplication>
#include <QLineF>
#include <QStyleHints>
 
#include <Ui/Monitor/ModeSwitch.hpp>
 
#include <algorithm>
 
namespace Ui::Monitor
{
inline const Process::ControlInlet*
controlInlet(const Process::ProcessModel& p, std::size_t index) noexcept
{
  if(index < p.inlets().size())
    return qobject_cast<const Process::ControlInlet*>(p.inlets()[index]);
  return nullptr;
}
 
template <typename E>
E enumValue(const Process::ControlInlet* c, E fallback, E last) noexcept
{
  if(!c)
    return fallback;
  return static_cast<E>(std::clamp(ossia::convert<int>(c->value()), 0, int(last)));
}
 
inline float floatValue(const Process::ControlInlet* c, float fallback) noexcept
{
  return c ? ossia::convert<float>(c->value()) : fallback;
}
 
inline bool boolValue(const Process::ControlInlet* c, bool fallback) noexcept
{
  return c ? ossia::convert<bool>(c->value()) : fallback;
}
 
inline void showInlet(
    const Process::ProcessModel& p, std::size_t index, const Process::Context& doc,
    QGraphicsItem* parent, QObject* owner, double y = 5.)
{
  if(index >= p.inlets().size())
    return;
  auto* inlet = p.inlets()[index];
  const auto& factories = doc.app.interfaces<Process::PortFactoryList>();
  if(auto fact = factories.get(inlet->concreteKey()))
    if(auto port = fact->makePortItem(*inlet, doc, parent, owner))
      port->setPos(0, y);
}
 
template <typename Item, typename... C>
void repaintOn(Item* item, C*... controls)
{
  for(const Process::ControlInlet* c : {controls...})
    if(c)
      QObject::connect(
          c, &Process::ControlInlet::valueChanged, item, [item] { item->update(); });
}
 
class DoubleClick
{
public:
  bool operator()(const QGraphicsSceneMouseEvent& ev)
  {
    if(ev.button() != Qt::LeftButton)
      return false;
    const bool second
        = m_last.isValid()
          && m_last.elapsed() < QGuiApplication::styleHints()->mouseDoubleClickInterval()
          && QLineF(ev.screenPos(), m_pos).length() < 6.;
    if(second)
    {
      m_last.invalidate();
      return true;
    }
    m_last.restart();
    m_pos = ev.screenPos();
    return false;
  }
 
private:
  QElapsedTimer m_last;
  QPoint m_pos;
};
 
inline void setControls(
    const score::CommandStackFacade& stack,
    std::initializer_list<std::pair<const Process::ControlInlet*, ossia::value>> values)
{
  MultiOngoingCommandDispatcher disp{stack};
  bool any = false;
  for(const auto& [c, v] : values)
    if(c)
    {
      disp.submit(new Process::SetControlValue{*c, v});
      any = true;
    }
  if(any)
    disp.commit<Process::SetControlValues>();
}
}