gtk2_ardour/mixer_strip.cc

   1 /*
   2     Copyright (C) 2000-2006 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17 */
  18
  19 #include <cmath>
  20 #include <list>
  21 #include <algorithm>
  22
  23 #include <sigc++/bind.h>
  24
  25 #include "pbd/convert.h"
  26 #include "pbd/enumwriter.h"
  27 #include "pbd/replace_all.h"
  28 #include "pbd/stacktrace.h"
  29
  30 #include <gtkmm2ext/gtk_ui.h>
  31 #include <gtkmm2ext/utils.h>
  32 #include <gtkmm2ext/choice.h>
  33 #include <gtkmm2ext/doi.h>
  34 #include <gtkmm2ext/slider_controller.h>
  35 #include <gtkmm2ext/bindable_button.h>
  36
  37 #include "ardour/audio_track.h"
  38 #include "ardour/audioengine.h"
  39 #include "ardour/internal_send.h"
  40 #include "ardour/meter.h"
  41 #include "ardour/midi_track.h"
  42 #include "ardour/pannable.h"
  43 #include "ardour/panner.h"
  44 #include "ardour/panner_shell.h"
  45 #include "ardour/panner_manager.h"
  46 #include "ardour/port.h"
  47 #include "ardour/profile.h"
  48 #include "ardour/route.h"
  49 #include "ardour/route_group.h"
  50 #include "ardour/send.h"
  51 #include "ardour/session.h"
  52 #include "ardour/types.h"
  53 #include "ardour/user_bundle.h"
  54
  55 #include "ardour_ui.h"
  56 #include "ardour_window.h"
  57 #include "mixer_strip.h"
  58 #include "mixer_ui.h"
  59 #include "keyboard.h"
  60 #include "ardour_button.h"
  61 #include "public_editor.h"
  62 #include "send_ui.h"
  63 #include "io_selector.h"
  64 #include "utils.h"
  65 #include "gui_thread.h"
  66 #include "route_group_menu.h"
  67 #include "meter_patterns.h"
  68
  69 #include "i18n.h"
  70
  71 using namespace ARDOUR;
  72 using namespace ARDOUR_UI_UTILS;
  73 using namespace PBD;
  74 using namespace Gtk;
  75 using namespace Gtkmm2ext;
  76 using namespace std;
  77 using namespace ArdourMeter;
  78
  79 MixerStrip* MixerStrip::_entered_mixer_strip;
  80
  81 PBD::Signal1<void,MixerStrip*> MixerStrip::CatchDeletion;
  82
  83 MixerStrip::MixerStrip (Mixer_UI& mx, Session* sess, bool in_mixer)
  84         : AxisView(sess)
  85         , RouteUI (sess)
  86         , _mixer(mx)
  87         , _mixer_owned (in_mixer)
  88         , processor_box (sess, boost::bind (&MixerStrip::plugin_selector, this), mx.selection(), this, in_mixer)
  89         , gpm (sess, 250)
  90         , panners (sess)
  91         , button_size_group (Gtk::SizeGroup::create (Gtk::SIZE_GROUP_HORIZONTAL))
  92         , button_table (3, 1)
  93         , rec_mon_table (2, 2)
  94         , solo_iso_table (1, 2)
  95         , mute_solo_table (1, 2)
  96         , bottom_button_table (1, 3)
  97         , meter_point_button (_("pre"))
  98         , midi_input_enable_button (0)
  99         , _comment_button (_("Comments"))
 100         , _visibility (X_("mixer-element-visibility"))
 101 {
 102         init ();
 103
 104         if (!_mixer_owned) {
 105                 /* the editor mixer strip: don't destroy it every time
 106                    the underlying route goes away.
 107                 */
 108
 109                 self_destruct = false;
 110         }
 111 }
 112
 113 MixerStrip::MixerStrip (Mixer_UI& mx, Session* sess, boost::shared_ptr<Route> rt, bool in_mixer)
 114         : AxisView(sess)
 115         , RouteUI (sess)
 116         , _mixer(mx)
 117         , _mixer_owned (in_mixer)
 118         , processor_box (sess, boost::bind (&MixerStrip::plugin_selector, this), mx.selection(), this, in_mixer)
 119         , gpm (sess, 250)
 120         , panners (sess)
 121         , button_size_group (Gtk::SizeGroup::create (Gtk::SIZE_GROUP_HORIZONTAL))
 122         , button_table (3, 1)
 123         , rec_mon_table (2, 2)
 124         , solo_iso_table (1, 2)
 125         , mute_solo_table (1, 2)
 126         , bottom_button_table (1, 3)
 127         , meter_point_button (_("pre"))
 128         , midi_input_enable_button (0)
 129         , _comment_button (_("Comments"))
 130         , _visibility (X_("mixer-element-visibility"))
 131 {
 132         init ();
 133         set_route (rt);
 134 }
 135
 136 void
 137 MixerStrip::init ()
 138 {
 139         int button_table_row = 0;
 140
 141         _entered_mixer_strip= 0;
 142         input_selector = 0;
 143         output_selector = 0;
 144         group_menu = 0;
 145         route_ops_menu = 0;
 146         ignore_comment_edit = false;
 147         ignore_toggle = false;
 148         comment_area = 0;
 149         _width_owner = 0;
 150         spacer = 0;
 151
 152         /* the length of this string determines the width of the mixer strip when it is set to `wide' */
 153         longest_label = "longest label";
 154
 155         string t = _("Click to toggle the width of this mixer strip.");
 156         if (_mixer_owned) {
 157                 t += string_compose (_("\n%1-%2-click to toggle the width of all strips."), Keyboard::primary_modifier_name(), Keyboard::tertiary_modifier_name ());
 158         }
 159
 160         width_button.set_image (::get_icon("strip_width"));
 161         ARDOUR_UI::instance()->set_tip (width_button, t);
 162
 163         hide_button.set_image(::get_icon("hide"));
 164         ARDOUR_UI::instance()->set_tip (&hide_button, _("Hide this mixer strip"));
 165
 166         input_button.set_text (_("Input"));
 167         input_button.set_name ("mixer strip button");
 168         input_button.set_size_request (-1, 20);
 169         input_button_box.pack_start (input_button, true, true);
 170
 171         output_button.set_text (_("Output"));
 172         output_button.set_name ("mixer strip button");
 173         Gtkmm2ext::set_size_request_to_display_given_text (output_button, longest_label.c_str(), 4, 4);
 174
 175         ARDOUR_UI::instance()->set_tip (&meter_point_button, _("Click to select metering point"), "");
 176         meter_point_button.set_name ("mixer strip button");
 177
 178         /* TRANSLATORS: this string should be longest of the strings
 179            used to describe meter points. In english, it's "input".
 180         */
 181         set_size_request_to_display_given_text (meter_point_button, _("tupni"), 5, 5);
 182
 183         bottom_button_table.attach (meter_point_button, 2, 3, 0, 1);
 184
 185         meter_point_button.signal_button_press_event().connect (sigc::mem_fun (gpm, &GainMeter::meter_press), false);
 186         meter_point_button.signal_button_release_event().connect (sigc::mem_fun (gpm, &GainMeter::meter_release), false);
 187
 188         hide_button.set_events (hide_button.get_events() & ~(Gdk::ENTER_NOTIFY_MASK|Gdk::LEAVE_NOTIFY_MASK));
 189
 190         monitor_input_button->set_diameter (3);
 191         monitor_disk_button->set_diameter (3);
 192
 193         solo_isolated_led = manage (new ArdourButton (ArdourButton::led_default_elements));
 194         solo_isolated_led->show ();
 195         solo_isolated_led->set_diameter (3);
 196         solo_isolated_led->set_no_show_all (true);
 197         solo_isolated_led->set_name (X_("solo isolate"));
 198         solo_isolated_led->add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
 199         solo_isolated_led->signal_button_release_event().connect (sigc::mem_fun (*this, &RouteUI::solo_isolate_button_release));
 200         UI::instance()->set_tip (solo_isolated_led, _("Isolate Solo"), "");
 201
 202         solo_safe_led = manage (new ArdourButton (ArdourButton::led_default_elements));
 203         solo_safe_led->show ();
 204         solo_safe_led->set_diameter (3);
 205         solo_safe_led->set_no_show_all (true);
 206         solo_safe_led->set_name (X_("solo safe"));
 207         solo_safe_led->add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
 208         solo_safe_led->signal_button_release_event().connect (sigc::mem_fun (*this, &RouteUI::solo_safe_button_release));
 209         UI::instance()->set_tip (solo_safe_led, _("Lock Solo Status"), "");
 210
 211         solo_safe_led->set_text (_("lock"));
 212         solo_isolated_led->set_text (_("iso"));
 213
 214         solo_iso_table.set_homogeneous (true);
 215         solo_iso_table.set_spacings (2);
 216         if (!ARDOUR::Profile->get_trx()) {
 217                 solo_iso_table.attach (*solo_isolated_led, 0, 1, 0, 1);
 218                 solo_iso_table.attach (*solo_safe_led, 1, 2, 0, 1);
 219         }
 220         solo_iso_table.show ();
 221
 222         rec_mon_table.set_homogeneous (true);
 223         rec_mon_table.set_row_spacings (2);
 224         rec_mon_table.set_col_spacings (2);
 225         if (ARDOUR::Profile->get_mixbus()) {
 226                 rec_mon_table.resize (1, 3);
 227                 rec_mon_table.attach (*monitor_input_button, 1, 2, 0, 1);
 228                 rec_mon_table.attach (*monitor_disk_button, 2, 3, 0, 1);
 229         } else if (!ARDOUR::Profile->get_trx()) {
 230                 rec_mon_table.attach (*monitor_input_button, 1, 2, 0, 1);
 231                 rec_mon_table.attach (*monitor_disk_button, 1, 2, 1, 2);
 232         }
 233         rec_mon_table.show ();
 234
 235         button_table.set_homogeneous (false);
 236         button_table.set_spacings (2);
 237
 238         if (solo_isolated_led) {
 239                 button_size_group->add_widget (*solo_isolated_led);
 240         }
 241         if (solo_safe_led) {
 242                 button_size_group->add_widget (*solo_safe_led);
 243         }
 244
 245         if (!ARDOUR::Profile->get_mixbus()) {
 246                 if (rec_enable_button) {
 247                         button_size_group->add_widget (*rec_enable_button);
 248                 }
 249                 if (monitor_disk_button) {
 250                         button_size_group->add_widget (*monitor_disk_button);
 251                 }
 252                 if (monitor_input_button) {
 253                         button_size_group->add_widget (*monitor_input_button);
 254                 }
 255         }
 256
 257         if (!ARDOUR::Profile->get_trx()) {
 258                 button_table.attach (name_button, 0, 1, button_table_row, button_table_row+1);
 259                 button_table_row++;
 260                 button_table.attach (input_button_box, 0, 2, button_table_row, button_table_row+1);
 261                 button_table_row++;
 262                 button_table.attach (_invert_button_box, 0, 2, button_table_row, button_table_row+1);
 263                 button_table_row++;
 264         }
 265
 266         mute_solo_table.set_homogeneous (true);
 267         mute_solo_table.set_spacings (2);
 268
 269         bottom_button_table.set_spacings (2);
 270         bottom_button_table.set_homogeneous (true);
 271         bottom_button_table.attach (group_button, 1, 2, 0, 1);
 272         bottom_button_table.attach (gpm.gain_automation_state_button, 0, 1, 0, 1);
 273
 274         name_button.set_name ("mixer strip button");
 275         name_button.set_text (" "); /* non empty text, forces creation of the layout */
 276         name_button.set_text (""); /* back to empty */
 277         name_button.layout()->set_ellipsize (Pango::ELLIPSIZE_END);
 278         name_button.signal_size_allocate().connect (sigc::mem_fun (*this, &MixerStrip::name_button_resized));
 279         Gtkmm2ext::set_size_request_to_display_given_text (name_button, longest_label.c_str(), 2, 2);
 280         name_button.set_size_request (-1, 20);
 281
 282         ARDOUR_UI::instance()->set_tip (&group_button, _("Mix group"), "");
 283         group_button.set_name ("mixer strip button");
 284         Gtkmm2ext::set_size_request_to_display_given_text (group_button, "Grp", 2, 2);
 285
 286         _comment_button.set_name (X_("mixer strip button"));
 287         _comment_button.signal_clicked.connect (sigc::mem_fun (*this, &RouteUI::toggle_comment_editor));
 288
 289         global_vpacker.set_border_width (0);
 290         global_vpacker.set_spacing (0);
 291
 292         width_button.set_name ("mixer strip button");
 293         hide_button.set_name ("mixer strip button");
 294
 295         width_button.signal_button_press_event().connect (sigc::mem_fun(*this, &MixerStrip::width_button_pressed), false);
 296         hide_button.signal_clicked.connect (sigc::mem_fun(*this, &MixerStrip::hide_clicked));
 297
 298         width_hide_box.set_border_width (2);
 299         width_hide_box.set_spacing (2);
 300         width_hide_box.pack_start (width_button, false, true);
 301         width_hide_box.pack_start (number_label, true, true);
 302         width_hide_box.pack_end (hide_button, false, true);
 303
 304         number_label.set_text ("-");
 305         number_label.set_no_show_all ();
 306         number_label.set_name ("tracknumber label");
 307         number_label.set_fixed_colors (0x80808080, 0x80808080);
 308         number_label.set_alignment (.5, .5);
 309
 310         global_vpacker.set_spacing (2);
 311         if (!ARDOUR::Profile->get_trx()) {
 312                 global_vpacker.pack_start (width_hide_box, Gtk::PACK_SHRINK);
 313                 global_vpacker.pack_start (button_table, Gtk::PACK_SHRINK);
 314                 global_vpacker.pack_start (processor_box, true, true);
 315         }
 316         global_vpacker.pack_start (panners, Gtk::PACK_SHRINK);
 317         global_vpacker.pack_start (rec_mon_table, Gtk::PACK_SHRINK);
 318         global_vpacker.pack_start (solo_iso_table, Gtk::PACK_SHRINK);
 319         global_vpacker.pack_start (mute_solo_table, Gtk::PACK_SHRINK);
 320         global_vpacker.pack_start (gpm, Gtk::PACK_SHRINK);
 321         global_vpacker.pack_start (bottom_button_table, Gtk::PACK_SHRINK);
 322         if (!ARDOUR::Profile->get_trx()) {
 323                 global_vpacker.pack_start (output_button, Gtk::PACK_SHRINK);
 324                 global_vpacker.pack_start (_comment_button, Gtk::PACK_SHRINK);
 325         } else {
 326                 global_vpacker.pack_start (name_button, Gtk::PACK_SHRINK);
 327         }
 328
 329         global_frame.add (global_vpacker);
 330         global_frame.set_shadow_type (Gtk::SHADOW_IN);
 331         global_frame.set_name ("BaseFrame");
 332
 333         add (global_frame);
 334
 335         /* force setting of visible selected status */
 336
 337         _selected = true;
 338         set_selected (false);
 339
 340         _packed = false;
 341         _embedded = false;
 342
 343         _session->engine().Stopped.connect (*this, invalidator (*this), boost::bind (&MixerStrip::engine_stopped, this), gui_context());
 344         _session->engine().Running.connect (*this, invalidator (*this), boost::bind (&MixerStrip::engine_running, this), gui_context());
 345
 346         input_button.signal_button_press_event().connect (sigc::mem_fun(*this, &MixerStrip::input_press), false);
 347         output_button.signal_button_press_event().connect (sigc::mem_fun(*this, &MixerStrip::output_press), false);
 348
 349         /* ditto for this button and busses */
 350
 351         number_label.signal_button_press_event().connect (sigc::mem_fun(*this, &MixerStrip::number_button_button_press), false);
 352         name_button.signal_button_press_event().connect (sigc::mem_fun(*this, &MixerStrip::name_button_button_press), false);
 353         group_button.signal_button_press_event().connect (sigc::mem_fun(*this, &MixerStrip::select_route_group), false);
 354
 355         _width = (Width) -1;
 356
 357         /* start off as a passthru strip. we'll correct this, if necessary,
 358            in update_diskstream_display().
 359         */
 360
 361         /* start off as a passthru strip. we'll correct this, if necessary,
 362            in update_diskstream_display().
 363         */
 364
 365         if (is_midi_track()) {
 366                 set_name ("MidiTrackStripBase");
 367         } else {
 368                 set_name ("AudioTrackStripBase");
 369         }
 370
 371         add_events (Gdk::BUTTON_RELEASE_MASK|
 372                     Gdk::ENTER_NOTIFY_MASK|
 373                     Gdk::LEAVE_NOTIFY_MASK|
 374                     Gdk::KEY_PRESS_MASK|
 375                     Gdk::KEY_RELEASE_MASK);
 376
 377         set_flags (get_flags() | Gtk::CAN_FOCUS);
 378
 379         AudioEngine::instance()->PortConnectedOrDisconnected.connect (
 380                 *this, invalidator (*this), boost::bind (&MixerStrip::port_connected_or_disconnected, this, _1, _3), gui_context ()
 381                 );
 382
 383         /* Add the widgets under visibility control to the VisibilityGroup; the names used here
 384            must be the same as those used in RCOptionEditor so that the configuration changes
 385            are recognised when they occur.
 386         */
 387         _visibility.add (&input_button_box, X_("Input"), _("Input"), false);
 388         _visibility.add (&_invert_button_box, X_("PhaseInvert"), _("Phase Invert"), false);
 389         _visibility.add (&rec_mon_table, X_("RecMon"), _("Record & Monitor"), false);
 390         _visibility.add (&solo_iso_table, X_("SoloIsoLock"), _("Solo Iso / Lock"), false);
 391         _visibility.add (&output_button, X_("Output"), _("Output"), false);
 392         _visibility.add (&_comment_button, X_("Comments"), _("Comments"), false);
 393
 394         parameter_changed (X_("mixer-element-visibility"));
 395
 396         Config->ParameterChanged.connect (_config_connection, MISSING_INVALIDATOR, boost::bind (&MixerStrip::parameter_changed, this, _1), gui_context());
 397         _session->config.ParameterChanged.connect (_config_connection, MISSING_INVALIDATOR, boost::bind (&MixerStrip::parameter_changed, this, _1), gui_context());
 398
 399         //watch for mouse enter/exit so we can do some stuff
 400         signal_enter_notify_event().connect (sigc::mem_fun(*this, &MixerStrip::mixer_strip_enter_event ));
 401         signal_leave_notify_event().connect (sigc::mem_fun(*this, &MixerStrip::mixer_strip_leave_event ));
 402
 403         gpm.LevelMeterButtonPress.connect_same_thread (_level_meter_connection, boost::bind (&MixerStrip::level_meter_button_press, this, _1));
 404 }
 405
 406 MixerStrip::~MixerStrip ()
 407 {
 408         CatchDeletion (this);
 409
 410         if (this ==_entered_mixer_strip)
 411                 _entered_mixer_strip = NULL;
 412
 413         delete input_selector;
 414         delete output_selector;
 415 }
 416
 417 bool
 418 MixerStrip::mixer_strip_enter_event (GdkEventCrossing *ev)
 419 {
 420         _entered_mixer_strip = this;
 421
 422         //although we are triggering on the "enter", to the user it will appear that it is happenin on the "leave"
 423         //because the mixerstrip control is a parent that encompasses the strip
 424         ARDOUR_UI::instance()->the_mixer()->deselect_all_strip_processors();
 425
 426         return false;
 427 }
 428
 429 bool
 430 MixerStrip::mixer_strip_leave_event (GdkEventCrossing *ev)
 431 {
 432         //if we have moved outside our strip, but not into a child view, then deselect ourselves
 433         if ( !(ev->detail == GDK_NOTIFY_INFERIOR) ) {
 434                 _entered_mixer_strip= 0;
 435
 436                 //clear keyboard focus in the gain display.  this is cheesy but fixes a longstanding bug.
 437                 gpm.gain_display.set_sensitive(false);
 438                 gpm.gain_display.set_sensitive(true);
 439
 440                 //if we leave this mixer strip we need to clear out any selections
 441                 //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
 442         }
 443
 444         return false;
 445 }
 446
 447 void
 448 MixerStrip::set_route (boost::shared_ptr<Route> rt)
 449 {
 450         //the rec/monitor stuff only shows up for tracks.
 451         //the show_sends only shows up for buses.
 452         //remove them all here, and we may add them back later
 453         if (show_sends_button->get_parent()) {
 454                 rec_mon_table.remove (*show_sends_button);
 455         }
 456         if (rec_enable_button->get_parent()) {
 457                 rec_mon_table.remove (*rec_enable_button);
 458         }
 459         if (monitor_input_button->get_parent()) {
 460                 rec_mon_table.remove (*monitor_input_button);
 461         }
 462         if (monitor_disk_button->get_parent()) {
 463                 rec_mon_table.remove (*monitor_disk_button);
 464         }
 465         if (group_button.get_parent()) {
 466                 bottom_button_table.remove (group_button);
 467         }
 468
 469         RouteUI::set_route (rt);
 470
 471         /* ProcessorBox needs access to _route so that it can read
 472            GUI object state.
 473         */
 474         processor_box.set_route (rt);
 475
 476         /* map the current state */
 477
 478         mute_changed (0);
 479         update_solo_display ();
 480
 481         delete input_selector;
 482         input_selector = 0;
 483
 484         delete output_selector;
 485         output_selector = 0;
 486
 487         revert_to_default_display ();
 488
 489         /* unpack these from the parent and stuff them into our own
 490            table
 491         */
 492
 493         if (gpm.peak_display.get_parent()) {
 494                 gpm.peak_display.get_parent()->remove (gpm.peak_display);
 495         }
 496         if (gpm.gain_display.get_parent()) {
 497                 gpm.gain_display.get_parent()->remove (gpm.gain_display);
 498         }
 499
 500         gpm.set_type (rt->meter_type());
 501
 502         mute_solo_table.attach (gpm.gain_display,0,1,1,2, EXPAND|FILL, EXPAND);
 503         mute_solo_table.attach (gpm.peak_display,1,2,1,2);
 504
 505         if (solo_button->get_parent()) {
 506                 mute_solo_table.remove (*solo_button);
 507         }
 508
 509         if (mute_button->get_parent()) {
 510                 mute_solo_table.remove (*mute_button);
 511         }
 512
 513         if (route()->is_master()) {
 514                 mute_solo_table.attach (*mute_button, 0, 2, 0, 1);
 515                 solo_button->hide ();
 516                 mute_button->show ();
 517                 rec_mon_table.hide ();
 518         } else {
 519                 bottom_button_table.attach (group_button, 1, 2, 0, 1);
 520                 mute_solo_table.attach (*mute_button, 0, 1, 0, 1);
 521                 mute_solo_table.attach (*solo_button, 1, 2, 0, 1);
 522                 mute_button->show ();
 523                 solo_button->show ();
 524                 rec_mon_table.show ();
 525         }
 526
 527         if (_mixer_owned && route()->is_master() ) {
 528
 529                 HScrollbar scrollbar;
 530                 Gtk::Requisition requisition(scrollbar.size_request ());
 531                 int scrollbar_height = requisition.height;
 532
 533                 spacer = manage (new EventBox);
 534                 spacer->set_size_request (-1, scrollbar_height+2);
 535                 global_vpacker.pack_start (*spacer, false, false);
 536                 spacer->show();
 537         }
 538
 539         if (is_track()) {
 540                 monitor_input_button->show ();
 541                 monitor_disk_button->show ();
 542         } else {
 543                 monitor_input_button->hide();
 544                 monitor_disk_button->hide ();
 545         }
 546
 547         if (is_midi_track()) {
 548                 if (midi_input_enable_button == 0) {
 549                         midi_input_enable_button = manage (new ArdourButton);
 550                         midi_input_enable_button->set_name ("midi input button");
 551                         midi_input_enable_button->set_image (::get_icon (X_("midi_socket_small")));
 552                         midi_input_enable_button->signal_button_press_event().connect (sigc::mem_fun (*this, &MixerStrip::input_active_button_press), false);
 553                         midi_input_enable_button->signal_button_release_event().connect (sigc::mem_fun (*this, &MixerStrip::input_active_button_release), false);
 554                         ARDOUR_UI::instance()->set_tip (midi_input_enable_button, _("Enable/Disable MIDI input"));
 555                 } else {
 556                         input_button_box.remove (*midi_input_enable_button);
 557                 }
 558                 /* get current state */
 559                 midi_input_status_changed ();
 560                 input_button_box.pack_start (*midi_input_enable_button, false, false);
 561                 /* follow changes */
 562                 midi_track()->InputActiveChanged.connect (route_connections, invalidator (*this), boost::bind (&MixerStrip::midi_input_status_changed, this), gui_context());
 563         } else {
 564                 if (midi_input_enable_button) {
 565                         /* removal from the container will delete it */
 566                         input_button_box.remove (*midi_input_enable_button);
 567                         midi_input_enable_button = 0;
 568                 }
 569         }
 570
 571         if (is_audio_track()) {
 572                 boost::shared_ptr<AudioTrack> at = audio_track();
 573                 at->FreezeChange.connect (route_connections, invalidator (*this), boost::bind (&MixerStrip::map_frozen, this), gui_context());
 574         }
 575
 576         if (is_track ()) {
 577
 578                 rec_mon_table.attach (*rec_enable_button, 0, 1, 0, ARDOUR::Profile->get_mixbus() ? 1 : 2);
 579                 rec_enable_button->set_sensitive (_session->writable());
 580                 rec_enable_button->show();
 581
 582                 if (ARDOUR::Profile->get_mixbus()) {
 583                         rec_mon_table.attach (*monitor_input_button, 1, 2, 0, 1);
 584                         rec_mon_table.attach (*monitor_disk_button, 2, 3, 0, 1);
 585                 } else if (ARDOUR::Profile->get_trx()) {
 586                         rec_mon_table.attach (*monitor_input_button, 1, 2, 0, 2);
 587                 } else {
 588                         rec_mon_table.attach (*monitor_input_button, 1, 2, 0, 1);
 589                         rec_mon_table.attach (*monitor_disk_button, 1, 2, 1, 2);
 590                 }
 591
 592         } else {
 593
 594                 /* non-master bus */
 595
 596                 if (!_route->is_master()) {
 597                         rec_mon_table.attach (*show_sends_button, 0, 1, 0, 2);
 598                         show_sends_button->show();
 599                 }
 600         }
 601
 602         meter_point_button.set_text (meter_point_string (_route->meter_point()));
 603
 604         delete route_ops_menu;
 605         route_ops_menu = 0;
 606
 607         _route->meter_change.connect (route_connections, invalidator (*this), bind (&MixerStrip::meter_changed, this), gui_context());
 608         _route->input()->changed.connect (*this, invalidator (*this), boost::bind (&MixerStrip::update_output_display, this), gui_context());
 609         _route->output()->changed.connect (*this, invalidator (*this), boost::bind (&MixerStrip::update_output_display, this), gui_context());
 610         _route->route_group_changed.connect (route_connections, invalidator (*this), boost::bind (&MixerStrip::route_group_changed, this), gui_context());
 611
 612         _route->io_changed.connect (route_connections, invalidator (*this), boost::bind (&MixerStrip::io_changed_proxy, this), gui_context ());
 613
 614         if (_route->panner_shell()) {
 615                 update_panner_choices();
 616                 _route->panner_shell()->Changed.connect (route_connections, invalidator (*this), boost::bind (&MixerStrip::connect_to_pan, this), gui_context());
 617         }
 618
 619         if (is_audio_track()) {
 620                 audio_track()->DiskstreamChanged.connect (route_connections, invalidator (*this), boost::bind (&MixerStrip::diskstream_changed, this), gui_context());
 621         }
 622
 623         _route->comment_changed.connect (route_connections, invalidator (*this), boost::bind (&MixerStrip::setup_comment_button, this), gui_context());
 624         _route->PropertyChanged.connect (route_connections, invalidator (*this), boost::bind (&MixerStrip::property_changed, this, _1), gui_context());
 625
 626         set_stuff_from_route ();
 627
 628         /* now force an update of all the various elements */
 629
 630         mute_changed (0);
 631         update_solo_display ();
 632         name_changed ();
 633         comment_changed (0);
 634         route_group_changed ();
 635
 636         connect_to_pan ();
 637         panners.setup_pan ();
 638
 639         if (has_audio_outputs ()) {
 640                 panners.show_all ();
 641         } else {
 642                 panners.hide_all ();
 643         }
 644
 645         update_diskstream_display ();
 646         update_input_display ();
 647         update_output_display ();
 648
 649         add_events (Gdk::BUTTON_RELEASE_MASK);
 650
 651         processor_box.show ();
 652
 653         if (!route()->is_master() && !route()->is_monitor()) {
 654                 /* we don't allow master or control routes to be hidden */
 655                 hide_button.show();
 656                 number_label.show();
 657         }
 658
 659         gpm.reset_peak_display ();
 660         gpm.gain_display.show ();
 661         gpm.peak_display.show ();
 662
 663         width_button.show();
 664         width_hide_box.show();
 665         global_frame.show();
 666         global_vpacker.show();
 667         button_table.show();
 668         mute_solo_table.show();
 669         bottom_button_table.show();
 670         gpm.show_all ();
 671         meter_point_button.show();
 672         input_button_box.show_all();
 673         output_button.show();
 674         name_button.show();
 675         _comment_button.show();
 676         group_button.show();
 677         gpm.gain_automation_state_button.show();
 678
 679         parameter_changed ("mixer-element-visibility");
 680
 681         show ();
 682 }
 683
 684 void
 685 MixerStrip::set_stuff_from_route ()
 686 {
 687         /* if width is not set, it will be set by the MixerUI or editor */
 688
 689         string str = gui_property ("strip-width");
 690         if (!str.empty()) {
 691                 set_width_enum (Width (string_2_enum (str, _width)), this);
 692         }
 693 }
 694
 695 void
 696 MixerStrip::set_width_enum (Width w, void* owner)
 697 {
 698         /* always set the gpm width again, things may be hidden */
 699
 700         gpm.set_width (w);
 701         panners.set_width (w);
 702
 703         boost::shared_ptr<AutomationList> gain_automation = _route->gain_control()->alist();
 704
 705         _width_owner = owner;
 706
 707         _width = w;
 708
 709         if (_width_owner == this) {
 710                 set_gui_property ("strip-width", enum_2_string (_width));
 711         }
 712
 713         set_button_names ();
 714
 715         switch (w) {
 716         case Wide:
 717
 718                 if (show_sends_button)  {
 719                         show_sends_button->set_text (_("Aux\nSends"));
 720                         show_sends_button->layout()->set_alignment (Pango::ALIGN_CENTER);
 721                 }
 722
 723                 gpm.gain_automation_style_button.set_text (
 724                                 gpm.astyle_string(gain_automation->automation_style()));
 725                 gpm.gain_automation_state_button.set_text (
 726                                 gpm.astate_string(gain_automation->automation_state()));
 727
 728                 if (_route->panner()) {
 729                         ((Gtk::Label*)panners.pan_automation_style_button.get_child())->set_text (
 730                                         panners.astyle_string(_route->panner()->automation_style()));
 731                         ((Gtk::Label*)panners.pan_automation_state_button.get_child())->set_text (
 732                                         panners.astate_string(_route->panner()->automation_state()));
 733                 }
 734
 735
 736                 Gtkmm2ext::set_size_request_to_display_given_text (name_button, longest_label.c_str(), 2, 2);
 737                 set_size_request (-1, -1);
 738                 break;
 739
 740         case Narrow:
 741
 742                 if (show_sends_button) {
 743                         show_sends_button->set_text (_("Snd"));
 744                 }
 745
 746                 gpm.gain_automation_style_button.set_text (
 747                                 gpm.short_astyle_string(gain_automation->automation_style()));
 748                 gpm.gain_automation_state_button.set_text (
 749                                 gpm.short_astate_string(gain_automation->automation_state()));
 750                 gain_meter().setup_meters (); // recalc meter width
 751
 752                 if (_route->panner()) {
 753                         ((Gtk::Label*)panners.pan_automation_style_button.get_child())->set_text (
 754                         panners.short_astyle_string(_route->panner()->automation_style()));
 755                         ((Gtk::Label*)panners.pan_automation_state_button.get_child())->set_text (
 756                         panners.short_astate_string(_route->panner()->automation_state()));
 757                 }
 758
 759                 Gtkmm2ext::set_size_request_to_display_given_text (name_button, "long", 2, 2);
 760                 set_size_request (max (50, gpm.get_gm_width()), -1);
 761                 break;
 762         }
 763
 764         processor_box.set_width (w);
 765
 766         update_input_display ();
 767         update_output_display ();
 768         setup_comment_button ();
 769         route_group_changed ();
 770         name_changed ();
 771         WidthChanged ();
 772 }
 773
 774 void
 775 MixerStrip::set_packed (bool yn)
 776 {
 777         _packed = yn;
 778
 779         if (_packed) {
 780                 set_gui_property ("visible", true);
 781         } else {
 782                 set_gui_property ("visible", false);
 783         }
 784 }
 785
 786
 787 struct RouteCompareByName {
 788         bool operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b) {
 789                 return a->name().compare (b->name()) < 0;
 790         }
 791 };
 792
 793 gint
 794 MixerStrip::output_press (GdkEventButton *ev)
 795 {
 796         using namespace Menu_Helpers;
 797         if (!_session->engine().connected()) {
 798                 MessageDialog msg (_("Not connected to audio engine - no I/O changes are possible"));
 799                 msg.run ();
 800                 return true;
 801         }
 802
 803         MenuList& citems = output_menu.items();
 804         switch (ev->button) {
 805
 806         case 1:
 807                 edit_output_configuration ();
 808                 break;
 809
 810         case 3:
 811         {
 812                 output_menu.set_name ("ArdourContextMenu");
 813                 citems.clear ();
 814                 output_menu_bundles.clear ();
 815
 816                 citems.push_back (MenuElem (_("Disconnect"), sigc::mem_fun (*(static_cast<RouteUI*>(this)), &RouteUI::disconnect_output)));
 817
 818                 for (DataType::iterator i = DataType::begin(); i != DataType::end(); ++i) {
 819                         citems.push_back (
 820                                 MenuElem (
 821                                         string_compose ("Add %1 port", (*i).to_i18n_string()),
 822                                         sigc::bind (sigc::mem_fun (*this, &MixerStrip::add_output_port), *i)
 823                                         )
 824                                 );
 825                 }
 826
 827                 citems.push_back (SeparatorElem());
 828                 uint32_t const n_with_separator = citems.size ();
 829
 830                 ARDOUR::BundleList current = _route->output()->bundles_connected ();
 831
 832                 boost::shared_ptr<ARDOUR::BundleList> b = _session->bundles ();
 833
 834                 /* give user bundles first chance at being in the menu */
 835
 836                 for (ARDOUR::BundleList::iterator i = b->begin(); i != b->end(); ++i) {
 837                         if (boost::dynamic_pointer_cast<UserBundle> (*i)) {
 838                                 maybe_add_bundle_to_output_menu (*i, current);
 839                         }
 840                 }
 841
 842                 for (ARDOUR::BundleList::iterator i = b->begin(); i != b->end(); ++i) {
 843                         if (boost::dynamic_pointer_cast<UserBundle> (*i) == 0) {
 844                                 maybe_add_bundle_to_output_menu (*i, current);
 845                         }
 846                 }
 847
 848                 boost::shared_ptr<ARDOUR::RouteList> routes = _session->get_routes ();
 849                 RouteList copy = *routes;
 850                 copy.sort (RouteCompareByName ());
 851                 for (ARDOUR::RouteList::const_iterator i = copy.begin(); i != copy.end(); ++i) {
 852                         maybe_add_bundle_to_output_menu ((*i)->input()->bundle(), current);
 853                 }
 854
 855                 if (citems.size() == n_with_separator) {
 856                         /* no routes added; remove the separator */
 857                         citems.pop_back ();
 858                 }
 859
 860                 output_menu.popup (1, ev->time);
 861                 break;
 862         }
 863
 864         default:
 865                 break;
 866         }
 867         return TRUE;
 868 }
 869
 870 void
 871 MixerStrip::edit_output_configuration ()
 872 {
 873         if (output_selector == 0) {
 874
 875                 boost::shared_ptr<Send> send;
 876                 boost::shared_ptr<IO> output;
 877
 878                 if ((send = boost::dynamic_pointer_cast<Send>(_current_delivery)) != 0) {
 879                         if (!boost::dynamic_pointer_cast<InternalSend>(send)) {
 880                                 output = send->output();
 881                         } else {
 882                                 output = _route->output ();
 883                         }
 884                 } else {
 885                         output = _route->output ();
 886                 }
 887
 888                 output_selector = new IOSelectorWindow (_session, output);
 889         }
 890
 891         if (output_selector->is_visible()) {
 892                 output_selector->get_toplevel()->get_window()->raise();
 893         } else {
 894                 output_selector->present ();
 895         }
 896
 897         output_selector->set_keep_above (true);
 898 }
 899
 900 void
 901 MixerStrip::edit_input_configuration ()
 902 {
 903         if (input_selector == 0) {
 904                 input_selector = new IOSelectorWindow (_session, _route->input());
 905         }
 906
 907         if (input_selector->is_visible()) {
 908                 input_selector->get_toplevel()->get_window()->raise();
 909         } else {
 910                 input_selector->present ();
 911         }
 912
 913         input_selector->set_keep_above (true);
 914 }
 915
 916 gint
 917 MixerStrip::input_press (GdkEventButton *ev)
 918 {
 919         using namespace Menu_Helpers;
 920
 921         MenuList& citems = input_menu.items();
 922         input_menu.set_name ("ArdourContextMenu");
 923         citems.clear();
 924
 925         if (!_session->engine().connected()) {
 926                 MessageDialog msg (_("Not connected to audio engine - no I/O changes are possible"));
 927                 msg.run ();
 928                 return true;
 929         }
 930
 931         if (_session->actively_recording() && _route->record_enabled())
 932                 return true;
 933
 934         switch (ev->button) {
 935
 936         case 1:
 937                 edit_input_configuration ();
 938                 break;
 939
 940         case 3:
 941         {
 942                 citems.push_back (MenuElem (_("Disconnect"), sigc::mem_fun (*(static_cast<RouteUI*>(this)), &RouteUI::disconnect_input)));
 943
 944                 for (DataType::iterator i = DataType::begin(); i != DataType::end(); ++i) {
 945                         citems.push_back (
 946                                 MenuElem (
 947                                         string_compose ("Add %1 port", (*i).to_i18n_string()),
 948                                         sigc::bind (sigc::mem_fun (*this, &MixerStrip::add_input_port), *i)
 949                                         )
 950                                 );
 951                 }
 952
 953                 citems.push_back (SeparatorElem());
 954                 uint32_t const n_with_separator = citems.size ();
 955
 956                 input_menu_bundles.clear ();
 957
 958                 ARDOUR::BundleList current = _route->input()->bundles_connected ();
 959
 960                 boost::shared_ptr<ARDOUR::BundleList> b = _session->bundles ();
 961
 962                 /* give user bundles first chance at being in the menu */
 963
 964                 for (ARDOUR::BundleList::iterator i = b->begin(); i != b->end(); ++i) {
 965                         if (boost::dynamic_pointer_cast<UserBundle> (*i)) {
 966                                 maybe_add_bundle_to_input_menu (*i, current);
 967                         }
 968                 }
 969
 970                 for (ARDOUR::BundleList::iterator i = b->begin(); i != b->end(); ++i) {
 971                         if (boost::dynamic_pointer_cast<UserBundle> (*i) == 0) {
 972                                 maybe_add_bundle_to_input_menu (*i, current);
 973                         }
 974                 }
 975
 976                 boost::shared_ptr<ARDOUR::RouteList> routes = _session->get_routes ();
 977                 RouteList copy = *routes;
 978                 copy.sort (RouteCompareByName ());
 979                 for (ARDOUR::RouteList::const_iterator i = copy.begin(); i != copy.end(); ++i) {
 980                         maybe_add_bundle_to_input_menu ((*i)->output()->bundle(), current);
 981                 }
 982
 983                 if (citems.size() == n_with_separator) {
 984                         /* no routes added; remove the separator */
 985                         citems.pop_back ();
 986                 }
 987
 988                 input_menu.popup (1, ev->time);
 989                 break;
 990         }
 991         default:
 992                 break;
 993         }
 994         return TRUE;
 995 }
 996
 997 void
 998 MixerStrip::bundle_input_chosen (boost::shared_ptr<ARDOUR::Bundle> c)
 999 {
1000         if (ignore_toggle) {
1001                 return;
1002         }
1003
1004         ARDOUR::BundleList current = _route->input()->bundles_connected ();
1005
1006         if (std::find (current.begin(), current.end(), c) == current.end()) {
1007                 _route->input()->connect_ports_to_bundle (c, true, this);
1008         } else {
1009                 _route->input()->disconnect_ports_from_bundle (c, this);
1010         }
1011 }
1012
1013 void
1014 MixerStrip::bundle_output_chosen (boost::shared_ptr<ARDOUR::Bundle> c)
1015 {
1016         if (ignore_toggle) {
1017                 return;
1018         }
1019
1020         ARDOUR::BundleList current = _route->output()->bundles_connected ();
1021
1022         if (std::find (current.begin(), current.end(), c) == current.end()) {
1023                 _route->output()->connect_ports_to_bundle (c, true, this);
1024         } else {
1025                 _route->output()->disconnect_ports_from_bundle (c, this);
1026         }
1027 }
1028
1029 void
1030 MixerStrip::maybe_add_bundle_to_input_menu (boost::shared_ptr<Bundle> b, ARDOUR::BundleList const& /*current*/)
1031 {
1032         using namespace Menu_Helpers;
1033
1034         if (b->ports_are_outputs() == false || b->nchannels() != _route->n_inputs() || *b == *_route->output()->bundle()) {
1035                 return;
1036         }
1037
1038         list<boost::shared_ptr<Bundle> >::iterator i = input_menu_bundles.begin ();
1039         while (i != input_menu_bundles.end() && b->has_same_ports (*i) == false) {
1040                 ++i;
1041         }
1042
1043         if (i != input_menu_bundles.end()) {
1044                 return;
1045         }
1046
1047         input_menu_bundles.push_back (b);
1048
1049         MenuList& citems = input_menu.items();
1050
1051         std::string n = b->name ();
1052         replace_all (n, "_", " ");
1053
1054         citems.push_back (MenuElem (n, sigc::bind (sigc::mem_fun(*this, &MixerStrip::bundle_input_chosen), b)));
1055 }
1056
1057 void
1058 MixerStrip::maybe_add_bundle_to_output_menu (boost::shared_ptr<Bundle> b, ARDOUR::BundleList const& /*current*/)
1059 {
1060         using namespace Menu_Helpers;
1061
1062         if (b->ports_are_inputs() == false || b->nchannels() != _route->n_outputs() || *b == *_route->input()->bundle()) {
1063                 return;
1064         }
1065
1066         list<boost::shared_ptr<Bundle> >::iterator i = output_menu_bundles.begin ();
1067         while (i != output_menu_bundles.end() && b->has_same_ports (*i) == false) {
1068                 ++i;
1069         }
1070
1071         if (i != output_menu_bundles.end()) {
1072                 return;
1073         }
1074
1075         output_menu_bundles.push_back (b);
1076
1077         MenuList& citems = output_menu.items();
1078
1079         std::string n = b->name ();
1080         replace_all (n, "_", " ");
1081
1082         citems.push_back (MenuElem (n, sigc::bind (sigc::mem_fun(*this, &MixerStrip::bundle_output_chosen), b)));
1083 }
1084
1085 void
1086 MixerStrip::update_diskstream_display ()
1087 {
1088         if (is_track() && input_selector) {
1089                         input_selector->hide_all ();
1090         }
1091
1092         route_color_changed ();
1093 }
1094
1095 void
1096 MixerStrip::connect_to_pan ()
1097 {
1098         ENSURE_GUI_THREAD (*this, &MixerStrip::connect_to_pan)
1099
1100         panstate_connection.disconnect ();
1101         panstyle_connection.disconnect ();
1102
1103         if (!_route->panner()) {
1104                 return;
1105         }
1106
1107         boost::shared_ptr<Pannable> p = _route->pannable ();
1108
1109         p->automation_state_changed.connect (panstate_connection, invalidator (*this), boost::bind (&PannerUI::pan_automation_state_changed, &panners), gui_context());
1110         p->automation_style_changed.connect (panstyle_connection, invalidator (*this), boost::bind (&PannerUI::pan_automation_style_changed, &panners), gui_context());
1111
1112         /* This call reduncant, PannerUI::set_panner() connects to _panshell->Changed itself
1113          * However, that only works a panner was previously set.
1114          *
1115          * PannerUI must remain subscribed to _panshell->Changed() in case
1116          * we switch the panner eg. AUX-Send and back
1117          * _route->panner_shell()->Changed() vs _panshell->Changed
1118          */
1119         if (panners._panner == 0) {
1120                 panners.panshell_changed ();
1121         }
1122         update_panner_choices();
1123 }
1124
1125 void
1126 MixerStrip::update_panner_choices ()
1127 {
1128         ENSURE_GUI_THREAD (*this, &MixerStrip::update_panner_choices)
1129         if (!_route->panner_shell()) { return; }
1130
1131         uint32_t in = _route->output()->n_ports().n_audio();
1132         uint32_t out = in;
1133         if (_route->panner()) {
1134                 in = _route->panner()->in().n_audio();
1135         }
1136
1137         panners.set_available_panners(PannerManager::instance().PannerManager::get_available_panners(in, out));
1138 }
1139
1140 /*
1141  * Output port labelling
1142  * =====================
1143  *
1144  * Case 1: Each output has one connection, all connections are to system:playback_%i
1145  *   out 1 -> system:playback_1
1146  *   out 2 -> system:playback_2
1147  *   out 3 -> system:playback_3
1148  *   Display as: 1/2/3
1149  *
1150  * Case 2: Each output has one connection, all connections are to ardour:track_x/in 1
1151  *   out 1 -> ardour:track_x/in 1
1152  *   out 2 -> ardour:track_x/in 2
1153  *   Display as: track_x
1154  *
1155  * Case 3: Each output has one connection, all connections are to Jack client "program x"
1156  *   out 1 -> program x:foo
1157  *   out 2 -> program x:foo
1158  *   Display as: program x
1159  *
1160  * Case 4: No connections (Disconnected)
1161  *   Display as: -
1162  *
1163  * Default case (unusual routing):
1164  *   Display as: *number of connections*
1165  *
1166  * Tooltips
1167  * ========
1168  * .-----------------------------------------------.
1169  * | Mixdown                                       |
1170  * | out 1 -> ardour:master/in 1, jamin:input/in 1 |
1171  * | out 2 -> ardour:master/in 2, jamin:input/in 2 |
1172  * '-----------------------------------------------'
1173  * .-----------------------------------------------.
1174  * | Guitar SM58                                   |
1175  * | Disconnected                                  |
1176  * '-----------------------------------------------'
1177  */
1178
1179 void
1180 MixerStrip::update_io_button (boost::shared_ptr<ARDOUR::Route> route, Width width, bool for_input)
1181 {
1182         uint32_t io_count;
1183         uint32_t io_index;
1184         boost::shared_ptr<Port> port;
1185         vector<string> port_connections;
1186
1187         uint32_t total_connection_count = 0;
1188         uint32_t io_connection_count = 0;
1189         uint32_t ardour_connection_count = 0;
1190         uint32_t system_connection_count = 0;
1191         uint32_t other_connection_count = 0;
1192
1193         ostringstream label;
1194         string label_string;
1195
1196         bool have_label = false;
1197         bool each_io_has_one_connection = true;
1198
1199         string connection_name;
1200         string ardour_track_name;
1201         string other_connection_type;
1202         string system_ports;
1203         string system_port;
1204
1205         ostringstream tooltip;
1206         char * tooltip_cstr;
1207
1208         if (for_input) {
1209                 io_count = route->n_inputs().n_total();
1210                 tooltip << string_compose (_("<b>INPUT</b> to %1"), Glib::Markup::escape_text(route->name()));
1211         } else {
1212                 io_count = route->n_outputs().n_total();
1213                 tooltip << string_compose (_("<b>OUTPUT</b> from %1"), Glib::Markup::escape_text(route->name()));
1214         }
1215
1216
1217         for (io_index = 0; io_index < io_count; ++io_index) {
1218                 if (for_input) {
1219                         port = route->input()->nth (io_index);
1220                 } else {
1221                         port = route->output()->nth (io_index);
1222                 }
1223
1224                 port_connections.clear ();
1225                 port->get_connections(port_connections);
1226                 io_connection_count = 0;
1227
1228                 if (!port_connections.empty()) {
1229                         for (vector<string>::iterator i = port_connections.begin(); i != port_connections.end(); ++i) {
1230                                 string& connection_name (*i);
1231
1232                                 if (io_connection_count == 0) {
1233                                         tooltip << endl << Glib::Markup::escape_text(port->name().substr(port->name().find("/") + 1)) << " -> " << Glib::Markup::escape_text(connection_name);
1234                                 } else {
1235                                         tooltip << ", " << Glib::Markup::escape_text(connection_name);
1236                                 }
1237
1238                                 if (connection_name.find("ardour:") == 0) {
1239                                         if (ardour_track_name.empty()) {
1240                                                 // "ardour:Master/in 1" -> "ardour:Master/"
1241                                                 string::size_type slash = connection_name.find("/");
1242                                                 if (slash != string::npos) {
1243                                                         ardour_track_name = connection_name.substr(0, slash + 1);
1244                                                 }
1245                                         }
1246
1247                                         if (connection_name.find(ardour_track_name) == 0) {
1248                                                 ++ardour_connection_count;
1249                                         }
1250                                 } else if (connection_name.find("system:") == 0) {
1251                                         if (for_input) {
1252                                                 // "system:capture_123" -> "123"
1253                                                 system_port = connection_name.substr(15);
1254                                         } else {
1255                                                 // "system:playback_123" -> "123"
1256                                                 system_port = connection_name.substr(16);
1257                                         }
1258
1259                                         if (system_ports.empty()) {
1260                                                 system_ports += system_port;
1261                                         } else {
1262                                                 system_ports += "/" + system_port;
1263                                         }
1264
1265                                         ++system_connection_count;
1266                                 } else {
1267                                         if (other_connection_type.empty()) {
1268                                                 // "jamin:in 1" -> "jamin:"
1269                                                 other_connection_type = connection_name.substr(0, connection_name.find(":") + 1);
1270                                         }
1271
1272                                         if (connection_name.find(other_connection_type) == 0) {
1273                                                 ++other_connection_count;
1274                                         }
1275                                 }
1276
1277                                 ++total_connection_count;
1278                                 ++io_connection_count;
1279                         }
1280                 }
1281
1282                 if (io_connection_count != 1) {
1283                         each_io_has_one_connection = false;
1284                 }
1285         }
1286
1287         if (total_connection_count == 0) {
1288                 tooltip << endl << _("Disconnected");
1289         }
1290
1291         tooltip_cstr = new char[tooltip.str().size() + 1];
1292         strcpy(tooltip_cstr, tooltip.str().c_str());
1293
1294         if (for_input) {
1295                 ARDOUR_UI::instance()->set_tip (&input_button, tooltip_cstr, "");
1296         } else {
1297                 ARDOUR_UI::instance()->set_tip (&output_button, tooltip_cstr, "");
1298         }
1299
1300         if (each_io_has_one_connection) {
1301                 if (total_connection_count == ardour_connection_count) {
1302                         // all connections are to the same track in ardour
1303                         // "ardour:Master/" -> "Master"
1304                         string::size_type slash = ardour_track_name.find("/");
1305                         if (slash != string::npos) {
1306                                 label << ardour_track_name.substr(7, slash - 7);
1307                                 have_label = true;
1308                         }
1309                 }
1310                 else if (total_connection_count == system_connection_count) {
1311                         // all connections are to system ports
1312                         label << system_ports;
1313                         have_label = true;
1314                 }
1315                 else if (total_connection_count == other_connection_count) {
1316                         // all connections are to the same external program eg jamin
1317                         // "jamin:" -> "jamin"
1318                         label << other_connection_type.substr(0, other_connection_type.size() - 1);
1319                         have_label = true;
1320                 }
1321         }
1322
1323         if (!have_label) {
1324                 if (total_connection_count == 0) {
1325                         // Disconnected
1326                         label << "-";
1327                 } else {
1328                         // Odd configuration
1329                         label << "*" << total_connection_count << "*";
1330                 }
1331         }
1332
1333         switch (width) {
1334         case Wide:
1335                 label_string = label.str().substr(0, 7);
1336                 break;
1337         case Narrow:
1338                 label_string = label.str().substr(0, 3);
1339                 break;
1340         }
1341
1342         if (for_input) {
1343                 input_button.set_text (label_string);
1344         } else {
1345                 output_button.set_text (label_string);
1346         }
1347 }
1348
1349 void
1350 MixerStrip::update_input_display ()
1351 {
1352         update_io_button (_route, _width, true);
1353         panners.setup_pan ();
1354
1355         if (has_audio_outputs ()) {
1356                 panners.show_all ();
1357         } else {
1358                 panners.hide_all ();
1359         }
1360
1361 }
1362
1363 void
1364 MixerStrip::update_output_display ()
1365 {
1366         update_io_button (_route, _width, false);
1367         gpm.setup_meters ();
1368         panners.setup_pan ();
1369
1370         if (has_audio_outputs ()) {
1371                 panners.show_all ();
1372         } else {
1373                 panners.hide_all ();
1374         }
1375 }
1376
1377 void
1378 MixerStrip::fast_update ()
1379 {
1380         gpm.update_meters ();
1381 }
1382
1383 void
1384 MixerStrip::diskstream_changed ()
1385 {
1386         Gtkmm2ext::UI::instance()->call_slot (invalidator (*this), boost::bind (&MixerStrip::update_diskstream_display, this));
1387 }
1388
1389 void
1390 MixerStrip::io_changed_proxy ()
1391 {
1392         Glib::signal_idle().connect_once (sigc::mem_fun (*this, &MixerStrip::update_panner_choices));
1393 }
1394
1395 void
1396 MixerStrip::port_connected_or_disconnected (boost::weak_ptr<Port> wa, boost::weak_ptr<Port> wb)
1397 {
1398         boost::shared_ptr<Port> a = wa.lock ();
1399         boost::shared_ptr<Port> b = wb.lock ();
1400
1401         if ((a && _route->input()->has_port (a)) || (b && _route->input()->has_port (b))) {
1402                 update_input_display ();
1403                 set_width_enum (_width, this);
1404         }
1405
1406         if ((a && _route->output()->has_port (a)) || (b && _route->output()->has_port (b))) {
1407                 update_output_display ();
1408                 set_width_enum (_width, this);
1409         }
1410 }
1411
1412 void
1413 MixerStrip::setup_comment_button ()
1414 {
1415         switch (_width) {
1416
1417         case Wide:
1418                 if (_route->comment().empty ()) {
1419                         _comment_button.unset_bg (STATE_NORMAL);
1420                         _comment_button.set_text (_("Comments"));
1421                 } else {
1422                         _comment_button.modify_bg (STATE_NORMAL, color ());
1423                         _comment_button.set_text (_("*Comments*"));
1424                 }
1425                 break;
1426
1427         case Narrow:
1428                 if (_route->comment().empty ()) {
1429                         _comment_button.unset_bg (STATE_NORMAL);
1430                         _comment_button.set_text (_("Cmt"));
1431                 } else {
1432                         _comment_button.modify_bg (STATE_NORMAL, color ());
1433                         _comment_button.set_text (_("*Cmt*"));
1434                 }
1435                 break;
1436         }
1437
1438         ARDOUR_UI::instance()->set_tip (
1439                 _comment_button, _route->comment().empty() ? _("Click to Add/Edit Comments") : _route->comment()
1440                 );
1441 }
1442
1443 bool
1444 MixerStrip::select_route_group (GdkEventButton *ev)
1445 {
1446         using namespace Menu_Helpers;
1447
1448         if (ev->button == 1) {
1449
1450                 if (group_menu == 0) {
1451
1452                         PropertyList* plist = new PropertyList();
1453
1454                         plist->add (Properties::gain, true);
1455                         plist->add (Properties::mute, true);
1456                         plist->add (Properties::solo, true);
1457
1458                         group_menu = new RouteGroupMenu (_session, plist);
1459                 }
1460
1461                 WeakRouteList r;
1462                 r.push_back (route ());
1463                 group_menu->build (r);
1464                 group_menu->menu()->popup (1, ev->time);
1465         }
1466
1467         return true;
1468 }
1469
1470 void
1471 MixerStrip::route_group_changed ()
1472 {
1473         ENSURE_GUI_THREAD (*this, &MixerStrip::route_group_changed)
1474
1475         RouteGroup *rg = _route->route_group();
1476
1477         if (rg) {
1478                 group_button.set_text (PBD::short_version (rg->name(), 5));
1479         } else {
1480                 switch (_width) {
1481                 case Wide:
1482                         group_button.set_text (_("Grp"));
1483                         break;
1484                 case Narrow:
1485                         group_button.set_text (_("~G"));
1486                         break;
1487                 }
1488         }
1489 }
1490
1491 void
1492 MixerStrip::route_color_changed ()
1493 {
1494         name_button.modify_bg (STATE_NORMAL, color());
1495         number_label.set_fixed_colors (gdk_color_to_rgba (color()), gdk_color_to_rgba (color()));
1496         reset_strip_style ();
1497 }
1498
1499 void
1500 MixerStrip::show_passthru_color ()
1501 {
1502         reset_strip_style ();
1503 }
1504
1505 void
1506 MixerStrip::build_route_ops_menu ()
1507 {
1508         using namespace Menu_Helpers;
1509         route_ops_menu = new Menu;
1510         route_ops_menu->set_name ("ArdourContextMenu");
1511
1512         MenuList& items = route_ops_menu->items();
1513
1514         items.push_back (MenuElem (_("Color..."), sigc::mem_fun (*this, &RouteUI::choose_color)));
1515
1516         items.push_back (MenuElem (_("Comments..."), sigc::mem_fun (*this, &RouteUI::open_comment_editor)));
1517         if (!_route->is_master()) {
1518                 items.push_back (MenuElem (_("Save As Template..."), sigc::mem_fun(*this, &RouteUI::save_as_template)));
1519         }
1520         items.push_back (MenuElem (_("Rename..."), sigc::mem_fun(*this, &RouteUI::route_rename)));
1521         rename_menu_item = &items.back();
1522
1523         items.push_back (SeparatorElem());
1524         items.push_back (CheckMenuElem (_("Active")));
1525         Gtk::CheckMenuItem* i = dynamic_cast<Gtk::CheckMenuItem *> (&items.back());
1526         i->set_active (_route->active());
1527         i->set_sensitive(! _session->transport_rolling());
1528         i->signal_activate().connect (sigc::bind (sigc::mem_fun (*this, &RouteUI::set_route_active), !_route->active(), false));
1529
1530         items.push_back (SeparatorElem());
1531
1532         items.push_back (MenuElem (_("Adjust Latency..."), sigc::mem_fun (*this, &RouteUI::adjust_latency)));
1533
1534         items.push_back (SeparatorElem());
1535         items.push_back (CheckMenuElem (_("Protect Against Denormals"), sigc::mem_fun (*this, &RouteUI::toggle_denormal_protection)));
1536         denormal_menu_item = dynamic_cast<Gtk::CheckMenuItem *> (&items.back());
1537         denormal_menu_item->set_active (_route->denormal_protection());
1538
1539         if (!Profile->get_sae()) {
1540                 items.push_back (SeparatorElem());
1541                 items.push_back (MenuElem (_("Remote Control ID..."), sigc::mem_fun (*this, &RouteUI::open_remote_control_id_dialog)));
1542         }
1543
1544         items.push_back (SeparatorElem());
1545         items.push_back (MenuElem (_("Remove"), sigc::bind (sigc::mem_fun(*this, &RouteUI::remove_this_route), false)));
1546 }
1547
1548 gboolean
1549 MixerStrip::name_button_button_press (GdkEventButton* ev)
1550 {
1551         /* show menu for either button 1 or 3, so as not to confuse people
1552            and also not hide stuff from them.
1553         */
1554
1555         if (ev->button == 3 || ev->button == 1) {
1556                 list_route_operations ();
1557
1558                 /* do not allow rename if the track is record-enabled */
1559                 rename_menu_item->set_sensitive (!_route->record_enabled());
1560                 route_ops_menu->popup (1, ev->time);
1561         }
1562
1563         return false;
1564 }
1565
1566 gboolean
1567 MixerStrip::number_button_button_press (GdkEventButton* ev)
1568 {
1569         if (  ev->button == 3 ) {
1570                 list_route_operations ();
1571
1572                 /* do not allow rename if the track is record-enabled */
1573                 rename_menu_item->set_sensitive (!_route->record_enabled());
1574                 route_ops_menu->popup (1, ev->time);
1575         }
1576
1577         return false;
1578 }
1579
1580 void
1581 MixerStrip::list_route_operations ()
1582 {
1583         delete route_ops_menu;
1584         build_route_ops_menu ();
1585 }
1586
1587 void
1588 MixerStrip::set_selected (bool yn)
1589 {
1590         AxisView::set_selected (yn);
1591         if (_selected) {
1592                 global_frame.set_shadow_type (Gtk::SHADOW_ETCHED_OUT);
1593                 global_frame.set_name ("MixerStripSelectedFrame");
1594         } else {
1595                 global_frame.set_shadow_type (Gtk::SHADOW_IN);
1596                 global_frame.set_name ("MixerStripFrame");
1597         }
1598         global_frame.queue_draw ();
1599
1600 //      if (!yn)
1601 //              processor_box.deselect_all_processors();
1602 }
1603
1604 void
1605 MixerStrip::property_changed (const PropertyChange& what_changed)
1606 {
1607         RouteUI::property_changed (what_changed);
1608
1609         if (what_changed.contains (ARDOUR::Properties::name)) {
1610                 name_changed ();
1611         }
1612 }
1613
1614 void
1615 MixerStrip::name_changed ()
1616 {
1617         switch (_width) {
1618         case Wide:
1619                 if (_session->config.get_track_name_number()) {
1620                         const int64_t track_number = _route->track_number ();
1621                         if (track_number == 0) {
1622                                 number_label.set_text ("-");
1623                         } else {
1624                                 number_label.set_text (PBD::to_string (abs(_route->track_number ()), std::dec));
1625                         }
1626                 } else {
1627                         number_label.set_text ("");
1628                 }
1629                 name_button.set_text (_route->name());
1630                 break;
1631         case Narrow:
1632                 if (_session->config.get_track_name_number()) {
1633                         name_button.set_markup(track_number_to_string (_route->track_number (), " ",
1634                                                 PBD::short_version (_route->name (), 5)));
1635                 } else {
1636                         name_button.set_text (PBD::short_version (_route->name(), 5));
1637                 }
1638                 break;
1639         }
1640
1641         ARDOUR_UI::instance()->set_tip (name_button, _route->name());
1642 }
1643
1644 void
1645 MixerStrip::name_button_resized (Gtk::Allocation& alloc)
1646 {
1647         name_button.layout()->set_width (alloc.get_width() * PANGO_SCALE);
1648 }
1649
1650 bool
1651 MixerStrip::width_button_pressed (GdkEventButton* ev)
1652 {
1653         if (ev->button != 1) {
1654                 return false;
1655         }
1656
1657         if (Keyboard::modifier_state_contains (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier | Keyboard::TertiaryModifier)) && _mixer_owned) {
1658                 switch (_width) {
1659                 case Wide:
1660                         _mixer.set_strip_width (Narrow, true);
1661                         break;
1662
1663                 case Narrow:
1664                         _mixer.set_strip_width (Wide, true);
1665                         break;
1666                 }
1667         } else {
1668                 switch (_width) {
1669                 case Wide:
1670                         set_width_enum (Narrow, this);
1671                         break;
1672                 case Narrow:
1673                         set_width_enum (Wide, this);
1674                         break;
1675                 }
1676         }
1677
1678         return true;
1679 }
1680
1681 void
1682 MixerStrip::hide_clicked ()
1683 {
1684         // LAME fix to reset the button status for when it is redisplayed (part 1)
1685         hide_button.set_sensitive(false);
1686
1687         if (_embedded) {
1688                 Hiding(); /* EMIT_SIGNAL */
1689         } else {
1690                 _mixer.hide_strip (this);
1691         }
1692
1693         // (part 2)
1694         hide_button.set_sensitive(true);
1695 }
1696
1697 void
1698 MixerStrip::set_embedded (bool yn)
1699 {
1700         _embedded = yn;
1701 }
1702
1703 void
1704 MixerStrip::map_frozen ()
1705 {
1706         ENSURE_GUI_THREAD (*this, &MixerStrip::map_frozen)
1707
1708         boost::shared_ptr<AudioTrack> at = audio_track();
1709
1710         if (at) {
1711                 switch (at->freeze_state()) {
1712                 case AudioTrack::Frozen:
1713                         processor_box.set_sensitive (false);
1714                         hide_redirect_editors ();
1715                         break;
1716                 default:
1717                         processor_box.set_sensitive (true);
1718                         // XXX need some way, maybe, to retoggle redirect editors
1719                         break;
1720                 }
1721         }
1722 }
1723
1724 void
1725 MixerStrip::hide_redirect_editors ()
1726 {
1727         _route->foreach_processor (sigc::mem_fun (*this, &MixerStrip::hide_processor_editor));
1728 }
1729
1730 void
1731 MixerStrip::hide_processor_editor (boost::weak_ptr<Processor> p)
1732 {
1733         boost::shared_ptr<Processor> processor (p.lock ());
1734         if (!processor) {
1735                 return;
1736         }
1737
1738         Gtk::Window* w = processor_box.get_processor_ui (processor);
1739
1740         if (w) {
1741                 w->hide ();
1742         }
1743 }
1744
1745 void
1746 MixerStrip::reset_strip_style ()
1747 {
1748         if (_current_delivery && boost::dynamic_pointer_cast<Send>(_current_delivery)) {
1749
1750                 gpm.set_fader_name ("SendStripBase");
1751
1752         } else {
1753
1754                 if (is_midi_track()) {
1755                         if (_route->active()) {
1756                                 set_name ("MidiTrackStripBase");
1757                         } else {
1758                                 set_name ("MidiTrackStripBaseInactive");
1759                         }
1760                         gpm.set_fader_name ("MidiTrackFader");
1761                 } else if (is_audio_track()) {
1762                         if (_route->active()) {
1763                                 set_name ("AudioTrackStripBase");
1764                         } else {
1765                                 set_name ("AudioTrackStripBaseInactive");
1766                         }
1767                         gpm.set_fader_name ("AudioTrackFader");
1768                 } else {
1769                         if (_route->active()) {
1770                                 set_name ("AudioBusStripBase");
1771                         } else {
1772                                 set_name ("AudioBusStripBaseInactive");
1773                         }
1774                         gpm.set_fader_name ("AudioBusFader");
1775
1776                         /* (no MIDI busses yet) */
1777                 }
1778         }
1779 }
1780
1781
1782 void
1783 MixerStrip::engine_stopped ()
1784 {
1785 }
1786
1787 void
1788 MixerStrip::engine_running ()
1789 {
1790 }
1791
1792 string
1793 MixerStrip::meter_point_string (MeterPoint mp)
1794 {
1795         switch (_width) {
1796         case Wide:
1797                 switch (mp) {
1798                 case MeterInput:
1799                         return _("in");
1800                         break;
1801
1802                 case MeterPreFader:
1803                         return _("pre");
1804                         break;
1805
1806                 case MeterPostFader:
1807                         return _("post");
1808                         break;
1809
1810                 case MeterOutput:
1811                         return _("out");
1812                         break;
1813
1814                 case MeterCustom:
1815                 default:
1816                         return _("custom");
1817                         break;
1818                 }
1819                 break;
1820         case Narrow:
1821                 switch (mp) {
1822                 case MeterInput:
1823                         return _("in");
1824                         break;
1825
1826                 case MeterPreFader:
1827                         return _("pr");
1828                         break;
1829
1830                 case MeterPostFader:
1831                         return _("po");
1832                         break;
1833
1834                 case MeterOutput:
1835                         return _("o");
1836                         break;
1837
1838                 case MeterCustom:
1839                 default:
1840                         return _("c");
1841                         break;
1842                 }
1843                 break;
1844         }
1845
1846         return string();
1847 }
1848
1849 /** Called when the metering point has changed */
1850 void
1851 MixerStrip::meter_changed ()
1852 {
1853         meter_point_button.set_text (meter_point_string (_route->meter_point()));
1854         gpm.setup_meters ();
1855         // reset peak when meter point changes
1856         gpm.reset_peak_display();
1857 }
1858
1859 /** The bus that we are displaying sends to has changed, or been turned off.
1860  *  @param send_to New bus that we are displaying sends to, or 0.
1861  */
1862 void
1863 MixerStrip::bus_send_display_changed (boost::shared_ptr<Route> send_to)
1864 {
1865         RouteUI::bus_send_display_changed (send_to);
1866
1867         if (send_to) {
1868                 boost::shared_ptr<Send> send = _route->internal_send_for (send_to);
1869
1870                 if (send) {
1871                         show_send (send);
1872                 } else {
1873                         revert_to_default_display ();
1874                 }
1875         } else {
1876                 revert_to_default_display ();
1877         }
1878 }
1879
1880 void
1881 MixerStrip::drop_send ()
1882 {
1883         boost::shared_ptr<Send> current_send;
1884
1885         if (_current_delivery && ((current_send = boost::dynamic_pointer_cast<Send>(_current_delivery)) != 0)) {
1886                 current_send->set_metering (false);
1887         }
1888
1889         send_gone_connection.disconnect ();
1890         input_button.set_sensitive (true);
1891         output_button.set_sensitive (true);
1892         group_button.set_sensitive (true);
1893         set_invert_sensitive (true);
1894         meter_point_button.set_sensitive (true);
1895         mute_button->set_sensitive (true);
1896         solo_button->set_sensitive (true);
1897         rec_enable_button->set_sensitive (true);
1898         solo_isolated_led->set_sensitive (true);
1899         solo_safe_led->set_sensitive (true);
1900         monitor_input_button->set_sensitive (true);
1901         monitor_disk_button->set_sensitive (true);
1902         _comment_button.set_sensitive (true);
1903 }
1904
1905 void
1906 MixerStrip::set_current_delivery (boost::shared_ptr<Delivery> d)
1907 {
1908         _current_delivery = d;
1909         DeliveryChanged (_current_delivery);
1910 }
1911
1912 void
1913 MixerStrip::show_send (boost::shared_ptr<Send> send)
1914 {
1915         assert (send != 0);
1916
1917         drop_send ();
1918
1919         set_current_delivery (send);
1920
1921         send->meter()->set_type(_route->shared_peak_meter()->get_type());
1922         send->set_metering (true);
1923         _current_delivery->DropReferences.connect (send_gone_connection, invalidator (*this), boost::bind (&MixerStrip::revert_to_default_display, this), gui_context());
1924
1925         gain_meter().set_controls (_route, send->meter(), send->amp());
1926         gain_meter().setup_meters ();
1927
1928         uint32_t const in = _current_delivery->pans_required();
1929         uint32_t const out = _current_delivery->pan_outs();
1930
1931         panner_ui().set_panner (_current_delivery->panner_shell(), _current_delivery->panner());
1932         panner_ui().set_available_panners(PannerManager::instance().PannerManager::get_available_panners(in, out));
1933         panner_ui().setup_pan ();
1934         panner_ui().set_send_drawing_mode (true);
1935         panner_ui().show_all ();
1936
1937         input_button.set_sensitive (false);
1938         group_button.set_sensitive (false);
1939         set_invert_sensitive (false);
1940         meter_point_button.set_sensitive (false);
1941         mute_button->set_sensitive (false);
1942         solo_button->set_sensitive (false);
1943         rec_enable_button->set_sensitive (false);
1944         solo_isolated_led->set_sensitive (false);
1945         solo_safe_led->set_sensitive (false);
1946         monitor_input_button->set_sensitive (false);
1947         monitor_disk_button->set_sensitive (false);
1948         _comment_button.set_sensitive (false);
1949
1950         if (boost::dynamic_pointer_cast<InternalSend>(send)) {
1951                 output_button.set_sensitive (false);
1952         }
1953
1954         reset_strip_style ();
1955 }
1956
1957 void
1958 MixerStrip::revert_to_default_display ()
1959 {
1960         drop_send ();
1961
1962         set_current_delivery (_route->main_outs ());
1963
1964         gain_meter().set_controls (_route, _route->shared_peak_meter(), _route->amp());
1965         gain_meter().setup_meters ();
1966
1967         panner_ui().set_panner (_route->main_outs()->panner_shell(), _route->main_outs()->panner());
1968         update_panner_choices();
1969         panner_ui().setup_pan ();
1970         panner_ui().set_send_drawing_mode (false);
1971
1972         if (has_audio_outputs ()) {
1973                 panners.show_all ();
1974         } else {
1975                 panners.hide_all ();
1976         }
1977
1978         reset_strip_style ();
1979 }
1980
1981 void
1982 MixerStrip::set_button_names ()
1983 {
1984         switch (_width) {
1985         case Wide:
1986                 rec_enable_button->set_text (_("Rec"));
1987                 mute_button->set_text (_("Mute"));
1988                 monitor_input_button->set_text (_("In"));
1989                 monitor_disk_button->set_text (_("Disk"));
1990
1991                 if (_route && _route->solo_safe()) {
1992                         solo_button->set_visual_state (Gtkmm2ext::VisualState (solo_button->visual_state() | Gtkmm2ext::Insensitive));
1993                 } else {
1994                         solo_button->set_visual_state (Gtkmm2ext::VisualState (solo_button->visual_state() & ~Gtkmm2ext::Insensitive));
1995                 }
1996                 if (!Config->get_solo_control_is_listen_control()) {
1997                         solo_button->set_text (_("Solo"));
1998                 } else {
1999                         switch (Config->get_listen_position()) {
2000                         case AfterFaderListen:
2001                                 solo_button->set_text (_("AFL"));
2002                                 break;
2003                         case PreFaderListen:
2004                                 solo_button->set_text (_("PFL"));
2005                                 break;
2006                         }
2007                 }
2008                 solo_isolated_led->set_text (_("iso"));
2009                 solo_safe_led->set_text (_("lock"));
2010                 break;
2011
2012         default:
2013                 rec_enable_button->set_text (_("R"));
2014                 mute_button->set_text (_("M"));
2015                 monitor_input_button->set_text (_("I"));
2016                 monitor_disk_button->set_text (_("D"));
2017
2018                 if (_route && _route->solo_safe()) {
2019                         solo_button->set_visual_state (Gtkmm2ext::VisualState (solo_button->visual_state() | Gtkmm2ext::Insensitive));
2020                 } else {
2021                         solo_button->set_visual_state (Gtkmm2ext::VisualState (solo_button->visual_state() & ~Gtkmm2ext::Insensitive));
2022                 }
2023                 if (!Config->get_solo_control_is_listen_control()) {
2024                         solo_button->set_text (_("S"));
2025                 } else {
2026                         switch (Config->get_listen_position()) {
2027                         case AfterFaderListen:
2028                                 solo_button->set_text (_("A"));
2029                                 break;
2030                         case PreFaderListen:
2031                                 solo_button->set_text (_("P"));
2032                                 break;
2033                         }
2034                 }
2035
2036                 solo_isolated_led->set_text (_("i"));
2037                 solo_safe_led->set_text (_("L"));
2038                 break;
2039         }
2040
2041         if (_route) {
2042                 meter_point_button.set_text (meter_point_string (_route->meter_point()));
2043         } else {
2044                 meter_point_button.set_text ("");
2045         }
2046 }
2047
2048 PluginSelector*
2049 MixerStrip::plugin_selector()
2050 {
2051         return _mixer.plugin_selector();
2052 }
2053
2054 void
2055 MixerStrip::hide_things ()
2056 {
2057         processor_box.hide_things ();
2058 }
2059
2060 bool
2061 MixerStrip::input_active_button_press (GdkEventButton*)
2062 {
2063         /* nothing happens on press */
2064         return true;
2065 }
2066
2067 bool
2068 MixerStrip::input_active_button_release (GdkEventButton* ev)
2069 {
2070         boost::shared_ptr<MidiTrack> mt = midi_track ();
2071
2072         if (!mt) {
2073                 return true;
2074         }
2075
2076         boost::shared_ptr<RouteList> rl (new RouteList);
2077
2078         rl->push_back (route());
2079
2080         _session->set_exclusive_input_active (rl, !mt->input_active(),
2081                                               Keyboard::modifier_state_contains (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::SecondaryModifier)));
2082
2083         return true;
2084 }
2085
2086 void
2087 MixerStrip::midi_input_status_changed ()
2088 {
2089         if (midi_input_enable_button) {
2090                 boost::shared_ptr<MidiTrack> mt = midi_track ();
2091                 assert (mt);
2092                 midi_input_enable_button->set_active (mt->input_active ());
2093         }
2094 }
2095
2096 string
2097 MixerStrip::state_id () const
2098 {
2099         return string_compose ("strip %1", _route->id().to_s());
2100 }
2101
2102 void
2103 MixerStrip::parameter_changed (string p)
2104 {
2105         if (p == _visibility.get_state_name()) {
2106                 /* The user has made changes to the mixer strip visibility, so get
2107                    our VisibilityGroup to reflect these changes in our widgets.
2108                 */
2109                 _visibility.set_state (Config->get_mixer_strip_visibility ());
2110         }
2111         else if (p == "track-name-number") {
2112                 name_changed ();
2113         }
2114 }
2115
2116 /** Called to decide whether the solo isolate / solo lock button visibility should
2117  *  be overridden from that configured by the user.  We do this for the master bus.
2118  *
2119  *  @return optional value that is present if visibility state should be overridden.
2120  */
2121 boost::optional<bool>
2122 MixerStrip::override_solo_visibility () const
2123 {
2124         if (_route && _route->is_master ()) {
2125                 return boost::optional<bool> (false);
2126         }
2127
2128         return boost::optional<bool> ();
2129 }
2130
2131 void
2132 MixerStrip::add_input_port (DataType t)
2133 {
2134         _route->input()->add_port ("", this, t);
2135 }
2136
2137 void
2138 MixerStrip::add_output_port (DataType t)
2139 {
2140         _route->output()->add_port ("", this, t);
2141 }
2142
2143 void
2144 MixerStrip::route_active_changed ()
2145 {
2146         reset_strip_style ();
2147 }
2148
2149 void
2150 MixerStrip::copy_processors ()
2151 {
2152         processor_box.processor_operation (ProcessorBox::ProcessorsCopy);
2153 }
2154
2155 void
2156 MixerStrip::cut_processors ()
2157 {
2158         processor_box.processor_operation (ProcessorBox::ProcessorsCut);
2159 }
2160
2161 void
2162 MixerStrip::paste_processors ()
2163 {
2164         processor_box.processor_operation (ProcessorBox::ProcessorsPaste);
2165 }
2166
2167 void
2168 MixerStrip::select_all_processors ()
2169 {
2170         processor_box.processor_operation (ProcessorBox::ProcessorsSelectAll);
2171 }
2172
2173 void
2174 MixerStrip::deselect_all_processors ()
2175 {
2176         processor_box.processor_operation (ProcessorBox::ProcessorsSelectNone);
2177 }
2178
2179 bool
2180 MixerStrip::delete_processors ()
2181 {
2182         return processor_box.processor_operation (ProcessorBox::ProcessorsDelete);
2183 }
2184
2185 void
2186 MixerStrip::toggle_processors ()
2187 {
2188         processor_box.processor_operation (ProcessorBox::ProcessorsToggleActive);
2189 }
2190
2191 void
2192 MixerStrip::ab_plugins ()
2193 {
2194         processor_box.processor_operation (ProcessorBox::ProcessorsAB);
2195 }
2196
2197 bool
2198 MixerStrip::level_meter_button_press (GdkEventButton* ev)
2199 {
2200         if (_current_delivery && boost::dynamic_pointer_cast<Send>(_current_delivery)) {
2201                 return false;
2202         }
2203         if (ev->button == 3) {
2204                 popup_level_meter_menu (ev);
2205                 return true;
2206         }
2207
2208         return false;
2209 }
2210
2211 void
2212 MixerStrip::popup_level_meter_menu (GdkEventButton* ev)
2213 {
2214         using namespace Gtk::Menu_Helpers;
2215
2216         Gtk::Menu* m = manage (new Menu);
2217         MenuList& items = m->items ();
2218
2219         RadioMenuItem::Group group;
2220
2221         _suspend_menu_callbacks = true;
2222         add_level_meter_item_point (items, group, _("Input"), MeterInput);
2223         add_level_meter_item_point (items, group, _("Pre Fader"), MeterPreFader);
2224         add_level_meter_item_point (items, group, _("Post Fader"), MeterPostFader);
2225         add_level_meter_item_point (items, group, _("Output"), MeterOutput);
2226         add_level_meter_item_point (items, group, _("Custom"), MeterCustom);
2227
2228         RadioMenuItem::Group tgroup;
2229         items.push_back (SeparatorElem());
2230
2231         add_level_meter_item_type (items, tgroup, ArdourMeter::meter_type_string(MeterPeak), MeterPeak);
2232         add_level_meter_item_type (items, tgroup, ArdourMeter::meter_type_string(MeterKrms),  MeterKrms);
2233         add_level_meter_item_type (items, tgroup, ArdourMeter::meter_type_string(MeterIEC1DIN), MeterIEC1DIN);
2234         add_level_meter_item_type (items, tgroup, ArdourMeter::meter_type_string(MeterIEC1NOR), MeterIEC1NOR);
2235         add_level_meter_item_type (items, tgroup, ArdourMeter::meter_type_string(MeterIEC2BBC), MeterIEC2BBC);
2236         add_level_meter_item_type (items, tgroup, ArdourMeter::meter_type_string(MeterIEC2EBU), MeterIEC2EBU);
2237         add_level_meter_item_type (items, tgroup, ArdourMeter::meter_type_string(MeterK20), MeterK20);
2238         add_level_meter_item_type (items, tgroup, ArdourMeter::meter_type_string(MeterK14), MeterK14);
2239         add_level_meter_item_type (items, tgroup, ArdourMeter::meter_type_string(MeterK12), MeterK12);
2240         add_level_meter_item_type (items, tgroup, ArdourMeter::meter_type_string(MeterVU),  MeterVU);
2241
2242         int _strip_type;
2243         if (_route->is_master()) {
2244                 _strip_type = 4;
2245         }
2246         else if (boost::dynamic_pointer_cast<AudioTrack>(_route) == 0
2247                         && boost::dynamic_pointer_cast<MidiTrack>(_route) == 0) {
2248                 /* non-master bus */
2249                 _strip_type = 3;
2250         }
2251         else if (boost::dynamic_pointer_cast<MidiTrack>(_route)) {
2252                 _strip_type = 2;
2253         }
2254         else {
2255                 _strip_type = 1;
2256         }
2257
2258         MeterType cmt = _route->meter_type();
2259         const std::string cmn = ArdourMeter::meter_type_string(cmt);
2260
2261         items.push_back (SeparatorElem());
2262         items.push_back (MenuElem (string_compose(_("Change all in Group to %1"), cmn),
2263                                 sigc::bind (SetMeterTypeMulti, -1, _route->route_group(), cmt)));
2264         items.push_back (MenuElem (string_compose(_("Change all to %1"), cmn),
2265                                 sigc::bind (SetMeterTypeMulti, 0, _route->route_group(), cmt)));
2266         items.push_back (MenuElem (string_compose(_("Change same track-type to %1"), cmn),
2267                                 sigc::bind (SetMeterTypeMulti, _strip_type, _route->route_group(), cmt)));
2268
2269         m->popup (ev->button, ev->time);
2270         _suspend_menu_callbacks = false;
2271 }
2272
2273 void
2274 MixerStrip::add_level_meter_item_point (Menu_Helpers::MenuList& items,
2275                 RadioMenuItem::Group& group, string const & name, MeterPoint point)
2276 {
2277         using namespace Menu_Helpers;
2278
2279         items.push_back (RadioMenuElem (group, name, sigc::bind (sigc::mem_fun (*this, &MixerStrip::set_meter_point), point)));
2280         RadioMenuItem* i = dynamic_cast<RadioMenuItem *> (&items.back ());
2281         i->set_active (_route->meter_point() == point);
2282 }
2283
2284 void
2285 MixerStrip::set_meter_point (MeterPoint p)
2286 {
2287         if (_suspend_menu_callbacks) return;
2288         _route->set_meter_point (p);
2289 }
2290
2291 void
2292 MixerStrip::add_level_meter_item_type (Menu_Helpers::MenuList& items,
2293                 RadioMenuItem::Group& group, string const & name, MeterType type)
2294 {
2295         using namespace Menu_Helpers;
2296
2297         items.push_back (RadioMenuElem (group, name, sigc::bind (sigc::mem_fun (*this, &MixerStrip::set_meter_type), type)));
2298         RadioMenuItem* i = dynamic_cast<RadioMenuItem *> (&items.back ());
2299         i->set_active (_route->meter_type() == type);
2300 }
2301
2302 void
2303 MixerStrip::set_meter_type (MeterType t)
2304 {
2305         if (_suspend_menu_callbacks) return;
2306         gpm.set_type (t);
2307 }