2#include <Process/Process.hpp>
4#include <Crousti/File.hpp>
5#include <Crousti/ProcessModel.hpp>
7#include <avnd/binding/ossia/node.hpp>
12template <
typename Node,
typename Field, std::
size_t NPred, std::
size_t NField>
15 using ExecNode = safe_node<Node>;
17 std::weak_ptr<ExecNode> weak_node;
19 void operator()(
const ossia::value& val)
21 using control_value_type = std::decay_t<
decltype(Field::value)>;
23 if(
auto node = weak_node.lock())
26 node->from_ossia_value(field, val, v, avnd::field_index<NField>{});
27 ctx.
executionQueue.enqueue([weak_node = weak_node, v = std::move(v)]()
mutable {
28 if(
auto n = weak_node.lock())
30 n->template control_updated_from_ui<control_value_type, NPred>(std::move(v));
37template <
typename Node,
typename Field, std::
size_t NPred, std::
size_t NField>
40 using ExecNode = safe_node<Node>;
42 std::weak_ptr<ExecNode> weak_node;
45 void operator()(
const ossia::value& val)
47 using control_value_type = std::decay_t<
decltype(Field::value)>;
49 if(
auto node = weak_node.lock())
52 node->from_ossia_value(field, val, v, avnd::field_index<NField>{});
54 [weak_node = weak_node, port_index = port_index, v = std::move(v)]()
mutable {
55 if(
auto n = weak_node.lock())
57 n->template control_updated_from_ui<control_value_type, NPred>(
58 std::move(v), port_index);
65template <
typename Node,
typename Field>
68 using ExecNode = safe_node<Node>;
73 const std::shared_ptr<ExecNode>& node_ptr;
76 void invoke_update(Field& param,
int k)
78 avnd::effect_container<Node>& eff = node_ptr->impl;
80 for(
auto state : eff.full_state())
82 if constexpr(avnd::dynamic_ports_port<Field>)
84 if_possible(param.ports[k].update(state.effect));
88 if_possible(param.update(state.effect));
94template <
typename Node,
typename Field, std::
size_t N, std::
size_t NField>
97template <
typename Node,
typename Field, std::
size_t N, std::
size_t NField>
100 using ExecNode = safe_node<Node>;
106 if constexpr(avnd::dynamic_ports_port<Field>)
108 if constexpr(!
requires { param.ports[0].value.reset(); })
110 this->node_ptr->from_ossia_value(
111 param, inlet->value(), param.ports[k].value, avnd::field_index<NField>{});
116 if constexpr(!
requires { param.value.reset(); })
118 this->node_ptr->from_ossia_value(
119 param, inlet->value(), param.value, avnd::field_index<NField>{});
127 if constexpr(
requires { param.update_controller; })
129 param.update_controller
130 = [inlet = QPointer{inlet}, self = QPointer{&this->element}](
auto&& value) {
136 ossia::qt::run_async(qApp, [self, inlet, val = std::move(value)] {
142 static const Field field;
143 oscr::to_ossia_value(field, val);
144 inlet->setValue(val);
153 std::weak_ptr<ExecNode> weak_node = this->node_ptr;
154 if constexpr(avnd::dynamic_ports_port<Field>)
156 using port_type = avnd::dynamic_port_type<Field>;
158 inlet, &Process::ControlInlet::valueChanged, this->parent,
160 this->ctx, weak_node, param.ports[k], k});
162 this->update_controller(param, inlet);
167 inlet, &Process::ControlInlet::valueChanged, this->parent,
170 this->update_controller(param, inlet);
175template <
typename Node, avnd::soundfile_port Field, std::
size_t N, std::
size_t NField>
179 using ExecNode = safe_node<Node>;
186 if(
auto hdl = loadSoundfile(inlet->value(), this->ctx.doc, this->ctx.execState))
187 this->node_ptr->soundfile_loaded(
188 hdl, avnd::predicate_index<N>{}, avnd::field_index<NField>{});
194 std::weak_ptr<ExecNode> weak_node = this->node_ptr;
195 std::weak_ptr<ossia::execution_state> weak_st = this->ctx.execState;
197 inlet, &Process::ControlInlet::valueChanged, this->parent,
198 [&ctx = this->ctx, weak_node = std::move(weak_node),
199 weak_st = std::move(weak_st)](
const ossia::value& v) {
200 if(
auto n = weak_node.lock())
201 if(
auto st = weak_st.lock())
202 if(
auto file = loadSoundfile(v, ctx.doc, st))
204 ctx.executionQueue.enqueue([f = std::move(file), weak_node]() mutable {
205 auto n = weak_node.lock();
212 f, avnd::predicate_index<N>{}, avnd::field_index<NField>{});
219template <
typename Node, avnd::m
idifile_port Field, std::
size_t N, std::
size_t NField>
220struct setup_control_for_exec<Node, Field, N, NField>
221 : setup_control_for_exec_base<Node, Field>
223 using ExecNode = safe_node<Node>;
224 using Model = ProcessModel<Node>;
231 if(
auto hdl = loadMidifile(inlet->value(), this->ctx.doc))
232 this->node_ptr->midifile_loaded(
233 hdl, avnd::predicate_index<N>{}, avnd::field_index<NField>{});
239 std::weak_ptr<ExecNode> weak_node = this->node_ptr;
240 std::weak_ptr<ossia::execution_state> weak_st = this->ctx.execState;
242 inlet, &Process::ControlInlet::valueChanged, this->parent,
243 [inlet, &ctx = this->ctx,
244 weak_node = std::move(weak_node)](
const ossia::value& v) {
245 if(
auto n = weak_node.lock())
246 if(
auto file = loadMidifile(v, ctx.doc))
248 ctx.executionQueue.enqueue([f = std::move(file), weak_node]() mutable {
249 auto n = weak_node.lock();
256 f, avnd::predicate_index<N>{}, avnd::field_index<NField>{});
263template <
typename Node, avnd::raw_file_port Field, std::
size_t N, std::
size_t NField>
264struct setup_control_for_exec<
Node, Field, N, NField>
265 : setup_control_for_exec_base<Node, Field>
267 using ExecNode = safe_node<Node>;
268 using Model = ProcessModel<Node>;
270 static constexpr bool has_text =
requires {
decltype(Field::file)::text; };
271 static constexpr bool has_mmap =
requires {
decltype(Field::file)::mmap; };
278 if(
auto hdl = loadRawfile(inlet->value(), this->ctx.doc, has_text, has_mmap))
280 if constexpr(avnd::port_can_process<Field>)
284 auto func = executePortPreprocess<Field>(*hdl);
285 this->node_ptr->file_loaded(
286 hdl, avnd::predicate_index<N>{}, avnd::field_index<NField>{});
288 func(this->node_ptr->impl.effect);
292 this->node_ptr->file_loaded(
293 hdl, avnd::predicate_index<N>{}, avnd::field_index<NField>{});
301 std::weak_ptr<ExecNode> weak_node = this->node_ptr;
302 std::weak_ptr<ossia::execution_state> weak_st = this->ctx.execState;
304 inlet, &Process::ControlInlet::valueChanged, this->parent,
305 [inlet, &ctx = this->ctx, weak_node = std::move(weak_node)] {
306 if(
auto n = weak_node.lock())
307 if(
auto file = loadRawfile(inlet->value(), ctx.doc, has_text, has_mmap))
309 if constexpr(avnd::port_can_process<Field>)
311 auto func = executePortPreprocess<Field>(*file);
312 ctx.executionQueue.enqueue(
313 [f = std::move(file), weak_node, ff = std::move(func)]() mutable {
314 auto n = weak_node.lock();
320 n->file_loaded(f, avnd::predicate_index<N>{}, avnd::field_index<NField>{});
327 ctx.executionQueue.enqueue([f = std::move(file), weak_node]() mutable {
328 auto n = weak_node.lock();
334 n->file_loaded(f, avnd::predicate_index<N>{}, avnd::field_index<NField>{});
342template <
typename Node>
345 using ExecNode = safe_node<Node>;
350 const std::shared_ptr<ExecNode>& node_ptr;
354 template <
typename Field, std::
size_t N, std::
size_t NField>
356 operator()(Field& param, avnd::predicate_index<N> np, avnd::field_index<NField> nf)
358 const auto ports = element.avnd_input_idx_to_model_ports(NField);
360 if constexpr(avnd::dynamic_ports_port<Field>)
362 param.ports.resize(ports.size());
368 if(
auto inlet = qobject_cast<Process::ControlInlet*>(p))
371 element, ctx, node_ptr, parent};
373 setup.initialize_control(param, inlet, k);
375 setup.invoke_update(param, k);
377 setup.connect_control_to_ui(param, inlet, k);
Definition score-plugin-avnd/Crousti/ProcessModel.hpp:79
TreeNode< DeviceExplorerNode > Node
Definition DeviceNode.hpp:74
Definition Factories.hpp:19
Definition ExecutionContext.hpp:76
ExecutionCommandQueue & executionQueue
Definition ExecutionContext.hpp:91
Definition ExecutorPortSetup.hpp:39
Definition ExecutorPortSetup.hpp:14
Definition ExecutorPortSetup.hpp:344
Definition ExecutorPortSetup.hpp:67
Definition ExecutorPortSetup.hpp:99