1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
/*
Copyright (C) 2002 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef __ardour_bundle_h__
#define __ardour_bundle_h__
#include <vector>
#include <string>
#include <sigc++/signal.h>
#include <glibmm/thread.h>
#include <pbd/stateful.h>
using std::vector;
using std::string;
namespace ARDOUR {
/**
* A set of `channels', each of which is associated with 0 or more
* JACK ports.
*/
class Bundle : public Stateful, public sigc::trackable {
public:
/**
* Bundle constructor.
* @param name Name for this Bundle.
* @param dy true if this Bundle is `dynamic', ie it is created on-the-fly
* and should not be written to the session file.
*/
Bundle (string name, bool dy = false) : _name (name), _dynamic(dy) {}
~Bundle() {}
/// A vector of JACK port names
typedef vector<string> PortList;
void set_name (string name, void *src);
/**
* @return name of this Bundle.
*/
string name() const { return _name; }
/**
* @return true if this Bundle is marked as `dynamic', meaning
* that it won't be written to the session file.
*/
bool dynamic() const { return _dynamic; }
/**
* @return Number of channels that this Bundle has.
*/
uint32_t nchannels () const { return _channels.size(); }
const PortList& channel_ports (int ch) const;
void set_nchannels (int n);
void add_port_to_channel (int ch, string portname);
void remove_port_from_channel (int ch, string portname);
/// Our name changed
sigc::signal<void, void*> NameChanged;
/// The number of channels changed
sigc::signal<void> ConfigurationChanged;
/// The ports associated with one of our channels changed
sigc::signal<void, int> PortsChanged;
bool operator==(const Bundle& other) const;
XMLNode& get_state (void);
int set_state (const XMLNode&);
protected:
Bundle (const XMLNode&);
private:
mutable Glib::Mutex channels_lock; ///< mutex for _channels
vector<PortList> _channels; ///< list of JACK ports associated with each of our channels
string _name; ///< name
bool _dynamic; ///< true if `dynamic', ie not to be written to the session file
int set_channels (const string& str);
int parse_io_string (const string& str, vector<string>& ports);
};
/**
* Bundle in which the JACK ports are inputs.
*/
class InputBundle : public Bundle {
public:
/**
* InputBundle constructor.
* \param name Name.
* \param dy true if this Bundle is `dynamic'; ie it is created on-the-fly
* and should not be written to the session file.
*/
InputBundle (string name, bool dy = false) : Bundle (name, dy) {}
InputBundle (const XMLNode&);
};
/**
* Bundle in which the JACK ports are outputs.
*/
class OutputBundle : public Bundle {
public:
OutputBundle (string name, bool dy = false) : Bundle (name, dy) {}
OutputBundle (const XMLNode&);
};
}
#endif /* __ardour_bundle_h__ */
|
