#include "pbd/convert.h"
#include "pbd/enumwriter.h"
#include "pbd/replace_all.h"
+#include "pbd/stacktrace.h"
#include <gtkmm2ext/gtk_ui.h>
#include <gtkmm2ext/utils.h>
#include "mixer_strip.h"
#include "mixer_ui.h"
#include "keyboard.h"
-#include "led.h"
+#include "ardour_button.h"
#include "public_editor.h"
#include "send_ui.h"
#include "io_selector.h"
using namespace Gtkmm2ext;
using namespace std;
-sigc::signal<void,boost::shared_ptr<Route> > MixerStrip::SwitchIO;
-
int MixerStrip::scrollbar_height = 0;
PBD::Signal1<void,MixerStrip*> MixerStrip::CatchDeletion;
, processor_box (sess, boost::bind (&MixerStrip::plugin_selector, this), mx.selection(), this, in_mixer)
, gpm (sess, 250)
, panners (sess)
+ , button_size_group (Gtk::SizeGroup::create (Gtk::SIZE_GROUP_HORIZONTAL))
, button_table (3, 1)
- , solo_led_table (2, 2)
+ , rec_solo_table (2, 2)
+ , top_button_table (1, 2)
, middle_button_table (1, 2)
, bottom_button_table (1, 2)
, meter_point_label (_("pre"))
, midi_input_enable_button (0)
+ , _comment_button (_("Comments"))
+ , _visibility (X_("mixer-strip-visibility"))
{
init ();
, processor_box (sess, sigc::mem_fun(*this, &MixerStrip::plugin_selector), mx.selection(), this, in_mixer)
, gpm (sess, 250)
, panners (sess)
+ , button_size_group (Gtk::SizeGroup::create (Gtk::SIZE_GROUP_HORIZONTAL))
, button_table (3, 1)
, middle_button_table (1, 2)
, bottom_button_table (1, 2)
, meter_point_label (_("pre"))
, midi_input_enable_button (0)
+ , _comment_button (_("Comments"))
+ , _visibility (X_("mixer-strip-visibility"))
{
init ();
set_route (rt);
hide_button.set_events (hide_button.get_events() & ~(Gdk::ENTER_NOTIFY_MASK|Gdk::LEAVE_NOTIFY_MASK));
- mute_button->set_name ("MixerMuteButton");
- solo_button->set_name ("MixerSoloButton");
+ monitor_input_button->set_diameter (3);
+ monitor_disk_button->set_diameter (3);
- solo_isolated_led = manage (new LED);
+ solo_isolated_led = manage (new ArdourButton (ArdourButton::led_default_elements));
solo_isolated_led->show ();
- solo_isolated_led->set_diameter (6);
+ solo_isolated_led->set_diameter (3);
solo_isolated_led->set_no_show_all (true);
- solo_isolated_led->set_name (X_("SoloIsolatedLED"));
+ solo_isolated_led->set_name (X_("solo isolate"));
solo_isolated_led->add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
solo_isolated_led->signal_button_release_event().connect (sigc::mem_fun (*this, &RouteUI::solo_isolate_button_release));
UI::instance()->set_tip (solo_isolated_led, _("Isolate Solo"), "");
- solo_safe_led = manage (new LED);
+ solo_safe_led = manage (new ArdourButton (ArdourButton::led_default_elements));
solo_safe_led->show ();
- solo_safe_led->set_diameter (6);
+ solo_safe_led->set_diameter (3);
solo_safe_led->set_no_show_all (true);
- solo_safe_led->set_name (X_("SoloSafeLED"));
+ solo_safe_led->set_name (X_("solo safe"));
solo_safe_led->add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
solo_safe_led->signal_button_release_event().connect (sigc::mem_fun (*this, &RouteUI::solo_safe_button_release));
UI::instance()->set_tip (solo_safe_led, _("Lock Solo Status"), "");
- _iso_label = manage (new Label (_("iso")));
- _safe_label = manage (new Label (_("lock")));
-
- _iso_label->set_name (X_("SoloLEDLabel"));
- _safe_label->set_name (X_("SoloLEDLabel"));
+ solo_safe_led->set_text (_("lock"));
+ solo_isolated_led->set_text (_("iso"));
- _iso_label->show ();
- _safe_label->show ();
+ top_button_table.set_homogeneous (true);
+ top_button_table.set_spacings (2);
+ top_button_table.attach (*monitor_input_button, 0, 1, 0, 1);
+ top_button_table.attach (*monitor_disk_button, 1, 2, 0, 1);
+ top_button_table.show ();
- solo_led_table.set_spacings (0);
- solo_led_table.set_border_width (1);
- solo_led_table.attach (*_iso_label, 0, 1, 0, 1, Gtk::FILL, Gtk::FILL);
- solo_led_table.attach (*solo_isolated_led, 1, 2, 0, 1, Gtk::FILL, Gtk::FILL);
- solo_led_table.attach (*_safe_label, 0, 1, 1, 2, Gtk::FILL, Gtk::FILL);
- solo_led_table.attach (*solo_safe_led, 1, 2, 1, 2, Gtk::FILL, Gtk::FILL);
+ rec_solo_table.set_homogeneous (false);
+ rec_solo_table.set_row_spacings (2);
+ rec_solo_table.set_col_spacings (2);
+ rec_solo_table.attach (*solo_isolated_led, 1, 2, 0, 1);
+ rec_solo_table.attach (*solo_safe_led, 1, 2, 1, 2);
+ rec_solo_table.show ();
- solo_led_table.show ();
- below_panner_box.set_border_width (2);
- below_panner_box.set_spacing (2);
- below_panner_box.pack_end (solo_led_table, false, false);
- below_panner_box.show ();
-
- button_table.set_homogeneous (true);
+ button_table.set_homogeneous (false);
button_table.set_spacings (0);
+ if (solo_button) {
+ button_size_group->add_widget (*solo_button);
+ }
+ if (mute_button) {
+ button_size_group->add_widget (*mute_button);
+ }
+ if (solo_isolated_led) {
+ button_size_group->add_widget (*solo_isolated_led);
+ }
+ if (solo_safe_led) {
+ button_size_group->add_widget (*solo_safe_led);
+ }
+ if (rec_enable_button) {
+ button_size_group->add_widget (*rec_enable_button);
+ }
+ if (monitor_disk_button) {
+ button_size_group->add_widget (*monitor_disk_button);
+ }
+ if (monitor_input_button) {
+ button_size_group->add_widget (*monitor_input_button);
+ }
+
button_table.attach (name_button, 0, 1, 0, 1);
button_table.attach (input_button_box, 0, 1, 1, 2);
button_table.attach (_invert_button_box, 0, 1, 2, 3);
middle_button_table.set_homogeneous (true);
- middle_button_table.set_spacings (0);
+ middle_button_table.set_spacings (2);
middle_button_table.attach (*mute_button, 0, 1, 0, 1);
middle_button_table.attach (*solo_button, 1, 2, 0, 1);
Gtkmm2ext::set_size_request_to_display_given_text (group_button, "Group", 2, 2);
group_label.set_name ("MixerGroupButtonLabel");
+ _comment_button.set_name (X_("MixerCommentButton"));
+ _comment_button.signal_clicked().connect (sigc::mem_fun (*this, &MixerStrip::toggle_comment));
+
global_vpacker.set_border_width (0);
global_vpacker.set_spacing (0);
global_vpacker.pack_start (button_table, Gtk::PACK_SHRINK);
global_vpacker.pack_start (processor_box, true, true);
global_vpacker.pack_start (panners, Gtk::PACK_SHRINK);
- global_vpacker.pack_start (below_panner_box, Gtk::PACK_SHRINK);
- global_vpacker.pack_start (middle_button_table, Gtk::PACK_SHRINK);
+ global_vpacker.pack_start (top_button_table, Gtk::PACK_SHRINK, 2);
+ global_vpacker.pack_start (rec_solo_table, Gtk::PACK_SHRINK, 2);
+ global_vpacker.pack_start (middle_button_table, Gtk::PACK_SHRINK, 2);
global_vpacker.pack_start (gpm, Gtk::PACK_SHRINK);
global_vpacker.pack_start (bottom_button_table, Gtk::PACK_SHRINK);
global_vpacker.pack_start (output_button, Gtk::PACK_SHRINK);
+ global_vpacker.pack_start (_comment_button, Gtk::PACK_SHRINK);
global_frame.add (global_vpacker);
global_frame.set_shadow_type (Gtk::SHADOW_IN);
input_button.signal_button_press_event().connect (sigc::mem_fun(*this, &MixerStrip::input_press), false);
output_button.signal_button_press_event().connect (sigc::mem_fun(*this, &MixerStrip::output_press), false);
- /* we don't need this if its not an audio track, but we don't know that yet and it doesn't
- hurt (much).
- */
-
- rec_enable_button->set_name ("MixerRecordEnableButton");
-
/* ditto for this button and busses */
name_button.signal_button_press_event().connect (sigc::mem_fun(*this, &MixerStrip::name_button_button_press), false);
in update_diskstream_display().
*/
- if (is_midi_track())
+ if (is_midi_track()) {
set_name ("MidiTrackStripBase");
- else
+ } else {
set_name ("AudioTrackStripBase");
+ }
add_events (Gdk::BUTTON_RELEASE_MASK|
Gdk::ENTER_NOTIFY_MASK|
set_flags (get_flags() | Gtk::CAN_FOCUS);
- SwitchIO.connect (sigc::mem_fun (*this, &MixerStrip::switch_io));
-
AudioEngine::instance()->PortConnectedOrDisconnected.connect (
- *this, invalidator (*this), boost::bind (&MixerStrip::port_connected_or_disconnected, this, _1, _2), gui_context ()
+ *this, invalidator (*this), boost::bind (&MixerStrip::port_connected_or_disconnected, this, _1, _3), gui_context ()
);
+
+ /* Add the widgets under visibility control to the VisibilityGroup; the names used here
+ must be the same as those used in RCOptionEditor so that the configuration changes
+ are recognised when they occur.
+ */
+ _visibility.add (&_invert_button_box, X_("PhaseInvert"), _("Phase Invert"));
+ _visibility.add (solo_safe_led, X_("SoloSafe"), _("Solo Safe"), true, boost::bind (&MixerStrip::override_solo_visibility, this));
+ _visibility.add (solo_isolated_led, X_("SoloIsolated"), _("Solo Isolated"), true, boost::bind (&MixerStrip::override_solo_visibility, this));
+ _visibility.add (&_comment_button, X_("Comments"), _("Comments"));
+ _visibility.add (&group_button, X_("Group"), _("Group"));
+ _visibility.add (&meter_point_button, X_("MeterPoint"), _("Meter Point"));
+
+ parameter_changed (X_("mixer-strip-visibility"));
+
+ Config->ParameterChanged.connect (_config_connection, MISSING_INVALIDATOR, ui_bind (&MixerStrip::parameter_changed, this, _1), gui_context());
}
MixerStrip::~MixerStrip ()
MixerStrip::set_route (boost::shared_ptr<Route> rt)
{
if (rec_enable_button->get_parent()) {
- below_panner_box.remove (*rec_enable_button);
+ rec_solo_table.remove (*rec_enable_button);
}
if (show_sends_button->get_parent()) {
- below_panner_box.remove (*show_sends_button);
+ rec_solo_table.remove (*show_sends_button);
}
processor_box.set_route (rt);
if (route()->is_master()) {
solo_button->hide ();
- below_panner_box.hide ();
+ rec_solo_table.hide ();
} else {
solo_button->show ();
- below_panner_box.show ();
+ rec_solo_table.show ();
}
if (_mixer_owned && (route()->is_master() || route()->is_monitor())) {
global_vpacker.pack_start (*spacer, false, false);
}
+ if (is_track()) {
+ monitor_input_button->show ();
+ monitor_disk_button->show ();
+ } else {
+ monitor_input_button->hide();
+ monitor_disk_button->hide ();
+ }
+
if (is_midi_track()) {
if (midi_input_enable_button == 0) {
Image* img = manage (new Image (get_icon (X_("midi_socket_small"))));
if (is_track ()) {
- below_panner_box.pack_start (*rec_enable_button);
+ rec_solo_table.attach (*rec_enable_button, 0, 1, 0, 2);
rec_enable_button->set_sensitive (_session->writable());
rec_enable_button->show();
/* non-master bus */
if (!_route->is_master()) {
- below_panner_box.pack_start (*show_sends_button);
+ rec_solo_table.attach (*show_sends_button, 0, 1, 0, 2);
show_sends_button->show();
}
}
output_label.show();
name_label.show();
name_button.show();
+ _comment_button.show();
group_button.show();
group_label.show();
+ parameter_changed ("mixer-strip-visibility");
+
show ();
}
switch (w) {
case Wide:
if (show_sends_button) {
- ((Gtk::Label*)show_sends_button->get_child())->set_text (_("Sends"));
+ show_sends_button->set_text (_("Sends"));
}
((Gtk::Label*)gpm.gain_automation_style_button.get_child())->set_text (
panners.astate_string(_route->panner()->automation_state()));
}
- _iso_label->show ();
- _safe_label->show ();
+ solo_isolated_led->set_text (_("iso"));
+ solo_safe_led->set_text (_("lock"));
Gtkmm2ext::set_size_request_to_display_given_text (name_button, "long", 2, 2);
set_size_request (-1, -1);
case Narrow:
if (show_sends_button) {
- ((Gtk::Label*)show_sends_button->get_child())->set_text (_("Snd"));
+ show_sends_button->set_text (_("Snd"));
}
((Gtk::Label*)gpm.gain_automation_style_button.get_child())->set_text (
((Gtk::Label*)panners.pan_automation_state_button.get_child())->set_text (
panners.short_astate_string(_route->panner()->automation_state()));
}
-
- _iso_label->hide ();
- _safe_label->hide ();
+
+ solo_isolated_led->set_text ("");
+ solo_safe_led->set_text ("");
Gtkmm2ext::set_size_request_to_display_given_text (name_button, longest_label.c_str(), 2, 2);
set_size_request (max (50, gpm.get_gm_width()), -1);
update_input_display ();
update_output_display ();
+ setup_comment_button ();
route_group_changed ();
name_changed ();
WidthChanged ();
output_menu_bundles.clear ();
citems.push_back (MenuElem (_("Disconnect"), sigc::mem_fun (*(static_cast<RouteUI*>(this)), &RouteUI::disconnect_output)));
+
+ for (DataType::iterator i = DataType::begin(); i != DataType::end(); ++i) {
+ citems.push_back (
+ MenuElem (
+ string_compose ("Add %1 port", (*i).to_i18n_string()),
+ sigc::bind (sigc::mem_fun (*this, &MixerStrip::add_output_port), *i)
+ )
+ );
+ }
+
citems.push_back (SeparatorElem());
ARDOUR::BundleList current = _route->output()->bundles_connected ();
case 3:
{
citems.push_back (MenuElem (_("Disconnect"), sigc::mem_fun (*(static_cast<RouteUI*>(this)), &RouteUI::disconnect_input)));
+
+ for (DataType::iterator i = DataType::begin(); i != DataType::end(); ++i) {
+ citems.push_back (
+ MenuElem (
+ string_compose ("Add %1 port", (*i).to_i18n_string()),
+ sigc::bind (sigc::mem_fun (*this, &MixerStrip::add_input_port), *i)
+ )
+ );
+ }
+
citems.push_back (SeparatorElem());
input_menu_bundles.clear ();
{
using namespace Menu_Helpers;
- if (b->ports_are_outputs() == false || b->nchannels() != _route->n_inputs()) {
+ if (b->ports_are_outputs() == false || b->nchannels() != _route->n_inputs() || *b == *_route->output()->bundle()) {
return;
}
{
using namespace Menu_Helpers;
- if (b->ports_are_inputs() == false || b->nchannels() != _route->n_outputs()) {
+ if (b->ports_are_inputs() == false || b->nchannels() != _route->n_outputs() || *b == *_route->input()->bundle()) {
return;
}
{
uint32_t io_count;
uint32_t io_index;
- Port *port;
+ boost::shared_ptr<Port> port;
vector<string> port_connections;
uint32_t total_connection_count = 0;
}
void
-MixerStrip::port_connected_or_disconnected (Port* a, Port* b)
+MixerStrip::port_connected_or_disconnected (boost::weak_ptr<Port> wa, boost::weak_ptr<Port> wb)
{
- if (_route->input()->has_port (a) || _route->input()->has_port (b)) {
+ boost::shared_ptr<Port> a = wa.lock ();
+ boost::shared_ptr<Port> b = wb.lock ();
+
+ if ((a && _route->input()->has_port (a)) || (b && _route->input()->has_port (b))) {
update_input_display ();
set_width_enum (_width, this);
}
- if (_route->output()->has_port (a) || _route->output()->has_port (b)) {
+ if ((a && _route->output()->has_port (a)) || (b && _route->output()->has_port (b))) {
update_output_display ();
set_width_enum (_width, this);
}
}
void
-MixerStrip::comment_editor_done_editing ()
+MixerStrip::setup_comment_button ()
{
- ignore_toggle = true;
- _comment_menu_item->set_active (false);
- ignore_toggle = false;
+ switch (_width) {
+
+ case Wide:
+ if (_route->comment().empty ()) {
+ _comment_button.unset_bg (STATE_NORMAL);
+ ((Gtk::Label *) _comment_button.get_child ())->set_text (_("Comments"));
+ } else {
+ _comment_button.modify_bg (STATE_NORMAL, color ());
+ ((Gtk::Label *) _comment_button.get_child ())->set_text (_("*Comments*"));
+ }
+ break;
+
+ case Narrow:
+ if (_route->comment().empty ()) {
+ _comment_button.unset_bg (STATE_NORMAL);
+ ((Gtk::Label *) _comment_button.get_child ())->set_text (_("Cmt"));
+ } else {
+ _comment_button.modify_bg (STATE_NORMAL, color ());
+ ((Gtk::Label *) _comment_button.get_child ())->set_text (_("*Cmt*"));
+ }
+ break;
+ }
+
+ ARDOUR_UI::instance()->set_tip (
+ _comment_button, _route->comment().empty() ? _("Click to Add/Edit Comments") : _route->comment()
+ );
+}
+void
+MixerStrip::comment_editor_done_editing ()
+{
string const str = comment_area->get_buffer()->get_text();
if (str == _route->comment ()) {
return;
}
_route->set_comment (str, this);
+ setup_comment_button ();
}
void
MenuList& items = route_ops_menu->items();
items.push_back (CheckMenuElem (_("Comments..."), sigc::mem_fun (*this, &MixerStrip::toggle_comment)));
- _comment_menu_item = dynamic_cast<CheckMenuItem*> (&items.back ());
+ CheckMenuItem* i = dynamic_cast<CheckMenuItem*> (&items.back ());
+ i->set_active (comment_window && comment_window->is_visible ());
items.push_back (MenuElem (_("Save As Template..."), sigc::mem_fun(*this, &RouteUI::save_as_template)));
items.push_back (MenuElem (_("Rename..."), sigc::mem_fun(*this, &RouteUI::route_rename)));
rename_menu_item = &items.back();
+
items.push_back (SeparatorElem());
items.push_back (CheckMenuElem (_("Active")));
- CheckMenuItem* i = dynamic_cast<CheckMenuItem *> (&items.back());
+ i = dynamic_cast<CheckMenuItem *> (&items.back());
i->set_active (_route->active());
i->signal_activate().connect (sigc::bind (sigc::mem_fun (*this, &RouteUI::set_route_active), !_route->active(), false));
gpm.reset_peak_display();
}
+/** The bus that we are displaying sends to has changed, or been turned off.
+ * @param send_to New bus that we are displaying sends to, or 0.
+ */
void
-MixerStrip::switch_io (boost::shared_ptr<Route> target)
+MixerStrip::bus_send_display_changed (boost::shared_ptr<Route> send_to)
{
- /* don't respond to switch IO signal outside of the mixer window */
-
- if (!_mixer_owned) {
- return;
- }
-
- if (_route == target || _route->is_master()) {
- /* don't change the display for the target or the master bus */
- return;
- } else if (!is_track() && show_sends_button) {
- /* make sure our show sends button is inactive, and we no longer blink,
- since we're not the target.
- */
- send_blink_connection.disconnect ();
- show_sends_button->set_active (false);
- show_sends_button->set_state (STATE_NORMAL);
- }
+ RouteUI::bus_send_display_changed (send_to);
- if (!target) {
- /* switch back to default */
- revert_to_default_display ();
- return;
- }
-
- boost::shared_ptr<Send> send = _route->internal_send_for (target);
-
- if (send) {
- show_send (send);
+ if (send_to) {
+ boost::shared_ptr<Send> send = _route->internal_send_for (send_to);
+ if (send) {
+ show_send (send);
+ } else {
+ revert_to_default_display ();
+ }
} else {
revert_to_default_display ();
}
rec_enable_button->set_sensitive (true);
solo_isolated_led->set_sensitive (true);
solo_safe_led->set_sensitive (true);
+ monitor_input_button->set_sensitive (true);
+ monitor_disk_button->set_sensitive (true);
+ _comment_button.set_sensitive (true);
}
void
rec_enable_button->set_sensitive (false);
solo_isolated_led->set_sensitive (false);
solo_safe_led->set_sensitive (false);
+ monitor_input_button->set_sensitive (false);
+ monitor_disk_button->set_sensitive (false);
+ _comment_button.set_sensitive (false);
if (boost::dynamic_pointer_cast<InternalSend>(send)) {
output_button.set_sensitive (false);
void
MixerStrip::revert_to_default_display ()
{
- if (show_sends_button) {
- show_sends_button->set_active (false);
- }
-
drop_send ();
set_current_delivery (_route->main_outs ());
{
switch (_width) {
case Wide:
- rec_enable_button_label.set_text (_("Rec"));
- mute_button_label.set_text (_("Mute"));
+ rec_enable_button->set_text (_("Rec"));
+ mute_button->set_text (_("Mute"));
+ monitor_input_button->set_text (_("In"));
+ monitor_disk_button->set_text (_("Disk"));
+
if (_route && _route->solo_safe()) {
- solo_button_label.set_text (X_("!"));
+ if (solo_safe_pixbuf == 0) {
+ solo_safe_pixbuf = ::get_icon("solo-safe-icon");
+ }
+ solo_button->set_image (solo_safe_pixbuf);
+ solo_button->set_text (string());
} else {
+ solo_button->set_image (Glib::RefPtr<Gdk::Pixbuf>());
if (!Config->get_solo_control_is_listen_control()) {
- solo_button_label.set_text (_("Solo"));
+ solo_button->set_text (_("Solo"));
} else {
switch (Config->get_listen_position()) {
case AfterFaderListen:
- solo_button_label.set_text (_("AFL"));
+ solo_button->set_text (_("AFL"));
break;
case PreFaderListen:
- solo_button_label.set_text (_("PFL"));
+ solo_button->set_text (_("PFL"));
break;
}
}
break;
default:
- rec_enable_button_label.set_text (_("R"));
- mute_button_label.set_text (_("M"));
+ rec_enable_button->set_text (_("R"));
+ mute_button->set_text (_("M"));
+ monitor_input_button->set_text (_("I"));
+ monitor_disk_button->set_text (_("D"));
if (_route && _route->solo_safe()) {
- solo_button_label.set_text (X_("!"));
+ solo_button->remove ();
+ if (solo_safe_pixbuf == 0) {
+ solo_safe_pixbuf =::get_icon("solo-safe-icon");
+ }
+ solo_button->set_image (solo_safe_pixbuf);
+ solo_button->set_text (string());
+ } else {
+ solo_button->set_image (Glib::RefPtr<Gdk::Pixbuf>());
if (!Config->get_solo_control_is_listen_control()) {
- solo_button_label.set_text (_("S"));
+ solo_button->set_text (_("S"));
} else {
switch (Config->get_listen_position()) {
case AfterFaderListen:
- solo_button_label.set_text (_("A"));
+ solo_button->set_text (_("A"));
break;
case PreFaderListen:
- solo_button_label.set_text (_("P"));
+ solo_button->set_text (_("P"));
break;
}
}
}
bool
-MixerStrip::input_active_button_press (GdkEventButton* ev)
+MixerStrip::input_active_button_press (GdkEventButton*)
{
/* nothing happens on press */
return true;
{
return string_compose ("strip %1", _route->id().to_s());
}
+
+void
+MixerStrip::parameter_changed (string p)
+{
+ if (p == _visibility.get_state_name()) {
+ /* The user has made changes to the mixer strip visibility, so get
+ our VisibilityGroup to reflect these changes in our widgets.
+ */
+ _visibility.set_state (Config->get_mixer_strip_visibility ());
+ }
+}
+
+/** Called to decide whether the solo isolate / solo lock button visibility should
+ * be overridden from that configured by the user. We do this for the master bus.
+ *
+ * @return optional value that is present if visibility state should be overridden.
+ */
+boost::optional<bool>
+MixerStrip::override_solo_visibility () const
+{
+ if (_route && _route->is_master ()) {
+ return boost::optional<bool> (false);
+ }
+
+ return boost::optional<bool> ();
+}
+
+void
+MixerStrip::add_input_port (DataType t)
+{
+ _route->input()->add_port ("", this, t);
+}
+
+void
+MixerStrip::add_output_port (DataType t)
+{
+ _route->output()->add_port ("", this, t);
+}
+
+void
+MixerStrip::route_active_changed ()
+{
+ reset_strip_style ();
+}
projects / ardour.git / blobdiff