34154826796

Committed 07 Sep 2026 07:14PM UTC coverage: 28.003% (+1.6%) from 26.366%

Build # 34154826796

Build Type

push

github

Committed by

jcelerier

Commit Message

dataflow: refilling a combo box's items is not a domain change

Dragging a control that causes a combo box to be refilled moved the value by
one step and then stopped, left a widget behind, and could leave a right-click
editor on the scene that nothing would close again.

setAlternatives restated the domain, and DefaultEffectItem answers
domainChanged by deleting every control of the process and rebuilding them from
the event loop. So the sequence was: drag the control -> the running object
refills the combo box -> setDomain -> domainChanged -> the control being
dragged is destroyed. The pointer then had nothing to drag, and anything the
destroyed control had put on the scene outlived the item that knew how to take
it down.

The item list is what changed, and alternativesChanged already says so -- the
widgets rebuild from it in place. The domain still follows the items for
whoever reads it later; it just no longer claims the control's shape changed.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018oUFSPD1bswcWtvrsq25t3

Coverage Stats

2 of 2 new or added lines in 2 files covered. (100.0%)

1657 existing lines in 32 files now uncovered.

66180 of 236333 relevant lines covered (28.0%)

63513.54 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

52.34

/src/plugins/score-lib-process/Process/Dataflow/WidgetInlets.cpp

#include <Process/Dataflow/WidgetInlets.hpp>

#include <score/plugins/SerializableHelpers.hpp>
#include <score/tools/FileWatch.hpp>

#include <ossia/dataflow/port.hpp>

#include <ossia-qt/invoke.hpp>

#include <QCoreApplication>
#include <QDir>
#include <QFileSystemWatcher>

#include <wobjectimpl.h>

