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