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