ControlTree.hpp

Go to the documentation of this file.

#pragma once
 
#include <ossia/network/base/device.hpp>
#include <ossia/network/base/node.hpp>
#include <ossia/network/base/parameter.hpp>
#include <ossia/network/common/complex_type.hpp>
#include <ossia/network/domain/domain.hpp>
#include <ossia/network/generic/generic_node.hpp>
 
#include <functional>
#include <memory>
#include <string>
#include <vector>
 
namespace Gfx
{
 
struct TreeControl
{
  std::string name;        
  std::string description; 
 
  ossia::val_type type{};
  ossia::domain domain;
  ossia::value initial;
  ossia::access_mode access{ossia::access_mode::BI};
 
  std::function<void(const ossia::value&)> onSet;
};
 
inline std::vector<ossia::net::parameter_base*> addControlGroup(
    ossia::net::device_base& dev, ossia::net::node_base& parent,
    const std::string& group, const std::vector<TreeControl>& controls)
{
  std::vector<ossia::net::parameter_base*> out;
  out.reserve(controls.size());
 
  // Reload puts the saved tree back before the hardware is opened, so the group
  // and its children can already be there. add_child refuses a duplicate name
  // and returns null.
  ossia::net::node_base* groupPtr = parent.find_child(group);
  if(!groupPtr)
    groupPtr = parent.add_child(
        std::make_unique<ossia::net::generic_node>(group, dev, parent));
  if(!groupPtr)
  {
    out.resize(controls.size(), nullptr);
    return out;
  }
 
  for(const auto& c : controls)
  {
    // Same again per control: adopt the node the document restored rather than
    // failing to add a second one with the same name.
    if(auto* existing = groupPtr->find_child(c.name))
    {
      // Whether the parameter PRE-EXISTED (the document restored it, so its
      // value is the user's) or is created right here (no restored value —
      // its default-constructed 0.0 is fabricated, not the user's).
      auto* param = existing->get_parameter();
      const bool parameterWasRestored = (param != nullptr);
      if(!param)
        param = existing->create_parameter(c.type);
      if(!param)
      {
        out.push_back(nullptr);
        continue;
      }
 
      if(c.domain)
        param->set_domain(c.domain);
      param->set_access(c.access);
      if(!c.description.empty())
        ossia::net::set_description(*existing, c.description);
 
      // A restored value is the user's, not the hardware's, so it is pushed
      // back through the callback rather than overwritten with c.initial the
      // way a freshly created node is. But a parameter CREATED here holds only
      // its default-constructed value (0.0 for FLOAT) — no document ever held
      // it — so pushing it would slam a gain/exposure to zero. The fresh-node
      // path refuses to write c.initial for the same reason; the adopt path
      // must likewise write nothing when it just made the parameter.
      const auto restored = param->value();
      param->callbacks_clear();
      if(c.onSet)
      {
        // Driven before the callback is installed, not after: the write has to
        // reach the hardware, and doing it through an installed callback would
        // re-enter the parameter that is being set up.
        if(parameterWasRestored && restored.valid())
          c.onSet(restored);
        auto cb = c.onSet;
        param->add_callback(std::move(cb));
      }
      out.push_back(param);
      continue;
    }
 
    auto node = std::make_unique<ossia::net::generic_node>(c.name, dev, *groupPtr);
    auto* param = node->create_parameter(c.type);
    if(!param)
    {
      out.push_back(nullptr);
      continue;
    }
 
    if(c.domain)
      param->set_domain(c.domain);
    param->set_access(c.access);
 
    if(!c.description.empty())
      ossia::net::set_description(*node, c.description);
 
    // The initial value is set before the callback is installed: it describes
    // what the hardware already holds, and writing it back would be a
    // round-trip through the driver for no reason -- and, for a control whose
    // write performs an action, an unwanted action.
    if(c.initial.valid())
      param->push_value(c.initial);
 
    if(c.onSet)
    {
      auto cb = c.onSet;
      param->add_callback(std::move(cb));
    }
 
    // add_child takes ownership; the node keeps the parameter alive.
    auto* added = groupPtr->add_child(std::move(node));
    out.push_back(added ? param : nullptr);
  }
 
  return out;
}
 
} // namespace Gfx