40815790952

Committed 29 Oct 2026 04:05AM UTC coverage: 50.888% (+1.7%) from 49.183%

Build # 40815790952

Build Type

Pull #2361

github

Committed by

web-flow

Commit Message

Merge 996cd0c5d into b3ba4155e

Pull Request Pull Request #2361: MIDI effects, audio and MIDI loopers, MIDI sync

Coverage Stats

176299 of 346447 relevant lines covered (50.89%)

166790.68 hits per line

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

65.04

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

#include <Process/Dataflow/WidgetInlets.hpp>

#include <score/document/DocumentContext.hpp>
#include <score/document/DocumentInterface.hpp>
#include <score/plugins/SerializableHelpers.hpp>
#include <score/tools/FilePath.hpp>
#include <score/tools/FileWatch.hpp>

#include <ossia/dataflow/port.hpp>
#include <ossia/detail/algorithms.hpp>
#include <ossia/detail/parse_strict.hpp>
#include <ossia/detail/ssize.hpp>
#include <ossia/network/value/value_conversion.hpp>

#include <ossia-qt/invoke.hpp>

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

#include <cmath>
#include <optional>

#include <core/document/Document.hpp>

#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)
W_OBJECT_IMPL(Process::FloatSlider)
W_OBJECT_IMPL(Process::FloatKnob)
W_OBJECT_IMPL(Process::LogFloatSlider)
W_OBJECT_IMPL(Process::IntSlider)
W_OBJECT_IMPL(Process::IntRangeSlider)
W_OBJECT_IMPL(Process::FloatRangeSlider)
W_OBJECT_IMPL(Process::IntRangeSpinBox)
W_OBJECT_IMPL(Process::FloatRangeSpinBox)
W_OBJECT_IMPL(Process::IntSpinBox)
W_OBJECT_IMPL(Process::FloatSpinBox)
W_OBJECT_IMPL(Process::TimeChooser)
W_OBJECT_IMPL(Process::GridChooser)
W_OBJECT_IMPL(Process::Toggle)
W_OBJECT_IMPL(Process::ChooserToggle)
W_OBJECT_IMPL(Process::LineEdit)
W_OBJECT_IMPL(Process::ProgramEdit)
W_OBJECT_IMPL(Process::Enum)
W_OBJECT_IMPL(Process::Button)
W_OBJECT_IMPL(Process::HSVSlider)
W_OBJECT_IMPL(Process::XYSlider)
W_OBJECT_IMPL(Process::XYZSlider)
W_OBJECT_IMPL(Process::XYSpinboxes)
W_OBJECT_IMPL(Process::XYZSpinboxes)
W_OBJECT_IMPL(Process::MultiSlider)
W_OBJECT_IMPL(Process::MultiSliderXY)
W_OBJECT_IMPL(Process::PathGeneratorXY)
W_OBJECT_IMPL(Process::Bargraph)
namespace Process
{
namespace
{
struct entry_index_visitor
{
  int n;

