X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fardour%2Fbundle.h;h=ef2247f12b84338e609fa594f44e605853fac933;hb=23a2cc4b71845a61dcc01f5663dacd74f198f0c3;hp=77d5e231960bfdb0cda7385094b3e99d2df1748b;hpb=ee42a6dd97045253d1a9bb32fc2e571d235f9967;p=ardour.git diff --git a/libs/ardour/ardour/bundle.h b/libs/ardour/ardour/bundle.h index 77d5e23196..ef2247f12b 100644 --- a/libs/ardour/ardour/bundle.h +++ b/libs/ardour/ardour/bundle.h @@ -1,5 +1,5 @@ /* - Copyright (C) 2002-2007 Paul Davis + Copyright (C) 2002-2007 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 @@ -22,22 +22,25 @@ #include #include -#include -#include +#include #include + +#include "pbd/signals.h" + #include "ardour/data_type.h" +#include "ardour/chan_count.h" namespace ARDOUR { -class AudioEngine; - +class AudioEngine; + /** A set of `channels', each of which is associated with 0 or more ports. - * Each channel has a name which can be anything useful. + * Each channel has a name which can be anything useful, and a data type. * Intended for grouping things like, for example, a buss' outputs. * `Channel' is a rather overloaded term but I can't think of a better * one right now. */ -class Bundle : public sigc::trackable +class LIBARDOUR_API Bundle : public PBD::ScopedConnectionList { public: @@ -47,33 +50,40 @@ class Bundle : public sigc::trackable typedef std::vector PortList; struct Channel { - Channel (std::string n) : name (n) {} + Channel (std::string n, DataType t) : name (n), type (t) {} + Channel (std::string n, DataType t, PortList p) : name (n), type (t), ports (p) {} + Channel (std::string n, DataType t, std::string const & p) : name (n), type (t) { + ports.push_back (p); + } bool operator== (Channel const &o) const { - return name == o.name && ports == o.ports; + return name == o.name && type == o.type && ports == o.ports; } - + std::string name; + DataType type; PortList ports; }; Bundle (bool i = true); Bundle (std::string const &, bool i = true); - Bundle (std::string const &, DataType, bool i = true); Bundle (boost::shared_ptr); - + virtual ~Bundle() {} /** @return Number of channels that this Bundle has */ - uint32_t nchannels () const; + ChanCount nchannels () const; /** @param Channel index. * @return Ports associated with this channel. */ PortList const & channel_ports (uint32_t) const; - void add_channel (std::string const &); + void add_channel (std::string const &, DataType); + void add_channel (std::string const &, DataType, std::string const &); + void add_channel (std::string const &, DataType, PortList); std::string channel_name (uint32_t) const; + DataType channel_type (uint32_t) const; void set_channel_name (uint32_t, std::string const &); void add_port_to_channel (uint32_t, std::string); void set_port (uint32_t, std::string); @@ -81,91 +91,86 @@ class Bundle : public sigc::trackable void remove_ports_from_channel (uint32_t); void remove_ports_from_channels (); bool port_attached_to_channel (uint32_t, std::string); - bool uses_port (std::string) const; + bool offers_port (std::string) const; bool offers_port_alone (std::string) const; void remove_channel (uint32_t); void remove_channels (); void add_channels_from_bundle (boost::shared_ptr); void connect (boost::shared_ptr, AudioEngine &); void disconnect (boost::shared_ptr, AudioEngine &); + bool connected_to (boost::shared_ptr, AudioEngine &); + bool connected_to_anything (AudioEngine &); + bool has_same_ports (boost::shared_ptr) const; + uint32_t type_channel_to_overall (DataType, uint32_t) const; + uint32_t overall_channel_to_type (DataType, uint32_t) const; - /** Set the name. - * @param n New name. - */ - void set_name (std::string const & n) { - _name = n; - Changed (NameChanged); - } + void set_name (std::string const &); /** @return Bundle name */ std::string name () const { return _name; } - /** Set the type of the ports in this Bundle. - * @param t New type. - */ - void set_type (DataType t) { _type = t; } - - /** @return Type of the ports in this Bundle. */ - DataType type () const { return _type; } - - void set_ports_are_inputs () { _ports_are_inputs = true; } - void set_ports_are_outputs () { _ports_are_inputs = false; } + void set_ports_are_inputs (); + void set_ports_are_outputs (); bool ports_are_inputs () const { return _ports_are_inputs; } bool ports_are_outputs () const { return !_ports_are_inputs; } void suspend_signals (); void resume_signals (); + bool operator== (Bundle const & other); + /** Things that might change about this bundle */ enum Change { NameChanged = 0x1, ///< the bundle name or a channel name has changed ConfigurationChanged = 0x2, ///< the number of channels has changed - PortsChanged = 0x4 ///< the port list associated with one of our channels has changed + PortsChanged = 0x4, ///< the port list associated with one of our channels has changed + TypeChanged = 0x8, ///< the data type has changed + DirectionChanged = 0x10 ///< the direction (whether ports are inputs or outputs) has changed }; - sigc::signal Changed; + PBD::Signal1 Changed; protected: - + /// mutex for _channel_ports and _channel_names /// XXX: is this necessary? - mutable Glib::Mutex _channel_mutex; + mutable Glib::Threads::Mutex _channel_mutex; std::vector _channel; private: int set_channels (std::string const &); int parse_io_string (std::string const &, std::vector &); void emit_changed (Change); - + std::string _name; - DataType _type; bool _ports_are_inputs; bool _signals_suspended; Change _pending_change; }; - - -struct BundleChannel +class LIBARDOUR_API BundleChannel { - BundleChannel () : channel (0) {} - - BundleChannel (boost::shared_ptr b, uint32_t c) +public: + BundleChannel () : channel (-1) {} + + BundleChannel (boost::shared_ptr b, int c) : bundle (b), channel (c) {} - + bool operator== (BundleChannel const& other) const { return bundle == other.bundle && channel == other.channel; } - + bool operator!= (BundleChannel const& other) const { return bundle != other.bundle || channel != other.channel; } boost::shared_ptr bundle; - uint32_t channel; + int channel; ///< channel index, or -1 for "all" }; - + } +std::ostream & operator<< (std::ostream & o, ARDOUR::Bundle const &); + #endif /* __ardour_bundle_h__ */