#include "ardour/session.h"
#include "ardour/types.h"
#include "ardour/user_bundle.h"
+#include "ardour/vca.h"
+#include "ardour/vca_manager.h"
-#include "ardour_ui.h"
#include "ardour_window.h"
#include "mixer_strip.h"
#include "mixer_ui.h"
#include "gui_thread.h"
#include "route_group_menu.h"
#include "meter_patterns.h"
+#include "tooltips.h"
#include "ui_config.h"
#include "i18n.h"
using namespace ArdourMeter;
MixerStrip* MixerStrip::_entered_mixer_strip;
-
PBD::Signal1<void,MixerStrip*> MixerStrip::CatchDeletion;
+static const uint32_t n_vca_buttons = 4;
+
MixerStrip::MixerStrip (Mixer_UI& mx, Session* sess, bool in_mixer)
: AxisView(sess)
, RouteUI (sess)
, solo_iso_table (1, 2)
, mute_solo_table (1, 2)
, bottom_button_table (1, 3)
+ , vca_table (1, 4)
, meter_point_button (_("pre"))
+ , monitor_section_button (0)
, midi_input_enable_button (0)
, _comment_button (_("Comments"))
, trim_control (ArdourKnob::default_elements, ArdourKnob::Flags (ArdourKnob::Detent | ArdourKnob::ArcToZero))
, solo_iso_table (1, 2)
, mute_solo_table (1, 2)
, bottom_button_table (1, 3)
+ , vca_table (1, 4)
, meter_point_button (_("pre"))
+ , monitor_section_button (0)
, midi_input_enable_button (0)
, _comment_button (_("Comments"))
, trim_control (ArdourKnob::default_elements, ArdourKnob::Flags (ArdourKnob::Detent | ArdourKnob::ArcToZero))
if (_mixer_owned) {
t += string_compose (_("\n%1-%2-click to toggle the width of all strips."), Keyboard::primary_modifier_name(), Keyboard::tertiary_modifier_name ());
}
-
+
width_button.set_icon (ArdourIcon::StripWidth);
- ARDOUR_UI::instance()->set_tip (width_button, t);
+ set_tooltip (width_button, t);
hide_button.set_icon (ArdourIcon::CloseCross);
- ARDOUR_UI::instance()->set_tip (&hide_button, _("Hide this mixer strip"));
+ set_tooltip (&hide_button, _("Hide this mixer strip"));
input_button_box.set_spacing(2);
-
+
input_button.set_text (_("Input"));
input_button.set_name ("mixer strip button");
input_button_box.pack_start (input_button, true, true);
output_button.set_text (_("Output"));
output_button.set_name ("mixer strip button");
- ARDOUR_UI::instance()->set_tip (&meter_point_button, _("Click to select metering point"), "");
+ set_tooltip (&meter_point_button, _("Click to select metering point"));
meter_point_button.set_name ("mixer strip button");
bottom_button_table.attach (meter_point_button, 2, 3, 0, 1);
meter_point_button.signal_button_press_event().connect (sigc::mem_fun (gpm, &GainMeter::meter_press), false);
meter_point_button.signal_button_release_event().connect (sigc::mem_fun (gpm, &GainMeter::meter_release), false);
-
+
hide_button.set_events (hide_button.get_events() & ~(Gdk::ENTER_NOTIFY_MASK|Gdk::LEAVE_NOTIFY_MASK));
solo_isolated_led = manage (new ArdourButton (ArdourButton::led_default_elements));
}
solo_iso_table.show ();
+ vca_table.set_homogeneous (true);
+ vca_table.set_spacings (1);
+ for (uint32_t n = 0; n < n_vca_buttons; ++n) {
+ ArdourButton* v = manage (new ArdourButton (ArdourButton::default_elements));
+ vca_buttons.push_back (v); /* no ownership transfer, button is managed by its container */
+ v->set_no_show_all (true);
+ v->set_name (X_("vca assign"));
+ v->add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
+ v->signal_button_release_event().connect (sigc::bind (sigc::mem_fun (*this, &MixerStrip::vca_button_release), n), false);
+ UI::instance()->set_tip (*v, string_compose (_("VCA %1 assign"), n));
+ v->set_text (_("v."));
+ v->show ();
+ vca_table.attach (*v, n, n+1, 0, 1);
+ }
+ vca_table.show ();
+
rec_mon_table.set_homogeneous (true);
rec_mon_table.set_row_spacings (2);
rec_mon_table.set_col_spacings (2);
button_size_group->add_widget (*monitor_input_button);
}
}
-
+
mute_solo_table.set_homogeneous (true);
mute_solo_table.set_spacings (2);
name_button.set_text_ellipsize (Pango::ELLIPSIZE_END);
name_button.signal_size_allocate().connect (sigc::mem_fun (*this, &MixerStrip::name_button_resized));
- ARDOUR_UI::instance()->set_tip (&group_button, _("Mix group"), "");
+ set_tooltip (&group_button, _("Mix group"));
group_button.set_name ("mixer strip button");
_comment_button.set_name (X_("mixer strip button"));
global_vpacker.pack_start (solo_iso_table, Gtk::PACK_SHRINK);
global_vpacker.pack_start (mute_solo_table, Gtk::PACK_SHRINK);
global_vpacker.pack_start (gpm, Gtk::PACK_SHRINK);
+ global_vpacker.pack_start (vca_table, Gtk::PACK_SHRINK);
global_vpacker.pack_start (bottom_button_table, Gtk::PACK_SHRINK);
if (!ARDOUR::Profile->get_trx()) {
global_vpacker.pack_start (output_button, Gtk::PACK_SHRINK);
_visibility.add (&solo_iso_table, X_("SoloIsoLock"), _("Solo Iso / Lock"), false);
_visibility.add (&output_button, X_("Output"), _("Output"), false);
_visibility.add (&_comment_button, X_("Comments"), _("Comments"), false);
+ _visibility.add (&vca_table, X_("VCA"), _("VCA Assigns"), false);
parameter_changed (X_("mixer-element-visibility"));
UIConfiguration::instance().ParameterChanged.connect (sigc::mem_fun (*this, &MixerStrip::parameter_changed));
MixerStrip::mixer_strip_enter_event (GdkEventCrossing* /*ev*/)
{
_entered_mixer_strip = this;
-
+
//although we are triggering on the "enter", to the user it will appear that it is happenin on the "leave"
//because the mixerstrip control is a parent that encompasses the strip
deselect_all_processors();
//if we leave this mixer strip we need to clear out any selections
//processor_box.processor_display.select_none(); //but this doesn't work, because it gets triggered when (for example) you open the menu or start a drag
}
-
+
return false;
}
if (group_button.get_parent()) {
bottom_button_table.remove (group_button);
}
-
+
RouteUI::set_route (rt);
/* ProcessorBox needs access to _route so that it can read
/* unpack these from the parent and stuff them into our own
table
*/
-
+
if (gpm.peak_display.get_parent()) {
gpm.peak_display.get_parent()->remove (gpm.peak_display);
}
}
gpm.set_type (rt->meter_type());
-
+
mute_solo_table.attach (gpm.gain_display,0,1,1,2, EXPAND|FILL, EXPAND);
mute_solo_table.attach (gpm.peak_display,1,2,1,2, EXPAND|FILL, EXPAND);
}
if (route()->is_master()) {
- mute_solo_table.attach (*mute_button, 0, 2, 0, 1);
solo_button->hide ();
mute_button->show ();
rec_mon_table.hide ();
if (solo_iso_table.get_parent()) {
solo_iso_table.get_parent()->remove(solo_iso_table);
}
+ if (monitor_section_button == 0) {
+ Glib::RefPtr<Action> act = ActionManager::get_action ("Common", "ToggleMonitorSection");
+ _session->MonitorChanged.connect (route_connections, invalidator (*this), boost::bind (&MixerStrip::monitor_changed, this), gui_context());
+
+ monitor_section_button = manage (new ArdourButton);
+ monitor_changed ();
+ monitor_section_button->set_related_action (act);
+ set_tooltip (monitor_section_button, _("Show/Hide Monitoring Section"));
+ mute_solo_table.attach (*monitor_section_button, 1, 2, 0, 1);
+ monitor_section_button->show();
+ monitor_section_button->unset_flags (Gtk::CAN_FOCUS);
+ }
+ parameter_changed ("use-monitor-bus");
} else {
bottom_button_table.attach (group_button, 1, 2, 0, 1);
mute_solo_table.attach (*mute_button, 0, 1, 0, 1);
midi_input_enable_button->set_icon (ArdourIcon::DinMidi);
midi_input_enable_button->signal_button_press_event().connect (sigc::mem_fun (*this, &MixerStrip::input_active_button_press), false);
midi_input_enable_button->signal_button_release_event().connect (sigc::mem_fun (*this, &MixerStrip::input_active_button_release), false);
- ARDOUR_UI::instance()->set_tip (midi_input_enable_button, _("Enable/Disable MIDI input"));
+ set_tooltip (midi_input_enable_button, _("Enable/Disable MIDI input"));
} else {
input_button_box.remove (*midi_input_enable_button);
}
if (is_track ()) {
rec_mon_table.attach (*rec_enable_button, 0, 1, 0, ARDOUR::Profile->get_mixbus() ? 1 : 2);
- rec_enable_button->set_sensitive (_session->writable());
rec_enable_button->show();
if (ARDOUR::Profile->get_mixbus()) {
update_mute_display ();
update_solo_display ();
name_changed ();
- comment_changed (0);
+ comment_changed ();
route_group_changed ();
connect_to_pan ();
gpm.gain_automation_state_button.show();
parameter_changed ("mixer-element-visibility");
+ map_frozen();
show ();
}
edit_output_configuration ();
break;
}
-
+
return false;
}
citems.pop_back ();
}
- citems.push_back (SeparatorElem());
+ if (!ARDOUR::Profile->get_mixbus()) {
+ citems.push_back (SeparatorElem());
- 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)
- )
- );
+ 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());
citems.push_back (MenuElem (_("Routing Grid"), sigc::mem_fun (*(static_cast<RouteUI*>(this)), &RouteUI::edit_output_configuration)));
citems.push_back (SeparatorElem());
uint32_t const n_with_separator = citems.size ();
-
+
input_menu_bundles.clear ();
ARDOUR::BundleList current = _route->input()->bundles_connected ();
{
using namespace Menu_Helpers;
- if (b->ports_are_outputs() == false || b->nchannels() != _route->n_inputs() || *b == *_route->output()->bundle()) {
- return;
- }
+ if (b->ports_are_outputs() == false || b->nchannels() != _route->n_inputs() || *b == *_route->output()->bundle()) {
+ return;
+ }
list<boost::shared_ptr<Bundle> >::iterator i = input_menu_bundles.begin ();
while (i != input_menu_bundles.end() && b->has_same_ports (*i) == false) {
{
using namespace Menu_Helpers;
- if (b->ports_are_inputs() == false || b->nchannels() != _route->n_outputs() || *b == *_route->input()->bundle()) {
- return;
- }
+ if (b->ports_are_inputs() == false || b->nchannels() != _route->n_outputs() || *b == *_route->input()->bundle()) {
+ return;
+ }
list<boost::shared_ptr<Bundle> >::iterator i = output_menu_bundles.begin ();
while (i != output_menu_bundles.end() && b->has_same_ports (*i) == false) {
ostringstream tooltip;
char * tooltip_cstr;
-
+
//to avoid confusion, the button caption should only show connections that match the datatype of the track
DataType dt = DataType::AUDIO;
if ( boost::dynamic_pointer_cast<MidiTrack>(route) != 0 ) {
if (for_input) {
io_count = route->n_inputs().n_total();
- tooltip << string_compose (_("<b>INPUT</b> to %1"), Glib::Markup::escape_text(route->name()));
+ tooltip << string_compose (_("<b>INPUT</b> to %1"), Gtkmm2ext::markup_escape_text (route->name()));
} else {
io_count = route->n_outputs().n_total();
- tooltip << string_compose (_("<b>OUTPUT</b> from %1"), Glib::Markup::escape_text(route->name()));
+ tooltip << string_compose (_("<b>OUTPUT</b> from %1"), Gtkmm2ext::markup_escape_text (route->name()));
}
} else {
port = route->output()->nth (io_index);
}
-
+
port_connections.clear ();
port->get_connections(port_connections);
}
if (io_connection_count == 0) {
- tooltip << endl << Glib::Markup::escape_text(port->name().substr(port->name().find("/") + 1))
+ tooltip << endl << Gtkmm2ext::markup_escape_text (port->name().substr(port->name().find("/") + 1))
<< " -> "
- << Glib::Markup::escape_text( pn.empty() ? connection_name : pn );
+ << Gtkmm2ext::markup_escape_text ( pn.empty() ? connection_name : pn );
} else {
tooltip << ", "
- << Glib::Markup::escape_text( pn.empty() ? connection_name : pn );
+ << Gtkmm2ext::markup_escape_text ( pn.empty() ? connection_name : pn );
}
- if (connection_name.find("ardour:") == 0) {
+ if (connection_name.find(RouteUI::program_port_prefix) == 0) {
if (ardour_track_name.empty()) {
// "ardour:Master/in 1" -> "ardour:Master/"
string::size_type slash = connection_name.find("/");
strcpy(tooltip_cstr, tooltip.str().c_str());
if (for_input) {
- ARDOUR_UI::instance()->set_tip (&input_button, tooltip_cstr, "");
- } else {
- ARDOUR_UI::instance()->set_tip (&output_button, tooltip_cstr, "");
+ set_tooltip (&input_button, tooltip_cstr);
+ } else {
+ set_tooltip (&output_button, tooltip_cstr);
}
+ delete [] tooltip_cstr;
+
if (each_io_has_one_connection) {
if (total_connection_count == ardour_connection_count) {
// all connections are to the same track in ardour
// "ardour:Master/" -> "Master"
string::size_type slash = ardour_track_name.find("/");
if (slash != string::npos) {
- label << ardour_track_name.substr(7, slash - 7);
+ const size_t ppps = RouteUI::program_port_prefix.size (); // "ardour:"
+ label << ardour_track_name.substr (ppps, slash - ppps);
have_label = true;
}
}
MixerStrip::update_input_display ()
{
update_io_button (_route, _width, true);
- panners.setup_pan ();
+ panners.setup_pan ();
if (has_audio_outputs ()) {
panners.show_all ();
MixerStrip::update_output_display ()
{
update_io_button (_route, _width, false);
- gpm.setup_meters ();
- panners.setup_pan ();
+ gpm.setup_meters ();
+ panners.setup_pan ();
if (has_audio_outputs ()) {
panners.show_all ();
break;
}
- ARDOUR_UI::instance()->set_tip (
- _comment_button, _route->comment().empty() ? _("Click to Add/Edit Comments") : _route->comment()
+ set_tooltip (
+ _comment_button, _route->comment().empty() ? _("Click to add/edit comments") : _route->comment()
);
}
i->set_sensitive(! _session->transport_rolling());
i->signal_activate().connect (sigc::bind (sigc::mem_fun (*this, &RouteUI::set_route_active), !_route->active(), false));
- items.push_back (SeparatorElem());
+ if (!Profile->get_mixbus ()) {
+ items.push_back (SeparatorElem());
+ items.push_back (CheckMenuElem (_("Strict I/O")));
+ i = dynamic_cast<Gtk::CheckMenuItem *> (&items.back());
+ i->set_active (_route->strict_io());
+ i->signal_activate().connect (sigc::hide_return (sigc::bind (sigc::mem_fun (*_route, &Route::set_strict_io), !_route->strict_io())));
+ }
+ if (1 /* TODO IFF >= 1 plugin-insert */) {
+ items.push_back (SeparatorElem());
+ items.push_back (MenuElem (_("Pin Connections..."), sigc::mem_fun (*this, &RouteUI::manage_pins)));
+ }
+
+ items.push_back (SeparatorElem());
items.push_back (MenuElem (_("Adjust Latency..."), sigc::mem_fun (*this, &RouteUI::adjust_latency)));
items.push_back (SeparatorElem());
denormal_menu_item = dynamic_cast<Gtk::CheckMenuItem *> (&items.back());
denormal_menu_item->set_active (_route->denormal_protection());
- if (!Profile->get_sae()) {
- items.push_back (SeparatorElem());
- items.push_back (MenuElem (_("Remote Control ID..."), sigc::mem_fun (*this, &RouteUI::open_remote_control_id_dialog)));
- }
-
items.push_back (SeparatorElem());
+ items.push_back (MenuElem (_("Remote Control ID..."), sigc::mem_fun (*this, &RouteUI::open_remote_control_id_dialog)));
if (_route) {
/* note that this relies on selection being shared across editor and
if (!selection.selected (rtav)) {
selection.set (rtav);
}
-
- items.push_front (MenuElem (_("Remove"), sigc::mem_fun(PublicEditor::instance(), &PublicEditor::remove_tracks)));
+
+ if (!_route->is_master()) {
+ items.push_back (SeparatorElem());
+ items.push_back (MenuElem (_("Duplicate..."), sigc::mem_fun (*this, &RouteUI::duplicate_selected_routes)));
+ }
+
+ items.push_back (SeparatorElem());
+ items.push_back (MenuElem (_("Remove"), sigc::mem_fun(PublicEditor::instance(), &PublicEditor::remove_tracks)));
}
}
}
/* do not allow rename if the track is record-enabled */
rename_menu_item->set_sensitive (!_route->record_enabled());
route_ops_menu->popup (1, ev->time);
-
+
return true;
}
global_frame.set_name ("MixerStripFrame");
}
global_frame.queue_draw ();
-
+
// if (!yn)
// processor_box.deselect_all_processors();
}
break;
}
- ARDOUR_UI::instance()->set_tip (name_button, _route->name());
+ set_tooltip (name_button, _route->name());
if (_session->config.get_track_name_number()) {
const int64_t track_number = _route->track_number ();
if (ev->button != 1) {
return false;
}
-
+
if (Keyboard::modifier_state_contains (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier | Keyboard::TertiaryModifier)) && _mixer_owned) {
switch (_width) {
case Wide:
// XXX need some way, maybe, to retoggle redirect editors
break;
}
+ } else {
+ processor_box.set_sensitive (true);
}
+ RouteUI::map_frozen ();
}
void
case MeterInput:
return _("In");
break;
-
+
case MeterPreFader:
return _("Pre");
break;
-
+
case MeterPostFader:
return _("Post");
break;
-
+
case MeterOutput:
return _("Out");
break;
-
+
case MeterCustom:
default:
return _("Custom");
case MeterInput:
return S_("Meter|In");
break;
-
+
case MeterPreFader:
return S_("Meter|Pr");
break;
-
+
case MeterPostFader:
return S_("Meter|Po");
break;
-
+
case MeterOutput:
return S_("Meter|O");
break;
-
+
case MeterCustom:
default:
return S_("Meter|C");
return string();
}
+/** Called when the monitor-section state */
+void
+MixerStrip::monitor_changed ()
+{
+ assert (monitor_section_button);
+ if (_session->monitor_active()) {
+ monitor_section_button->set_name ("master monitor section button active");
+ } else {
+ monitor_section_button->set_name ("master monitor section button normal");
+ }
+}
+
/** Called when the metering point has changed */
void
MixerStrip::meter_changed ()
meter_point_button.set_sensitive (true);
mute_button->set_sensitive (true);
solo_button->set_sensitive (true);
- 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);
+ RouteUI::check_rec_enable_sensitivity ();
+ set_button_names (); // update solo button visual state
}
void
send->set_metering (true);
_current_delivery->DropReferences.connect (send_gone_connection, invalidator (*this), boost::bind (&MixerStrip::revert_to_default_display, this), gui_context());
- gain_meter().set_controls (_route, send->meter(), send->amp());
+ gain_meter().set_controls (_route, send->meter(), send->amp(), send->gain_control());
gain_meter().setup_meters ();
uint32_t const in = _current_delivery->pans_required();
set_current_delivery (_route->main_outs ());
- gain_meter().set_controls (_route, _route->shared_peak_meter(), _route->amp());
+ gain_meter().set_controls (_route, _route->shared_peak_meter(), _route->amp(), _route->gain_control());
gain_meter().setup_meters ();
panner_ui().set_panner (_route->main_outs()->panner_shell(), _route->main_outs()->panner());
mute_button->set_text (_("Mute"));
monitor_input_button->set_text (_("In"));
monitor_disk_button->set_text (_("Disk"));
+ if (monitor_section_button) {
+ monitor_section_button->set_text (_("Mon"));
+ }
if (_route && _route->solo_safe()) {
solo_button->set_visual_state (Gtkmm2ext::VisualState (solo_button->visual_state() | Gtkmm2ext::Insensitive));
mute_button->set_text (S_("Mute|M"));
monitor_input_button->set_text (S_("MonitorInput|I"));
monitor_disk_button->set_text (S_("MonitorDisk|D"));
+ if (monitor_section_button) {
+ monitor_section_button->set_text (S_("Mon|O"));
+ }
if (_route && _route->solo_safe()) {
solo_button->set_visual_state (Gtkmm2ext::VisualState (solo_button->visual_state() | Gtkmm2ext::Insensitive));
else if (p == "track-name-number") {
name_changed ();
}
+ else if (p == "use-monitor-bus") {
+ if (monitor_section_button) {
+ if (mute_button->get_parent()) {
+ mute_button->get_parent()->remove(*mute_button);
+ }
+ if (monitor_section_button->get_parent()) {
+ monitor_section_button->get_parent()->remove(*monitor_section_button);
+ }
+ if (Config->get_use_monitor_bus ()) {
+ mute_solo_table.attach (*mute_button, 0, 1, 0, 1);
+ mute_solo_table.attach (*monitor_section_button, 1, 2, 0, 1);
+ mute_button->show();
+ monitor_section_button->show();
+ } else {
+ mute_solo_table.attach (*mute_button, 0, 2, 0, 1);
+ mute_button->show();
+ }
+ }
+ }
}
/** Called to decide whether the solo isolate / solo lock button visibility should
if (_route && _route->is_master ()) {
return boost::optional<bool> (false);
}
-
+
return boost::optional<bool> ();
}
RadioMenuItem::Group& group, string const & name, MeterPoint point)
{
using namespace Menu_Helpers;
-
+
items.push_back (RadioMenuElem (group, name, sigc::bind (sigc::mem_fun (*this, &MixerStrip::set_meter_point), point)));
RadioMenuItem* i = dynamic_cast<RadioMenuItem *> (&items.back ());
i->set_active (_route->meter_point() == point);
RadioMenuItem::Group& group, string const & name, MeterType type)
{
using namespace Menu_Helpers;
-
+
items.push_back (RadioMenuElem (group, name, sigc::bind (sigc::mem_fun (*this, &MixerStrip::set_meter_type), type)));
RadioMenuItem* i = dynamic_cast<RadioMenuItem *> (&items.back ());
i->set_active (_route->meter_type() == type);
if (_suspend_menu_callbacks) return;
gpm.set_type (t);
}
+
+void
+MixerStrip::vca_menu_toggle (MenuItem* m, uint32_t n)
+{
+ if (!_route) {
+ return;
+ }
+
+ boost::shared_ptr<VCA> vca = _session->vca_manager().vca_by_number (n);
+
+ if (!vca) {
+ return;
+ }
+
+ RadioMenuItem* ri = dynamic_cast<RadioMenuItem*> (m);
+
+ if (!ri) {
+ return;
+ }
+
+ if (!ri->get_active()) {
+ _mixer.do_vca_unassign (vca);
+ return;
+ }
+
+ /* Now invoke a global method to apply this all relevant strips/routes */
+
+ _mixer.do_vca_assign (vca);
+}
+
+void
+MixerStrip::vca_assign (boost::shared_ptr<VCA> vca)
+{
+ if (!vca || !_route) {
+ return;
+ }
+
+ vca->add (_route);
+}
+
+void
+MixerStrip::vca_unassign (boost::shared_ptr<VCA> vca)
+{
+ if (!_route) {
+ return;
+ }
+
+ if (!vca) {
+ /* null VCA means drop all VCA assignments */
+ }
+}
+
+bool
+MixerStrip::vca_button_release (GdkEventButton* ev, uint32_t which)
+{
+ using namespace Gtk::Menu_Helpers;
+
+ if (!_session || !Keyboard::is_context_menu_event (ev)) {
+ return false;
+ }
+
+ if (!_route) {
+ /* no route - nothing to do */
+ return false;
+ }
+
+ VCAList vcas (_session->vca_manager().vcas());
+
+ if (vcas.empty()) {
+ /* XXX should probably show a message saying "No VCA masters" */
+ return true;
+ }
+
+ Menu* menu = new Menu;
+ MenuList& items = menu->items();
+ RadioMenuItem::Group group;
+
+ items.push_back (MenuElem (_("Unassign"), sigc::bind (sigc::mem_fun (_mixer, &Mixer_UI::do_vca_unassign), boost::shared_ptr<VCA>())));
+
+ for (VCAList::iterator v = vcas.begin(); v != vcas.end(); ++v) {
+ items.push_back (RadioMenuElem (group, (*v)->name()));
+ RadioMenuItem* item = dynamic_cast<RadioMenuItem*> (&items.back());
+ if (_route->slaved_to (*v)) {
+ item->set_active (true);
+ }
+ item->signal_activate().connect (sigc::bind (sigc::mem_fun (*this, &MixerStrip::vca_menu_toggle), item, (*v)->number()));
+ }
+
+ menu->popup (1, ev->time);
+
+ return true;
+}