  std::optional<int> operator()(int32_t i) const noexcept
  {
    return i >= 0 && i < n ? std::optional<int>(i) : std::nullopt;
  }
  std::optional<int> operator()(float f) const noexcept
  {
    // Bounded before narrowing: int32_t(1e30f) and int32_t(NaN) are undefined.
    // Whole numbers only, so a float and the same number spelled as a string
    // agree, and nothing in (-1, 1) truncates onto the first entry.
    const double d = f;
    if(!(d >= 0. && d < double(n)) || d != std::floor(d))
      return std::nullopt;
    return std::optional<int>(int(d));
  }
  std::optional<int> operator()(const std::string& s) const noexcept
  {
    // Exactly the digits a coerced integer becomes, not even surrounding
    // blanks: anything looser eats names that merely begin with a number.
    const auto parsed = ossia::parse_strict<int64_t>(s);
    if(!parsed)
      return std::nullopt;
    // Bounded here: narrowing first could fold a huge number back into range.
    return *parsed >= 0 && *parsed < n ? std::optional<int>(int(*parsed))
                                       : std::nullopt;
  }
  std::optional<int> operator()(const auto&) const noexcept { return std::nullopt; }
  std::optional<int> operator()() const noexcept { return std::nullopt; }
};

bool entriesAreNames(
    const std::vector<std::pair<QString, ossia::value>>& alternatives) noexcept
{
  for(const auto& [name, value] : alternatives)
    if(value.valid())
      return value.get_type() == ossia::val_type::STRING;
  return false;
}
}

std::optional<int> readEntryIndex(const ossia::value& v, int n) noexcept
{
  return v.apply(entry_index_visitor{n});
}

int ComboBox::indexOfValue(const ossia::value& v) const noexcept
{
  // Two invalid values compare equal, so one would select a valueless entry.
  if(!v.valid())
    return -1;

  const int n = std::ssize(alternatives);
  for(int i = 0; i < n; i++)
    if(alternatives[i].second == v)
      return i;

  if(auto str = v.target<std::string>())
  {
    const auto label = QString::fromStdString(*str);
    for(int i = 0; i < n; i++)
      if(alternatives[i].first == label)
        return i;
  }

  if(!entriesAreNames(alternatives))
    return -1;

  return readEntryIndex(v, n).value_or(-1);
}

void ComboBox::setValue(const ossia::value& value)
{
  if(value.target<std::string>())
  {
    const bool is_a_value = ossia::any_of(
        alternatives, [&](const auto& alt) { return alt.second == value; });
    if(!is_a_value)
    {
      if(const int i = indexOfValue(value); i >= 0)
        return ControlInlet::setValue(alternatives[i].second);
    }
  }
  ControlInlet::setValue(value);
}

ossia::value ComboBox::valueAtIndex(int i) const noexcept
{
  if(i < 0 || i >= std::ssize(alternatives))
    return {};
  return alternatives[i].second;
}

int Enum::indexOfValue(const ossia::value& v) const noexcept
{
  if(!v.valid())
    return -1;

  const int n = std::ssize(values);
  const auto name = QString::fromStdString(ossia::convert<std::string>(v));
  for(int i = 0; i < n; i++)
    if(values[i] == name)
      return i;

  return readEntryIndex(v, n).value_or(-1);
}

ossia::value Enum::valueAtIndex(int i) const noexcept
{
  if(i < 0 || i >= std::ssize(values))
    return {};
  return values[i].toStdString();
}

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;
}

void HSVSlider::setupExecution(ossia::inlet& inl, QObject* exec_context) const noexcept
{
  // The unit, not just the value type: it is what makes an address declared
  // color.rgb (or hsv, or any other colour unit) arrive here as the rgba this
  // control reads. Without it value_port::effective_type() is empty and
  // adapt_value() has nothing to convert towards.
  auto& port = **safe_cast<ossia::value_inlet*>(&inl);
  port.type = unit().get();
}

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;
  // The second component is the mode: 0 is a time in seconds, anything else is
  // a musical denomination. It starts at 0, which is what the object declaring
  // the control says too -- halp::time_chooser_t has `bool sync{false}`.
  //
  // It used to start synced, and that made every such control's default wrong:
  // the value the process declared as its init was read as a number of quarter
  // notes and converted to seconds against the tempo, so a control asking for
  // two seconds got two quarters instead. Deuterium's sampler carries a
  // work-around for exactly this.
  setValue(ossia::vec2f{init, 0.f});
  setInit(value());
  setDomain(ossia::make_domain(ossia::vec2f{min, 0.f}, ossia::vec2f{max, 1.f}));
}

TimeChooser::~TimeChooser() { }

bool TimeChooser::preferSynced(double tempo)
{
  const auto v = ossia::convert<ossia::vec2f>(value());
  if(v[1] != 0.f || !(v[0] > 0.f) || !(tempo > 0.))
    return false;
  // Seconds -> a fraction of a whole note, then the closest straight note
  // from 1/64 to 4 wholes
  const double whole = v[0] * tempo / 240.;
  double best = 1.;
  double best_ratio = 1e9;
  for(double note = 1. / 64.; note <= 4.; note *= 2.)
  {
    const double r = std::max(note / whole, whole / note);
    if(r < best_ratio)
    {
      best_ratio = r;
      best = note;
    }
  }
  if(best_ratio > 1.5)
    return false;
  const ossia::vec2f synced{float(best), 1.f};
  setValue(synced);
  setInit(synced);
  return true;
}

void TimeChooser::setValue(const ossia::value& value)
{
  switch(value.get_type())
  {
    case ossia::val_type::FLOAT:
    case ossia::val_type::INT:
    case ossia::val_type::BOOL:
      ControlInlet::setValue(ossia::vec2f{ossia::convert<float>(value), 0.f});
      break;
    default:
      ControlInlet::setValue(value);
      break;
  }
}

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();
}