W_OBJECT_IMPL(Process::ComboBox)
W_OBJECT_IMPL(Process::FileChooserBase)
W_OBJECT_IMPL(Process::FileChooser)
W_OBJECT_IMPL(Process::FolderChooser)
W_OBJECT_IMPL(Process::AudioFileChooser)
W_OBJECT_IMPL(Process::VideoFileChooser)
W_OBJECT_IMPL(Process::ImpulseButton)
namespace Process
{
Enum::Enum(
    const std::vector<std::string>& dom, std::vector<QString> pixmaps, std::string init,
    const QString& name, Id<Port> id, QObject* parent)
    : ControlInlet{name, id, parent}
    , pixmaps{std::move(pixmaps)}
{
  for(auto& val : dom)
    values.push_back(QString::fromStdString(val));

  displayHandledExplicitly = true;
  setInit(init);
  setValue(init);
  setDomain(State::Domain{ossia::domain_base<std::string>{dom}});
}

Enum::Enum(
    const QStringList& values, std::vector<QString> pixmaps, std::string init,
    const QString& name, Id<Port> id, QObject* parent)
    : ControlInlet{name, id, parent}
    , values{values.begin(), values.end()}
    , pixmaps{std::move(pixmaps)}
{
  displayHandledExplicitly = true;
  setInit(init);
  setValue(init);
  ossia::domain_base<std::string> dom;
  for(auto& val : values)
    dom.values.push_back(val.toStdString());
  setDomain(State::Domain{dom});
}

Enum::~Enum() { }

Enum::Enum(DataStream::Deserializer& vis, QObject* parent)
    : ControlInlet{vis, parent}
{
  vis.writeTo(*this);
}
Enum::Enum(JSONObject::Deserializer& vis, QObject* parent)
    : ControlInlet{vis, parent}
{
  vis.writeTo(*this);
}
Enum::Enum(DataStream::Deserializer&& vis, QObject* parent)
    : ControlInlet{vis, parent}
{
  vis.writeTo(*this);
}
Enum::Enum(JSONObject::Deserializer&& vis, QObject* parent)
    : ControlInlet{vis, parent}
{
  vis.writeTo(*this);
}

void Enum::setupExecution(ossia::inlet& inl, QObject* exec_context) const noexcept
{
  auto& port = **safe_cast<ossia::value_inlet*>(&inl);
  port.type = ossia::val_type::STRING;
  port.domain = domain().get();
}

ComboBox::ComboBox(DataStream::Deserializer& vis, QObject* parent)
    : ControlInlet{vis, parent}
{
  vis.writeTo(*this);
}
ComboBox::ComboBox(
    std::vector<std::pair<QString, ossia::value>> values, ossia::value init,
    const QString& name, Id<Port> id, QObject* parent)
    : ControlInlet{name, id, parent}
    , alternatives{std::move(values)}
{
  displayHandledExplicitly = true;
  setInit(init);
  setValue(init);
  std::vector<ossia::value> vals;
  for(auto& v : alternatives)
    vals.push_back(v.second);
  setDomain(State::Domain{ossia::make_domain(vals)});
}

void ComboBox::setupExecution(ossia::inlet& inl, QObject* exec_context) const noexcept
{
  auto& port = **safe_cast<ossia::value_inlet*>(&inl);
  port.domain = domain().get();
}

void ComboBox::repopulateFromFolder(const QString& folderPath)
{
  std::vector<std::pair<QString, ossia::value>> alts;
  if(!folderPath.isEmpty())
  {
    QDir dir(folderPath);
    const auto files = fileExtensions.isEmpty()
                           ? dir.entryList(QDir::Files, QDir::Name)
                           : dir.entryList(fileExtensions, QDir::Files, QDir::Name);
    for(const auto& f : files)
      alts.emplace_back(f, f.toStdString()); // value = the file name itself
  }
  if(alts.empty())
    alts.emplace_back(QStringLiteral("-"), std::string("-"));
  setAlternatives(std::move(alts));

  // Watch the folder so files created while the document is open (e.g. by an
  // upstream process writing its analysis) appear in the list right away.
  if(folderPath != m_watchedFolder)
  {
    if(m_folderWatcher)
    {
      delete m_folderWatcher;
      m_folderWatcher = nullptr;
    }
    m_watchedFolder = folderPath;
    if(!folderPath.isEmpty() && QDir{folderPath}.exists())
    {
      m_folderWatcher = new QFileSystemWatcher{{folderPath}, this};
      connect(
          m_folderWatcher, &QFileSystemWatcher::directoryChanged, this,
          [this](const QString& path) { repopulateFromFolder(path); });
    }
  }
}

void ComboBox::setAlternatives(std::vector<std::pair<QString, ossia::value>> values)
{
  if(values == alternatives)
    return;
  alternatives = std::move(values);

  std::vector<ossia::value> vals;
  for(auto& v : alternatives)
    vals.push_back(v.second);
  // Not setDomain(): what changed is the item list, and alternativesChanged
  // below says exactly that. Announcing a domain change instead makes the
  // effect item rebuild every control of the process, which kills whatever
  // edit is in flight -- and for a combo box refilled from the running score,
  // that includes the control the user is dragging to refill it.
  setDomainWithoutNotifying(State::Domain{ossia::make_domain(vals)});

  // Keep the current value if it is still in the list; otherwise fall back to
  // the init value when available. A value absent from the list is left
  // untouched: for folder-backed comboboxes it may name a file that simply
  // does not exist *yet* — it becomes selectable (and shows up as selected)
  // once the file appears.
  if(!alternatives.empty())
  {
    auto in_list = [this](const ossia::value& v) {
      return ossia::find_if(
                 alternatives, [&](const auto& pair) { return pair.second == v; })
             != alternatives.end();
    };
    if(!in_list(value()) && in_list(init()))
      setValue(init());
  }

  alternativesChanged();
}

ComboBox::~ComboBox() { }

ComboBox::ComboBox(JSONObject::Deserializer& vis, QObject* parent)
    : ControlInlet{vis, parent}
{
  vis.writeTo(*this);
}
ComboBox::ComboBox(DataStream::Deserializer&& vis, QObject* parent)
    : ControlInlet{vis, parent}
{
  vis.writeTo(*this);
}
ComboBox::ComboBox(JSONObject::Deserializer&& vis, QObject* parent)
    : ControlInlet{vis, parent}
{
  vis.writeTo(*this);
}

HSVSlider::HSVSlider(
    ossia::vec4f init, const QString& name, Id<Port> id, QObject* parent)
    : ControlInlet{name, id, parent}
{
  displayHandledExplicitly = true;
  setInit(init);
  setValue(init);
}

HSVSlider::~HSVSlider() { }

const State::Unit& HSVSlider::unit() const noexcept
{
  static const State::Unit u{ossia::unit_t{ossia::rgba_u{}}};
  return u;
}

FloatSlider::FloatSlider(
    float min, float max, float init, const QString& name, Id<Port> id, QObject* parent)
    : ControlInlet{name, id, parent}
{
  displayHandledExplicitly = true;
  setInit(init);
  setValue(init);
  setDomain(ossia::make_domain(min, max));
}

FloatSlider::~FloatSlider() { }

void FloatSlider::setupExecution(ossia::inlet& inl, QObject* exec_context) const noexcept
{
  auto& port = **safe_cast<ossia::value_inlet*>(&inl);
  port.type = ossia::val_type::FLOAT;
  port.domain = domain().get();
}

FloatKnob::FloatKnob(
    float min, float max, float init, const QString& name, Id<Port> id, QObject* parent)
    : ControlInlet{name, id, parent}
{
  displayHandledExplicitly = true;
  setInit(init);
  setValue(init);
  setDomain(ossia::make_domain(min, max));
}

FloatKnob::~FloatKnob() { }

void FloatKnob::setupExecution(ossia::inlet& inl, QObject* exec_context) const noexcept
{
  auto& port = **safe_cast<ossia::value_inlet*>(&inl);
  port.type = ossia::val_type::FLOAT;
  port.domain = domain().get();
}

LogFloatSlider::LogFloatSlider(
    float min, float max, float init, const QString& name, Id<Port> id, QObject* parent)
    : ControlInlet{name, id, parent}
{
  displayHandledExplicitly = true;
  setInit(init);
  setValue(init);
  setDomain(ossia::make_domain(min, max));
}

LogFloatSlider::~LogFloatSlider() { }

void LogFloatSlider::setupExecution(
    ossia::inlet& inl, QObject* exec_context) const noexcept
{
  auto& port = **safe_cast<ossia::value_inlet*>(&inl);
  port.type = ossia::val_type::FLOAT;
  port.domain = domain().get();
}

IntSlider::IntSlider(
    int min, int max, int init, const QString& name, Id<Port> id, QObject* parent)
    : ControlInlet{name, id, parent}
{
  displayHandledExplicitly = true;
  setInit(init);
  setValue(init);
  setDomain(ossia::make_domain(min, max));
}

IntSlider::~IntSlider() { }

void IntSlider::setupExecution(ossia::inlet& inl, QObject* exec_context) const noexcept
{
  auto& port = **safe_cast<ossia::value_inlet*>(&inl);
  port.type = ossia::val_type::INT;
  port.domain = domain().get();
}

IntRangeSlider::IntRangeSlider(
    int min, int max, ossia::vec2f init, const QString& name, Id<Port> id,
    QObject* parent)
    : ControlInlet{name, id, parent}
{
  displayHandledExplicitly = true;
  setInit(init);
  setValue(init);
  setDomain(ossia::make_domain(min, max));
}

IntRangeSlider::~IntRangeSlider() { }

void IntRangeSlider::setupExecution(
    ossia::inlet& inl, QObject* exec_context) const noexcept
{
  auto& port = **safe_cast<ossia::value_inlet*>(&inl);
  port.type = ossia::val_type::VEC2F;
  port.domain = domain().get();
}

FloatRangeSlider::FloatRangeSlider(
    float min, float max, ossia::vec2f init, const QString& name, Id<Port> id,
    QObject* parent)
    : ControlInlet{name, id, parent}
{
  displayHandledExplicitly = true;
  setInit(init);
  setValue(init);
  setDomain(ossia::make_domain(min, max));
}

FloatRangeSlider::~FloatRangeSlider() { }

void FloatRangeSlider::setupExecution(
    ossia::inlet& inl, QObject* exec_context) const noexcept
{
  auto& port = **safe_cast<ossia::value_inlet*>(&inl);
  port.type = ossia::val_type::VEC2F;
  port.domain = domain().get();
}

IntRangeSpinBox::IntRangeSpinBox(
    int min, int max, ossia::vec2f init, const QString& name, Id<Port> id,
    QObject* parent)
    : ControlInlet{name, id, parent}
{
  displayHandledExplicitly = true;
  setInit(init);
  setValue(init);
  setDomain(ossia::make_domain(min, max));
}
IntRangeSpinBox::~IntRangeSpinBox() { }

void IntRangeSpinBox::setupExecution(
    ossia::inlet& inl, QObject* exec_context) const noexcept
{
  auto& port = **safe_cast<ossia::value_inlet*>(&inl);
  port.type = ossia::val_type::VEC2F;
  port.domain = domain().get();
}

FloatRangeSpinBox::FloatRangeSpinBox(
    float min, float max, ossia::vec2f init, const QString& name, Id<Port> id,
    QObject* parent)
    : ControlInlet{name, id, parent}
{
  displayHandledExplicitly = true;
  setInit(init);
  setValue(init);
  setDomain(ossia::make_domain(min, max));
}

FloatRangeSpinBox::~FloatRangeSpinBox() { }

void FloatRangeSpinBox::setupExecution(
    ossia::inlet& inl, QObject* exec_context) const noexcept
{
  auto& port = **safe_cast<ossia::value_inlet*>(&inl);
  port.type = ossia::val_type::VEC2F;
  port.domain = domain().get();
}

IntSpinBox::IntSpinBox(
    int min, int max, int init, const QString& name, Id<Port> id, QObject* parent)
    : ControlInlet{name, id, parent}
{
  displayHandledExplicitly = true;
  setInit(init);
  setValue(init);
  setDomain(ossia::make_domain(min, max));
}

void IntSpinBox::setupExecution(ossia::inlet& inl, QObject* exec_context) const noexcept
{
  auto& port = **safe_cast<ossia::value_inlet*>(&inl);
  port.type = ossia::val_type::INT;
  port.domain = domain().get();
}

IntSpinBox::~IntSpinBox() { }

FloatSpinBox::FloatSpinBox(
    float min, float max, float init, const QString& name, Id<Port> id, QObject* parent)
    : ControlInlet{name, id, parent}
{
  displayHandledExplicitly = true;
  setInit(init);
  setValue(init);
  setDomain(ossia::make_domain(min, max));
}

void FloatSpinBox::setupExecution(
    ossia::inlet& inl, QObject* exec_context) const noexcept
{
  auto& port = **safe_cast<ossia::value_inlet*>(&inl);
  port.type = ossia::val_type::FLOAT;
  port.domain = domain().get();
}

FloatSpinBox::~FloatSpinBox() { }

TimeChooser::TimeChooser(
    float min, float max, float init, const QString& name, Id<Port> id, QObject* parent)
    : ControlInlet{name, id, parent}
{
  displayHandledExplicitly = true;
  setValue(ossia::vec2f{init, 1.f});
  setInit(value());
  setDomain(ossia::make_domain(ossia::vec2f{min, 0.f}, ossia::vec2f{max, 1.f}));
}

TimeChooser::~TimeChooser() { }

void TimeChooser::setupExecution(ossia::inlet& inl, QObject* exec_context) const noexcept
{
  auto& port = **safe_cast<ossia::value_inlet*>(&inl);
  port.type = ossia::val_type::VEC2F;
  // port.type = ossia::second_u{};
  // port.domain = domain().get();
}

Toggle::Toggle(bool init, const QString& name, Id<Port> id, QObject* parent)
    : ControlInlet{name, id, parent}
{
  displayHandledExplicitly = true;
  setInit(init);
  setValue(init);
  setDomain(State::Domain{ossia::domain_base<bool>{}});
}

void Toggle::setupExecution(ossia::inlet& inl, QObject* exec_context) const noexcept
{
  auto& port = **safe_cast<ossia::value_inlet*>(&inl);
  port.type = ossia::val_type::BOOL;
  port.domain = domain().get();
}

Toggle::~Toggle() { }

ChooserToggle::ChooserToggle(
    QStringList alternatives, bool init, const QString& name, Id<Port> id,
    QObject* parent)
    : ControlInlet{name, id, parent}
{
  displayHandledExplicitly = true;
  setValue(init ? alternatives[1].toStdString() : alternatives[0].toStdString());
  setInit(value());
  setDomain(
      State::Domain{ossia::domain_base<std::string>{
          {alternatives[0].toStdString(), alternatives[1].toStdString()}}});
}

void ChooserToggle::setupExecution(
    ossia::inlet& inl, QObject* exec_context) const noexcept
{
  auto& port = **safe_cast<ossia::value_inlet*>(&inl);
  port.type = ossia::val_type::STRING;
  port.domain = domain().get();
}

ChooserToggle::~ChooserToggle() { }

QStringList ChooserToggle::alternatives() const noexcept
{
  const auto& dom = *this->domain().get().v.target<ossia::domain_base<std::string>>();
  auto it = dom.values.begin();
  auto& s1 = *it;
  auto& s2 = *(++it);
  return {QString::fromStdString(s1), QString::fromStdString(s2)};
}

LineEdit::LineEdit(QString init, const QString& name, Id<Port> id, QObject* parent)
    : ControlInlet{name, id, parent}
{
  displayHandledExplicitly = true;
  setValue(init.toStdString());
  setInit(value());
}

void LineEdit::setupExecution(ossia::inlet& inl, QObject* exec_context) const noexcept
{
  auto& port = **safe_cast<ossia::value_inlet*>(&inl);
  port.type = ossia::val_type::STRING;
  port.domain = domain().get();
}

LineEdit::~LineEdit() { }

ProgramEdit::ProgramEdit(QString init, const QString& name, Id<Port> id, QObject* parent)
    : ControlInlet{name, id, parent}
{
  displayHandledExplicitly = true;
  setValue(init.toStdString());
  setInit(value());
}

void ProgramEdit::setupExecution(ossia::inlet& inl, QObject* exec_context) const noexcept
{
  auto& port = **safe_cast<ossia::value_inlet*>(&inl);
  port.type = ossia::val_type::STRING;
  port.domain = domain().get();
}

ProgramEdit::~ProgramEdit() { }

FileChooserBase::FileChooserBase(
    QString init, QString filters, const QString& name, Id<Port> id, QObject* parent)
    : ControlInlet{name, id, parent}
{
  displayHandledExplicitly = true;
  setValue(init.toStdString());
  setInit(value());
  m_filters = filters;
}

void FileChooserBase::setupExecution(
    ossia::inlet& inl, QObject* exec_context) const noexcept
{
  auto& port = **safe_cast<ossia::value_inlet*>(&inl);
  port.type = ossia::val_type::STRING;
  port.domain = domain().get();
}

void FileChooserBase::enableFileWatch()
{
  auto fun = std::make_shared<std::function<void()>>([ptr = QPointer{this}]() mutable {
    ossia::qt::run_async(qApp, [ptr] {
      if(ptr)
      {
        // This will trigger a reload
        // FIXME make it work with execution value changes
        ptr->valueChanged(ptr->value());
      }
    });
  });

  auto& f = score::FileWatch::instance();
  f.add(QString::fromStdString(ossia::convert<std::string>(this->value())), fun);

  connect(
      this, &Process::FileChooser::valueChanged, this,
      [cur_s = ossia::convert<std::string>(this->value()),
       fun](const ossia::value& v) mutable {
    auto new_s = ossia::convert<std::string>(v);
    if(new_s != cur_s)
    {
      auto& f = score::FileWatch::instance();
      f.remove(QString::fromStdString(cur_s), fun);
      f.add(QString::fromStdString(new_s), fun);
      cur_s = new_s;
    }
      });

  connect(this, &Process::FileChooser::destroying, this, [this, fun] {
    auto& f = score::FileWatch::instance();
    f.remove(QString::fromStdString(ossia::convert<std::string>(this->value())), fun);
  });
}

FileChooserBase::~FileChooserBase()
{
  destroying();
}

FileChooser::FileChooser(
    QString init, QString filters, const QString& name, Id<Port> id, QObject* parent)
    : FileChooserBase{init, filters, name, id, parent}
{
}

FileChooser::~FileChooser() { }

FolderChooser::FolderChooser(
    QString init, const QString& name, Id<Port> id, QObject* parent)
    : Process::ControlInlet{name, id, parent}
{
  displayHandledExplicitly = true;
  setValue(init.toStdString());
  setInit(value());
}

void FolderChooser::setupExecution(
    ossia::inlet& inl, QObject* exec_context) const noexcept
{
  auto& port = **safe_cast<ossia::value_inlet*>(&inl);
  port.type = ossia::val_type::STRING;
  port.domain = domain().get();
}

FolderChooser::~FolderChooser() { }

AudioFileChooser::AudioFileChooser(
    QString init, QString filters, const QString& name, Id<Port> id, QObject* parent)
    : FileChooserBase{init, filters, name, id, parent}
{
}

AudioFileChooser::~AudioFileChooser() { }

static QString toFilters(const QSet<QString>& exts)
{
  QString res;
  for(const auto& s : exts)
  {
    res += "*.";
    res += s;
    res += " ";
  }
  if(!res.isEmpty())
    res.resize(res.size() - 1);
  return res;
}

static QString videoFilesTypes()
{
  // FIXME refactor supported formats with Video process
  QSet<QString> files = {"mkv", "mov", "mp4", "h264", "avi", "hap",  "mpg", "mpeg",
                          "imf", "mxf", "mts", "m2ts", "mj2", "webm", "y4m", "nut", "ts"};
  return QString{"Videos (%1)"}.arg(toFilters(files));
}

VideoFileChooser::VideoFileChooser(
    QString init, QString filters, const QString& name, Id<Port> id, QObject* parent)
    : FileChooserBase{init, videoFilesTypes(), name, id, parent}
{
}

VideoFileChooser::~VideoFileChooser() { }

Button::Button(const QString& name, Id<Port> id, QObject* parent)
    : ControlInlet{name, id, parent}
{
  displayHandledExplicitly = true;
  setValue(false);
  setInit(false);
  setDomain(State::Domain{ossia::domain_base<bool>{}});
}

void Button::setupExecution(ossia::inlet& inl, QObject* exec_context) const noexcept
{
  auto& port = **safe_cast<ossia::value_inlet*>(&inl);
  port.type = ossia::val_type::BOOL;
  port.domain = domain().get();
}

Button::~Button() { }

ImpulseButton::ImpulseButton(const QString& name, Id<Port> id, QObject* parent)
    : ControlInlet{name, id, parent}
{
  displayHandledExplicitly = true;
  setValue(ossia::impulse{});
  setInit(ossia::impulse{});
  setDomain(State::Domain{ossia::domain_base<ossia::impulse>{}});
}

void ImpulseButton::setupExecution(
    ossia::inlet& inl, QObject* exec_context) const noexcept
{
  auto& port = **safe_cast<ossia::value_inlet*>(&inl);
  port.type = ossia::val_type::IMPULSE;
  port.domain = domain().get();
}

ImpulseButton::~ImpulseButton() { }

XYSlider::XYSlider(ossia::vec2f init, const QString& name, Id<Port> id, QObject* parent)
    : ControlInlet{name, id, parent}
{
  displayHandledExplicitly = true;
  setValue(init);
  setInit(init);
  setDomain(ossia::make_domain(ossia::vec2f{0., 0.}, ossia::vec2f{1., 1.}));
}

XYSlider::XYSlider(
    ossia::vec2f min, ossia::vec2f max, ossia::vec2f init, const QString& name,
    Id<Port> id, QObject* parent)
    : ControlInlet{name, id, parent}
{
  displayHandledExplicitly = true;
  setValue(init);
  setInit(init);
  setDomain(ossia::make_domain(min, max));
}

void XYSlider::setupExecution(ossia::inlet& inl, QObject* exec_context) const noexcept
{
  auto& port = **safe_cast<ossia::value_inlet*>(&inl);
  port.type = ossia::val_type::VEC2F;
  port.domain = domain().get();
}

XYSlider::~XYSlider() { }

XYZSlider::XYZSlider(
    ossia::vec3f init, const QString& name, Id<Port> id, QObject* parent)
    : ControlInlet{name, id, parent}
{
  displayHandledExplicitly = true;
  setValue(init);
  setInit(init);
  setDomain(ossia::make_domain(ossia::vec3f{0., 0., 0.}, ossia::vec3f{1., 1., 1.}));
}

XYZSlider::XYZSlider(
    ossia::vec3f min, ossia::vec3f max, ossia::vec3f init, const QString& name,
    Id<Port> id, QObject* parent)
    : ControlInlet{name, id, parent}
{
  displayHandledExplicitly = true;
  setValue(init);
  setInit(init);
  setDomain(ossia::make_domain(min, max));
}

XYZSlider::~XYZSlider() { }

void XYZSlider::setupExecution(ossia::inlet& inl, QObject* exec_context) const noexcept
{
  auto& port = **safe_cast<ossia::value_inlet*>(&inl);
  port.type = ossia::val_type::VEC3F;
  port.domain = domain().get();
}

XYZSpinboxes::XYZSpinboxes(
    ossia::vec3f init, const QString& name, Id<Port> id, QObject* parent)
    : ControlInlet{name, id, parent}
{
  displayHandledExplicitly = true;
  setValue(init);
  setInit(init);
  setDomain(ossia::make_domain(ossia::vec3f{0., 0., 0.}, ossia::vec3f{1., 1., 1.}));
}

XYSpinboxes::XYSpinboxes(
    ossia::vec2f init, const QString& name, Id<Port> id, QObject* parent)
    : ControlInlet{name, id, parent}
    , integral{false}
{
  displayHandledExplicitly = true;
  setValue(init);
  setInit(init);
}
XYSpinboxes::XYSpinboxes(
    ossia::vec2f min, ossia::vec2f max, ossia::vec2f init, bool integral,
    const QString& name, Id<Port> id, QObject* parent)
    : ControlInlet{name, id, parent}
    , integral{integral}
{
  displayHandledExplicitly = true;
  setValue(init);
  setInit(init);
  setDomain(ossia::make_domain(min, max));
}

XYSpinboxes::XYSpinboxes(DataStream::Deserializer& vis, QObject* parent)
    : ControlInlet{vis, parent}
{
  vis.writeTo(*this);
}
XYSpinboxes::XYSpinboxes(JSONObject::Deserializer& vis, QObject* parent)
    : ControlInlet{vis, parent}
{
  vis.writeTo(*this);
}
XYSpinboxes::XYSpinboxes(DataStream::Deserializer&& vis, QObject* parent)
    : ControlInlet{vis, parent}
{
  vis.writeTo(*this);
}
XYSpinboxes::XYSpinboxes(JSONObject::Deserializer&& vis, QObject* parent)
    : ControlInlet{vis, parent}
{
  vis.writeTo(*this);
}

XYSpinboxes::~XYSpinboxes() { }

void XYSpinboxes::setupExecution(ossia::inlet& inl, QObject* exec_context) const noexcept
{
  auto& port = **safe_cast<ossia::value_inlet*>(&inl);
  port.type = ossia::val_type::VEC2F;
  port.domain = domain().get();
}

XYZSpinboxes::XYZSpinboxes(
    ossia::vec3f min, ossia::vec3f max, ossia::vec3f init, bool integral,
    const QString& name, Id<Port> id, QObject* parent)
    : ControlInlet{name, id, parent}
    , integral{integral}
{
  displayHandledExplicitly = true;
  setValue(init);
  setInit(init);
  setDomain(ossia::make_domain(min, max));
}

XYZSpinboxes::~XYZSpinboxes() { }

void XYZSpinboxes::setupExecution(
    ossia::inlet& inl, QObject* exec_context) const noexcept
{
  auto& port = **safe_cast<ossia::value_inlet*>(&inl);
  port.type = ossia::val_type::VEC3F;
  port.domain = domain().get();
}

MultiSlider::MultiSlider(
    ossia::value init, const QString& name, Id<Port> id, QObject* parent)
    : ControlInlet{name, id, parent}
{
  displayHandledExplicitly = true;
  setValue(std::move(init));
  setInit(value());
  setDomain(ossia::make_domain(0., 1.));
}

MultiSlider::~MultiSlider() { }

ossia::value MultiSlider::getMin() const noexcept
{
  return domain().get().get_min();
}

ossia::value MultiSlider::getMax() const noexcept
{
  return domain().get().get_max();
}

void MultiSlider::setupExecution(ossia::inlet& inl, QObject* exec_context) const noexcept
{
  auto& port = **safe_cast<ossia::value_inlet*>(&inl);
  port.type = ossia::val_type::LIST;
  port.domain = domain().get();
}

MultiSliderXY::MultiSliderXY(
    ossia::value init, const QString& name, Id<Port> id, QObject* parent)
    : ControlInlet{name, id, parent}
{
  displayHandledExplicitly = true;
  setValue(std::move(init));
  setInit(value());
  setDomain(ossia::make_domain(0., 1.));
}

MultiSliderXY::~MultiSliderXY() { }

ossia::value MultiSliderXY::getMin() const noexcept
{
  return domain().get().get_min();
}

ossia::value MultiSliderXY::getMax() const noexcept
{
  return domain().get().get_max();
}

void MultiSliderXY::setupExecution(ossia::inlet& inl, QObject* exec_context) const noexcept
{
  auto& port = **safe_cast<ossia::value_inlet*>(&inl);
  port.type = ossia::val_type::LIST;
  port.domain = domain().get();
}

PathGeneratorXY::PathGeneratorXY(
    ossia::value init, const QString& name, Id<Port> id, QObject* parent)
    : ControlInlet{name, id, parent}
{
  displayHandledExplicitly = true;
  setValue(std::move(init));
  setInit(value());
  setDomain(ossia::make_domain(0., 1.));
}

PathGeneratorXY::~PathGeneratorXY() { }

ossia::value PathGeneratorXY::getMin() const noexcept
{
  return domain().get().get_min();
}

ossia::value PathGeneratorXY::getMax() const noexcept
{
  return domain().get().get_max();
}

void PathGeneratorXY::setupExecution(ossia::inlet& inl, QObject* exec_context) const noexcept
{
  auto& port = **safe_cast<ossia::value_inlet*>(&inl);
  port.type = ossia::val_type::LIST;
  port.domain = domain().get();
}

Bargraph::Bargraph(
    float min, float max, float init, const QString& name, Id<Port> id, QObject* parent)
    : ControlOutlet{name, id, parent}
{
  displayHandledExplicitly = true;
  setValue(init);
  setDomain(ossia::make_domain(min, max));
}

Bargraph::~Bargraph() { }

}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::FloatSlider& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamWriter::write(Process::FloatSlider& p)
{
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONReader::read(const Process::FloatSlider& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONWriter::write(Process::FloatSlider& p)
{
}

template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::FloatKnob& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamWriter::write(Process::FloatKnob& p)
{
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONReader::read(const Process::FloatKnob& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONWriter::write(Process::FloatKnob& p)
{
}

template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::LogFloatSlider& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamWriter::write(Process::LogFloatSlider& p)
{
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONReader::read(const Process::LogFloatSlider& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONWriter::write(Process::LogFloatSlider& p)
{
}

template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::IntSlider& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamWriter::write(Process::IntSlider& p)
{
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONReader::read(const Process::IntSlider& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONWriter::write(Process::IntSlider& p)
{
}

template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::IntRangeSlider& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamWriter::write(Process::IntRangeSlider& p)
{
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONReader::read(const Process::IntRangeSlider& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONWriter::write(Process::IntRangeSlider& p)
{
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::FloatRangeSlider& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamWriter::write(Process::FloatRangeSlider& p)
{
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONReader::read(const Process::FloatRangeSlider& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONWriter::write(Process::FloatRangeSlider& p)
{
}

template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::IntRangeSpinBox& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamWriter::write(Process::IntRangeSpinBox& p)
{
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONReader::read(const Process::IntRangeSpinBox& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONWriter::write(Process::IntRangeSpinBox& p)
{
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::FloatRangeSpinBox& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamWriter::write(Process::FloatRangeSpinBox& p)
{
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONReader::read(const Process::FloatRangeSpinBox& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONWriter::write(Process::FloatRangeSpinBox& p)
{
}

template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::IntSpinBox& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamWriter::write(Process::IntSpinBox& p)
{
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONReader::read(const Process::IntSpinBox& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONWriter::write(Process::IntSpinBox& p)
{
}

template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::FloatSpinBox& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamWriter::write(Process::FloatSpinBox& p)
{
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONReader::read(const Process::FloatSpinBox& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONWriter::write(Process::FloatSpinBox& p)
{
}

template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::TimeChooser& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamWriter::write(Process::TimeChooser& p)
{
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONReader::read(const Process::TimeChooser& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONWriter::write(Process::TimeChooser& p)
{
}

template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::Toggle& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamWriter::write(Process::Toggle& p)
{
}
template <>
SCORE_LIB_PROCESS_EXPORT void JSONReader::read(const Process::Toggle& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void JSONWriter::write(Process::Toggle& p)
{
}

template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::ChooserToggle& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamWriter::write(Process::ChooserToggle& p)
{
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONReader::read(const Process::ChooserToggle& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONWriter::write(Process::ChooserToggle& p)
{
}

template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::LineEdit& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamWriter::write(Process::LineEdit& p)
{
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONReader::read(const Process::LineEdit& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void JSONWriter::write(Process::LineEdit& p)
{
}

template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::ProgramEdit& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamWriter::write(Process::ProgramEdit& p)
{
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONReader::read(const Process::ProgramEdit& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONWriter::write(Process::ProgramEdit& p)
{
}

template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::FileChooser& p)
{
  read((const Process::ControlInlet&)p);
  m_stream << p.filters();
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamWriter::write(Process::FileChooser& p)
{
  QString f;
  m_stream >> f;
  p.setFilters(f);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONReader::read(const Process::FileChooser& p)
{
  read((const Process::ControlInlet&)p);
  obj["Filters"] = p.filters();
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONWriter::write(Process::FileChooser& p)
{
  QString f;
  f <<= obj["Filters"];
  p.setFilters(f);
}

template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::FolderChooser& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamWriter::write(Process::FolderChooser& p)
{
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONReader::read(const Process::FolderChooser& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONWriter::write(Process::FolderChooser& p)
{
}

template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::AudioFileChooser& p)
{
  read((const Process::ControlInlet&)p);
  m_stream << p.filters();
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamWriter::write(Process::AudioFileChooser& p)
{
  QString f;
  m_stream >> f;
  p.setFilters(f);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONReader::read(const Process::AudioFileChooser& p)
{
  read((const Process::ControlInlet&)p);
  obj["Filters"] = p.filters();
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONWriter::write(Process::AudioFileChooser& p)
{
  QString f;
  f <<= obj["Filters"];
  p.setFilters(f);
}

template <>
SCORE_LIB_PROCESS_EXPORT void DataStreamReader::read(const Process::VideoFileChooser& p)
{
  read((const Process::ControlInlet&)p);
  m_stream << p.filters();
}
template <>
SCORE_LIB_PROCESS_EXPORT void DataStreamWriter::write(Process::VideoFileChooser& p)
{
  QString f;
  m_stream >> f;
  p.setFilters(f);
}
template <>
SCORE_LIB_PROCESS_EXPORT void JSONReader::read(const Process::VideoFileChooser& p)
{
  read((const Process::ControlInlet&)p);
  obj["Filters"] = p.filters();
}
template <>
SCORE_LIB_PROCESS_EXPORT void JSONWriter::write(Process::VideoFileChooser& p)
{
  QString f;
  f <<= obj["Filters"];
  p.setFilters(f);
}

template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::Enum& p)
{
  read((const Process::ControlInlet&)p);
  m_stream << p.values << p.pixmaps;
}
template <>
SCORE_LIB_PROCESS_EXPORT void DataStreamWriter::write(Process::Enum& p)
{
  m_stream >> p.values >> p.pixmaps;
}
template <>
SCORE_LIB_PROCESS_EXPORT void JSONReader::read(const Process::Enum& p)
{
  read((const Process::ControlInlet&)p);
  obj["Values"] = p.values;
  obj["Pixmaps"] = p.pixmaps;
}
template <>
SCORE_LIB_PROCESS_EXPORT void JSONWriter::write(Process::Enum& p)
{
  p.values <<= obj["Values"];
  p.pixmaps <<= obj["Pixmaps"];
}

template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::ComboBox& p)
{
  read((const Process::ControlInlet&)p);
  m_stream << p.alternatives << p.folderPortName << p.fileExtensions;
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamWriter::write(Process::ComboBox& p)
{
  m_stream >> p.alternatives >> p.folderPortName >> p.fileExtensions;
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONReader::read(const Process::ComboBox& p)
{
  read((const Process::ControlInlet&)p);
  obj["Values"] = p.alternatives;
  // Folder-backed combobox metadata (empty for a plain combobox). Persisted so
  // a loaded document can re-scan the folder and re-establish live refresh;
  // see ProcessModel::init_folder_comboboxes. Extensions are stored as one
  // space-joined string ("*.json *.wav"), like FileChooser's filters.
  obj["FolderPort"] = p.folderPortName;
  obj["FileExtensions"] = p.fileExtensions.join(QChar(' '));
}
template <>
SCORE_LIB_PROCESS_EXPORT void JSONWriter::write(Process::ComboBox& p)
{
  p.alternatives <<= obj["Values"];
  // Guarded for documents saved before these fields existed.
  if(obj.tryGet("FolderPort"))
    p.folderPortName <<= obj["FolderPort"];
  if(obj.tryGet("FileExtensions"))
  {
    QString exts;
    exts <<= obj["FileExtensions"];
    p.fileExtensions
        = exts.isEmpty() ? QStringList{} : exts.split(QChar(' '), Qt::SkipEmptyParts);
  }
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::Button& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamWriter::write(Process::Button& p)
{
}
template <>
SCORE_LIB_PROCESS_EXPORT void JSONReader::read(const Process::Button& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void JSONWriter::write(Process::Button& p)
{
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::ImpulseButton& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamWriter::write(Process::ImpulseButton& p)
{
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONReader::read(const Process::ImpulseButton& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONWriter::write(Process::ImpulseButton& p)
{
}

template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::HSVSlider& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamWriter::write(Process::HSVSlider& p)
{
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONReader::read(const Process::HSVSlider& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONWriter::write(Process::HSVSlider& p)
{
}

template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::XYSlider& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamWriter::write(Process::XYSlider& p)
{
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONReader::read(const Process::XYSlider& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void JSONWriter::write(Process::XYSlider& p)
{
}

template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::XYZSlider& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamWriter::write(Process::XYZSlider& p)
{
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONReader::read(const Process::XYZSlider& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONWriter::write(Process::XYZSlider& p)
{
}

template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::XYSpinboxes& p)
{
  read((const Process::ControlInlet&)p);
  m_stream << p.integral;
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamWriter::write(Process::XYSpinboxes& p)
{
  m_stream >> p.integral;
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONReader::read(const Process::XYSpinboxes& p)
{
  read((const Process::ControlInlet&)p);
  obj["Integral"] = p.integral;
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONWriter::write(Process::XYSpinboxes& p)
{
  if(auto val = obj.tryGet("Integral"))
    p.integral = val->toBool();
}

template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::XYZSpinboxes& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamWriter::write(Process::XYZSpinboxes& p)
{
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONReader::read(const Process::XYZSpinboxes& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONWriter::write(Process::XYZSpinboxes& p)
{
}

template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::MultiSlider& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamWriter::write(Process::MultiSlider& p)
{
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONReader::read(const Process::MultiSlider& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONWriter::write(Process::MultiSlider& p)
{
}

template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::MultiSliderXY& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamWriter::write(Process::MultiSliderXY& p)
{
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONReader::read(const Process::MultiSliderXY& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONWriter::write(Process::MultiSliderXY& p)
{
}


template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::PathGeneratorXY& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamWriter::write(Process::PathGeneratorXY& p)
{
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONReader::read(const Process::PathGeneratorXY& p)
{
  read((const Process::ControlInlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONWriter::write(Process::PathGeneratorXY& p)
{
}

template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::Bargraph& p)
{
  read((const Process::ControlOutlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamWriter::write(Process::Bargraph& p)
{
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONReader::read(const Process::Bargraph& p)
{
  read((const Process::ControlOutlet&)p);
}
template <>
SCORE_LIB_PROCESS_EXPORT void JSONWriter::write(Process::Bargraph& p)
{
}

template <>
SCORE_LIB_PROCESS_EXPORT void DataStreamReader::read(const QString& p)
{
  m_stream << p;
}
template <>
SCORE_LIB_PROCESS_EXPORT void DataStreamWriter::write(QString& p)
{
  m_stream >> p;
}

ossia / score / 34154826796

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous