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