GridChooser::GridChooser(
    ossia::vec2f init, uint32_t units, int maxBars, double maxSeconds,
    QString periodName, const QString& name, Id<Port> id, QObject* parent)
    : ControlInlet{name, id, parent}
    , units{units}
    , maxBars{maxBars}
    , maxSeconds{maxSeconds}
    , periodName{std::move(periodName)}
{
  displayHandledExplicitly = true;
  setValue(init);
  setInit(value());
  // No domain: a range would clamp the value of one unit with another's bounds
}

GridChooser::~GridChooser() { }

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

void GridChooser::setValue(const ossia::value& value)
{
  switch(value.get_type())
  {
    case ossia::val_type::FLOAT:
    case ossia::val_type::INT:
    case ossia::val_type::BOOL:
      ControlInlet::setValue(ossia::vec2f{ossia::convert<float>(value), 0.f});
      break;
    default:
      ControlInlet::setValue(value);
      break;
  }
}

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

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() { }

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

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() { }

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

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() { }

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

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();
  // A bang happens, it is not a state: an address mapped here delivers what it
  // received, instead of having its current value copied in on every tick.
  port.is_event = true;
}

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::GridChooser& p)
{
  read((const Process::ControlInlet&)p);
  m_stream << p.units << p.maxBars << p.maxSeconds << p.periodName;
}
template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamWriter::write(Process::GridChooser& p)
{
  m_stream >> p.units >> p.maxBars >> p.maxSeconds >> p.periodName;
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONReader::read(const Process::GridChooser& p)
{
  read((const Process::ControlInlet&)p);
  obj["Units"] = p.units;
  obj["MaxBars"] = p.maxBars;
  obj["MaxSeconds"] = p.maxSeconds;
  obj["Period"] = p.periodName;
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONWriter::write(Process::GridChooser& p)
{
  p.units = uint32_t(obj["Units"].toUInt64());
  p.maxBars = obj["MaxBars"].toInt();
  p.maxSeconds = obj["MaxSeconds"].toDouble();
  p.periodName <<= obj["Period"];
}

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)
{
}


namespace
{
// Paths under the document's folder or the user library are saved as
// <PROJECT>: / <LIBRARY>: paths, so that they survive the document moving.
ossia::value storedPathValue(const Process::ControlInlet& p)
{
  const auto* str = p.value().target<std::string>();
  if(!str || str->empty())
    return p.value();

  const auto path = QString::fromStdString(*str);
  const auto stored = [&] {
    if(auto* doc = score::IDocument::try_documentFromObject(p))
      return score::relativizeFilePath(path, doc->context());
    return score::relativizeFilePath(path);
  }();
  return stored.toStdString();
}

void readPathControl(DataStreamReader& s, const Process::ControlInlet& p)
{
  s.readFrom(storedPathValue(p));
  s.readFrom(p.init());
  s.readFrom(p.domain());
}

void readPathControl(JSONReader& s, const Process::ControlInlet& p)
{
  s.obj[s.strings.Value] = storedPathValue(p);
  s.obj[s.strings.Init] = p.init();
  s.obj[s.strings.Domain] = p.domain();
}
}

template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::FileChooser& p)
{
  readPathControl(*this, 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)
{
  readPathControl(*this, p);
  obj["Filters"] = p.filters();
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONWriter::write(Process::FileChooser& p)
{
  // tryGet: these three writers are reachable through the deserializing
  // constructors, and documents older than the "Filters" key exist.
  if(auto it = obj.tryGet("Filters"))
  {
    QString f;
    f <<= *it;
    p.setFilters(f);
  }
}

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

template <>
SCORE_LIB_PROCESS_EXPORT void
DataStreamReader::read(const Process::AudioFileChooser& p)
{
  readPathControl(*this, 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)
{
  readPathControl(*this, p);
  obj["Filters"] = p.filters();
}
template <>
SCORE_LIB_PROCESS_EXPORT void
JSONWriter::write(Process::AudioFileChooser& p)
{
  if(auto it = obj.tryGet("Filters"))
  {
    QString f;
    f <<= *it;
    p.setFilters(f);
  }
}

template <>
SCORE_LIB_PROCESS_EXPORT void DataStreamReader::read(const Process::VideoFileChooser& p)
{
  readPathControl(*this, 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)
{
  readPathControl(*this, p);
  obj["Filters"] = p.filters();
}
template <>
SCORE_LIB_PROCESS_EXPORT void JSONWriter::write(Process::VideoFileChooser& p)
{
  if(auto it = obj.tryGet("Filters"))
  {
    QString f;
    f <<= *it;
    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 / 40815790952

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