Loading...
Searching...
No Matches
Port.hpp
1#pragma once
2#include <State/Address.hpp>
3#include <State/Domain.hpp>
4
5#include <Device/Address/AddressSettings.hpp>
6
7#include <Process/Dataflow/PortForward.hpp>
8#include <Process/Dataflow/PortType.hpp>
9
10#include <score/model/IdentifiedObject.hpp>
11#include <score/model/path/Path.hpp>
12#include <score/plugins/SerializableInterface.hpp>
13#include <score/selection/Selectable.hpp>
14#include <score/serialization/VisitorInterface.hpp>
15
16#include <ossia/detail/small_vector.hpp>
17#include <ossia/network/value/value.hpp>
18
19#include <QPointF>
20
21#include <score_lib_process_export.h>
22#include <smallfun.hpp>
23
24#include <verdigris>
25
26#if __cpp_constexpr >= 201907
27#define VIRTUAL_CONSTEXPR constexpr
28#else
29#define VIRTUAL_CONSTEXPR
30#endif
31
32namespace ossia
33{
34struct inlet;
35struct outlet;
36}
37namespace Process
38{
39class Port;
40class Inlet;
41class Outlet;
42class ValueInlet;
43class ValueOutlet;
44class AudioInlet;
45class AudioOutlet;
46class MidiInlet;
47class MidiOutlet;
48class ControlInlet;
49class ControlOutlet;
50}
51UUID_METADATA(
52 SCORE_LIB_PROCESS_EXPORT, Process::Port, Process::Inlet,
53 "8884228a-d197-4b0a-b6ca-d1fb15291559")
54UUID_METADATA(
55 SCORE_LIB_PROCESS_EXPORT, Process::Port, Process::Outlet,
56 "34e2c5a7-18c4-4759-b6cc-46feaeee06e2")
57UUID_METADATA(
58 SCORE_LIB_PROCESS_EXPORT, Process::Port, Process::ValueInlet,
59 "769dd38a-bfb3-4dc6-b52a-b6abb7afe2a3")
60UUID_METADATA(
61 SCORE_LIB_PROCESS_EXPORT, Process::Port, Process::ValueOutlet,
62 "cff96158-cc72-46d7-99dc-b6038171375b")
63UUID_METADATA(
64 SCORE_LIB_PROCESS_EXPORT, Process::Port, Process::MidiInlet,
65 "c18adc77-e0e0-4ddf-a46c-43cb0719a890")
66UUID_METADATA(
67 SCORE_LIB_PROCESS_EXPORT, Process::Port, Process::MidiOutlet,
68 "d8a3ed3d-b9c2-46f2-bdb3-d282a48481c6")
69UUID_METADATA(
70 SCORE_LIB_PROCESS_EXPORT, Process::Port, Process::AudioInlet,
71 "a1574bb0-cbd4-4c7d-9417-0c25cfd1187b")
72UUID_METADATA(
73 SCORE_LIB_PROCESS_EXPORT, Process::Port, Process::AudioOutlet,
74 "a1d97535-18ac-444a-8417-0cbc1692d897")
75UUID_METADATA(
76 SCORE_LIB_PROCESS_EXPORT, Process::Port, Process::ControlInlet,
77 "9a13fb32-269a-47bf-99a9-930188c1f19c")
78UUID_METADATA(
79 SCORE_LIB_PROCESS_EXPORT, Process::Port, Process::ControlOutlet,
80 "3620ea94-5991-41cf-89b3-11f842cc39d0")
81namespace Process
82{
83
84// Used to know where to layout items for a given
85// kind of port.
86static constexpr const qreal default_margin = 5.;
87static constexpr const qreal default_padding = 5.;
88
89struct PortItemLayout
90{
91 QPointF port{0., 1.};
92 QPointF label{12., 0.};
93 QPointF control{0., 12.};
94 Qt::Alignment labelAlignment{};
95 Qt::Alignment controlAlignment{};
96 bool labelVisible{true};
97};
98
99class Cable;
100class SCORE_LIB_PROCESS_EXPORT Port
101 : public IdentifiedObject<Port>
102 , public score::SerializableInterface<Port>
103{
104 W_OBJECT(Port)
105 SCORE_SERIALIZE_FRIENDS
106public:
107 Selectable selection{this};
108 bool displayHandledExplicitly{};
109 bool noValueChangeOnMove{};
110
111 void addCable(const Process::Cable& c);
112 void removeCable(const Path<Process::Cable>& c);
113 void takeCables(Process::Port&& c);
114
115 const QString& visualName() const noexcept;
116 const QString& visualDescription() const noexcept;
117
118 const QString& name() const noexcept;
119 const State::AddressAccessor& address() const noexcept;
120 const std::vector<Path<Cable>>& cables() const noexcept;
121 const QString& exposed() const noexcept;
122 const QString& description() const noexcept;
123
124 virtual PortType type() const noexcept = 0;
125
126 virtual Device::FullAddressAccessorSettings settings() const noexcept;
127 virtual void setSettings(const Device::FullAddressAccessorSettings& set) noexcept;
128
129public:
130 void setName(const QString& customData);
131 W_SLOT(setName);
132 void setExposed(const QString& add);
133 W_SLOT(setExposed);
134 void setDescription(const QString& add);
135 W_SLOT(setDescription);
136 void setAddress(const State::AddressAccessor& address);
137 W_SLOT(setAddress);
138
139 void nameChanged(const QString& name)
140 E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, nameChanged, name)
141 void exposedChanged(const QString& addr)
142 E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, exposedChanged, addr)
143 void descriptionChanged(const QString& txt)
144 E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, descriptionChanged, txt)
145 void cablesChanged() E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, cablesChanged)
146 void addressChanged(const State::AddressAccessor& address)
147 E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, addressChanged, address)
148 void executionReset() E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, executionReset)
149
150 PROPERTY(
151 State::AddressAccessor,
152 address W_READ address W_WRITE setAddress W_NOTIFY addressChanged)
153 PROPERTY(QString, name W_READ name W_WRITE setName W_NOTIFY nameChanged)
154 PROPERTY(Process::PortType, type W_READ type W_CONSTANT W_FINAL)
155
156 virtual QByteArray saveData() const noexcept;
157 virtual void loadData(const QByteArray& arr) noexcept;
158
159protected:
160 Port() = delete;
161 ~Port() override;
162 Port(const Port&) = delete;
163 Port(Id<Port> c, const QString& name, QObject* parent);
164
165 Port(DataStream::Deserializer& vis, QObject* parent);
166 Port(JSONObject::Deserializer& vis, QObject* parent);
167 Port(DataStream::Deserializer&& vis, QObject* parent);
168 Port(JSONObject::Deserializer&& vis, QObject* parent);
169
170private:
171 std::vector<Path<Cable>> m_cables;
172 QString m_name;
173 QString m_exposed;
174 QString m_description;
175 State::AddressAccessor m_address;
176};
177
178class SCORE_LIB_PROCESS_EXPORT Inlet : public Port
179{
180 W_OBJECT(Inlet)
181public:
182 using score_base_type = Inlet;
183 MODEL_METADATA_IMPL_HPP(Inlet)
184
185 ~Inlet() override;
186
187 virtual void setupExecution(ossia::inlet&, QObject* exec_context) const noexcept;
188 virtual void forChildInlets(const smallfun::function<void(Inlet&)>&) const noexcept;
189 virtual void mapExecution(
190 ossia::inlet&,
191 const smallfun::function<void(Inlet&, ossia::inlet&)>&) const noexcept;
192
193protected:
194 Inlet() = delete;
195 Inlet(const Inlet&) = delete;
196 Inlet(const QString& name, Id<Process::Port> c, QObject* parent);
197
198 Inlet(DataStream::Deserializer& vis, QObject* parent);
199 Inlet(JSONObject::Deserializer& vis, QObject* parent);
200 Inlet(DataStream::Deserializer&& vis, QObject* parent);
201 Inlet(JSONObject::Deserializer&& vis, QObject* parent);
202};
203
204class SCORE_LIB_PROCESS_EXPORT ControlInlet : public Inlet
205{
206 W_OBJECT(ControlInlet)
207
208 SCORE_SERIALIZE_FRIENDS
209public:
210 MODEL_METADATA_IMPL_HPP(ControlInlet)
211 ControlInlet() = delete;
212 ~ControlInlet() override;
213 ControlInlet(const ControlInlet&) = delete;
214 ControlInlet(const QString& name, Id<Process::Port> c, QObject* parent);
215
216 ControlInlet(DataStream::Deserializer& vis, QObject* parent, bool skip_this = false);
217 ControlInlet(JSONObject::Deserializer& vis, QObject* parent, bool skip_this = false);
218 ControlInlet(DataStream::Deserializer&& vis, QObject* parent, bool skip_this = false);
219 ControlInlet(JSONObject::Deserializer&& vis, QObject* parent, bool skip_this = false);
220
221 VIRTUAL_CONSTEXPR PortType type() const noexcept override
222 {
223 return Process::PortType::Message;
224 }
225
226 const ossia::value& value() const noexcept { return m_value; }
227 const ossia::value& init() const noexcept { return m_init; }
228 const State::Domain& domain() const noexcept { return m_domain; }
229
230 QByteArray saveData() const noexcept override;
231 void loadData(const QByteArray& arr) noexcept override;
232
233public:
234 void valueChanged(const ossia::value& v)
235 E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, valueChanged, v)
236 void initChanged(const ossia::value& v)
237 E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, initChanged, v)
238 void executionValueChanged(const ossia::value& v)
239 E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, executionValueChanged, v)
240 void domainChanged(const State::Domain& d)
241 E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, domainChanged, d)
242
243public:
244 void setValue(const ossia::value& value);
245 W_SLOT(setValue)
246 void setInit(const ossia::value& value);
247 W_SLOT(setInit)
248
249 inline void setExecutionValue(const ossia::value& value)
250 {
251 executionValueChanged(value);
252 }
253
254 void setDomain(const State::Domain& d)
255 {
256 if(m_domain != d)
257 {
258 m_domain = d;
259 domainChanged(d);
260 }
261 }
262 W_SLOT(setDomain)
263
264 PROPERTY(State::Domain, domain W_READ domain W_WRITE setDomain W_NOTIFY domainChanged)
265 PROPERTY(ossia::value, value W_READ value W_WRITE setValue W_NOTIFY valueChanged)
266 PROPERTY(ossia::value, init W_READ init W_WRITE setInit W_NOTIFY initChanged)
267private:
268 ossia::value m_value;
269 ossia::value m_init;
270 State::Domain m_domain;
271};
272
273class SCORE_LIB_PROCESS_EXPORT Outlet : public Port
274{
275 W_OBJECT(Outlet)
276
277 SCORE_SERIALIZE_FRIENDS
278public:
279 using score_base_type = Outlet;
280 MODEL_METADATA_IMPL_HPP(Outlet)
281
282 ~Outlet() override;
283 virtual void setupExecution(ossia::outlet&, QObject* exec_context) const noexcept;
284 virtual void forChildInlets(const smallfun::function<void(Inlet&)>&) const noexcept;
285 virtual void mapExecution(
286 ossia::outlet&,
287 const smallfun::function<void(Inlet&, ossia::inlet&)>&) const noexcept;
288
289protected:
290 Outlet() = delete;
291 Outlet(const Outlet&) = delete;
292 Outlet(const QString& name, Id<Process::Port> c, QObject* parent);
293
294 Outlet(DataStream::Deserializer& vis, QObject* parent);
295 Outlet(JSONObject::Deserializer& vis, QObject* parent);
296 Outlet(DataStream::Deserializer&& vis, QObject* parent);
297 Outlet(JSONObject::Deserializer&& vis, QObject* parent);
298};
299
300class SCORE_LIB_PROCESS_EXPORT AudioInlet : public Inlet
301{
302 W_OBJECT(AudioInlet)
303
304 SCORE_SERIALIZE_FRIENDS
305public:
306 MODEL_METADATA_IMPL_HPP(AudioInlet)
307 AudioInlet() = delete;
308 ~AudioInlet() override;
309 AudioInlet(const AudioInlet&) = delete;
310 AudioInlet(const QString& name, Id<Process::Port> c, QObject* parent);
311
312 AudioInlet(DataStream::Deserializer& vis, QObject* parent);
313 AudioInlet(JSONObject::Deserializer& vis, QObject* parent);
314 AudioInlet(DataStream::Deserializer&& vis, QObject* parent);
315 AudioInlet(JSONObject::Deserializer&& vis, QObject* parent);
316
317 VIRTUAL_CONSTEXPR PortType type() const noexcept override
318 {
319 return Process::PortType::Audio;
320 }
321};
322
323class SCORE_LIB_PROCESS_EXPORT AudioOutlet : public Outlet
324{
325 W_OBJECT(AudioOutlet)
326
327 SCORE_SERIALIZE_FRIENDS
328public:
329 MODEL_METADATA_IMPL_HPP(AudioOutlet)
330 AudioOutlet() = delete;
331 ~AudioOutlet() override;
332 AudioOutlet(const AudioOutlet&) = delete;
333 AudioOutlet(const QString& name, Id<Process::Port> c, QObject* parent);
334
335 AudioOutlet(DataStream::Deserializer& vis, QObject* parent);
336 AudioOutlet(JSONObject::Deserializer& vis, QObject* parent);
337 AudioOutlet(DataStream::Deserializer&& vis, QObject* parent);
338 AudioOutlet(JSONObject::Deserializer&& vis, QObject* parent);
339
340 VIRTUAL_CONSTEXPR PortType type() const noexcept override
341 {
342 return Process::PortType::Audio;
343 }
344
345 void forChildInlets(const smallfun::function<void(Inlet&)>&) const noexcept override;
346 void mapExecution(
347 ossia::outlet&,
348 const smallfun::function<void(Inlet&, ossia::inlet&)>&) const noexcept override;
349
350 QByteArray saveData() const noexcept override;
351 void loadData(const QByteArray& arr) noexcept override;
352
353 bool propagate() const;
354 void setPropagate(bool propagate);
355 void propagateChanged(bool propagate)
356 E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, propagateChanged, propagate)
357
358 double gain() const;
359 void setGain(double g);
360 void gainChanged(double g) E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, gainChanged, g)
361
362 pan_weight pan() const;
363 void setPan(pan_weight g);
364 void panChanged(pan_weight g) E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, panChanged, g)
365
366 std::unique_ptr<Process::ControlInlet> gainInlet;
367 std::unique_ptr<Process::ControlInlet> panInlet;
368
369 PROPERTY(
370 bool, propagate W_READ propagate W_WRITE setPropagate W_NOTIFY propagateChanged)
371 PROPERTY(double, gain W_READ gain W_WRITE setGain W_NOTIFY gainChanged)
372 PROPERTY(pan_weight, pan W_READ pan W_WRITE setPan W_NOTIFY panChanged)
373private:
374 double m_gain{};
375 pan_weight m_pan;
376 bool m_propagate{false};
377};
378
379class SCORE_LIB_PROCESS_EXPORT MidiInlet : public Inlet
380{
381 W_OBJECT(MidiInlet)
382
383 SCORE_SERIALIZE_FRIENDS
384public:
385 MODEL_METADATA_IMPL_HPP(MidiInlet)
386 MidiInlet() = delete;
387 ~MidiInlet() override;
388 MidiInlet(const MidiInlet&) = delete;
389 MidiInlet(const QString& name, Id<Process::Port> c, QObject* parent);
390
391 MidiInlet(DataStream::Deserializer& vis, QObject* parent);
392 MidiInlet(JSONObject::Deserializer& vis, QObject* parent);
393 MidiInlet(DataStream::Deserializer&& vis, QObject* parent);
394 MidiInlet(JSONObject::Deserializer&& vis, QObject* parent);
395
396 VIRTUAL_CONSTEXPR PortType type() const noexcept override
397 {
398 return Process::PortType::Midi;
399 }
400};
401
402class SCORE_LIB_PROCESS_EXPORT MidiOutlet : public Outlet
403{
404 W_OBJECT(MidiOutlet)
405
406 SCORE_SERIALIZE_FRIENDS
407public:
408 MODEL_METADATA_IMPL_HPP(MidiOutlet)
409 MidiOutlet() = delete;
410 ~MidiOutlet() override;
411 MidiOutlet(const MidiOutlet&) = delete;
412 MidiOutlet(const QString& name, Id<Process::Port> c, QObject* parent);
413
414 MidiOutlet(DataStream::Deserializer& vis, QObject* parent);
415 MidiOutlet(JSONObject::Deserializer& vis, QObject* parent);
416 MidiOutlet(DataStream::Deserializer&& vis, QObject* parent);
417 MidiOutlet(JSONObject::Deserializer&& vis, QObject* parent);
418
419 VIRTUAL_CONSTEXPR PortType type() const noexcept override
420 {
421 return Process::PortType::Midi;
422 }
423};
424
425class SCORE_LIB_PROCESS_EXPORT ControlOutlet : public Outlet
426{
427 W_OBJECT(ControlOutlet)
428
429 SCORE_SERIALIZE_FRIENDS
430public:
431 MODEL_METADATA_IMPL_HPP(ControlOutlet)
432 ControlOutlet() = delete;
433 ControlOutlet(const Outlet&) = delete;
434 ControlOutlet(const QString& name, Id<Process::Port> c, QObject* parent);
435 ~ControlOutlet() override;
436
437 ControlOutlet(DataStream::Deserializer& vis, QObject* parent);
438 ControlOutlet(JSONObject::Deserializer& vis, QObject* parent);
439 ControlOutlet(DataStream::Deserializer&& vis, QObject* parent);
440 ControlOutlet(JSONObject::Deserializer&& vis, QObject* parent);
441
442 VIRTUAL_CONSTEXPR PortType type() const noexcept override
443 {
444 return Process::PortType::Message;
445 }
446
447 QByteArray saveData() const noexcept override;
448 void loadData(const QByteArray& arr) noexcept override;
449
450 const ossia::value& value() const { return m_value; }
451 const State::Domain& domain() const { return m_domain; }
452
453public:
454 void valueChanged(const ossia::value& v)
455 E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, valueChanged, v)
456 void executionValueChanged(const ossia::value& v)
457 E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, executionValueChanged, v)
458 void domainChanged(const State::Domain& d)
459 E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, domainChanged, d)
460
461public:
462 void setExecutionValue(const ossia::value& value) { executionValueChanged(value); }
463
464 void setValue(const ossia::value& value)
465 {
466 if(value != m_value)
467 {
468 m_value = value;
469 valueChanged(value);
470 }
471 }
472 W_SLOT(setValue)
473
474 void setDomain(const State::Domain& d)
475 {
476 if(m_domain != d)
477 {
478 m_domain = d;
479 domainChanged(d);
480 }
481 }
482 W_SLOT(setDomain)
483
484 PROPERTY(State::Domain, domain W_READ domain W_WRITE setDomain W_NOTIFY domainChanged)
485 PROPERTY(ossia::value, value W_READ value W_WRITE setValue W_NOTIFY valueChanged)
486private:
487 ossia::value m_value;
488 State::Domain m_domain;
489};
490
491class SCORE_LIB_PROCESS_EXPORT ValueInlet : public Inlet
492{
493 W_OBJECT(ValueInlet)
494
495 SCORE_SERIALIZE_FRIENDS
496public:
497 MODEL_METADATA_IMPL_HPP(ValueInlet)
498 ValueInlet() = delete;
499 ~ValueInlet() override;
500 ValueInlet(const ValueInlet&) = delete;
501 ValueInlet(const QString& name, Id<Process::Port> c, QObject* parent);
502
503 ValueInlet(DataStream::Deserializer& vis, QObject* parent);
504 ValueInlet(JSONObject::Deserializer& vis, QObject* parent);
505 ValueInlet(DataStream::Deserializer&& vis, QObject* parent);
506 ValueInlet(JSONObject::Deserializer&& vis, QObject* parent);
507
508 VIRTUAL_CONSTEXPR PortType type() const noexcept override
509 {
510 return Process::PortType::Message;
511 }
512};
513
514class SCORE_LIB_PROCESS_EXPORT ValueOutlet : public Outlet
515{
516 W_OBJECT(ValueOutlet)
517
518 SCORE_SERIALIZE_FRIENDS
519public:
520 MODEL_METADATA_IMPL_HPP(ValueOutlet)
521 ValueOutlet() = delete;
522 ~ValueOutlet() override;
523 ValueOutlet(const ValueOutlet&) = delete;
524 ValueOutlet(const QString& name, Id<Process::Port> c, QObject* parent);
525
526 ValueOutlet(DataStream::Deserializer& vis, QObject* parent);
527 ValueOutlet(JSONObject::Deserializer& vis, QObject* parent);
528 ValueOutlet(DataStream::Deserializer&& vis, QObject* parent);
529 ValueOutlet(JSONObject::Deserializer&& vis, QObject* parent);
530
531 VIRTUAL_CONSTEXPR PortType type() const noexcept override
532 {
533 return Process::PortType::Message;
534 }
535};
536
537}
538
539DEFAULT_MODEL_METADATA(Process::Port, "Port")
540
541W_REGISTER_ARGTYPE(Id<Process::Port>)
542W_REGISTER_ARGTYPE(Process::Port)
543
544// Q_DECLARE_METATYPE(Process::pan_weight)
545W_REGISTER_ARGTYPE(Process::pan_weight)
DataStreamWriter
Definition DataStreamVisitor.hpp:202
IdentifiedObject
The IdentifiedObject class.
Definition IdentifiedObject.hpp:19
JSONWriter
Definition JSONVisitor.hpp:423
Path
The Path class is a typesafe wrapper around ObjectPath.
Definition Path.hpp:52
Process::AudioInlet
Definition Port.hpp:301
Process::AudioOutlet
Definition Port.hpp:324
Process::Cable
Definition Cable.hpp:38
Process::ControlInlet
Definition Port.hpp:205
Process::ControlOutlet
Definition Port.hpp:426
Process::Inlet
Definition Port.hpp:179
Process::MidiInlet
Definition Port.hpp:380
Process::MidiOutlet
Definition Port.hpp:403
Process::Outlet
Definition Port.hpp:274
Process::Port
Definition Port.hpp:103
Process::ValueInlet
Definition Port.hpp:492
Process::ValueOutlet
Definition Port.hpp:515
Selectable
The Selectable class.
Definition Selectable.hpp:14
id_base_t
The id_base_t class.
Definition Identifier.hpp:59
score::SerializableInterface
Generic serialization method for abstract classes.
Definition SerializableInterface.hpp:21
Process
Base classes and tools to implement processes and layers.
Definition JSONVisitor.hpp:1115
Device::FullAddressAccessorSettings
Definition AddressSettings.hpp:131
Process::PortItemLayout
Definition Port.hpp:90
Process::pan_weight
Definition PortForward.hpp:31
State::AddressAccessor
Definition Address.hpp:108
State::Domain
Definition Domain.hpp:17