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
  21 #include <sigc++/bind.h>
  22
  23 #include <pbd/convert.h>
  24
  25 #include <gtkmm2ext/gtk_ui.h>
  26 #include <gtkmm2ext/utils.h>
  27 #include <gtkmm2ext/choice.h>
  28 #include <gtkmm2ext/stop_signal.h>
  29 #include <gtkmm2ext/doi.h>
  30 #include <gtkmm2ext/slider_controller.h>
  31 #include <gtkmm2ext/bindable_button.h>
  32
  33 #include <ardour/ardour.h>
  34 #include <ardour/session.h>
  35 #include <ardour/audioengine.h>
  36 #include <ardour/route.h>
  37 #include <ardour/audio_track.h>
  38 #include <ardour/audio_diskstream.h>
  39 #include <ardour/panner.h>
  40 #include <ardour/send.h>
  41 #include <ardour/insert.h>
  42 #include <ardour/ladspa_plugin.h>
  43 #include <ardour/connection.h>
  44 #include <ardour/session_connection.h>
  45
  46 #include "ardour_ui.h"
  47 #include "ardour_dialog.h"
  48 #include "mixer_strip.h"
  49 #include "mixer_ui.h"
  50 #include "keyboard.h"
  51 #include "public_editor.h"
  52 #include "send_ui.h"
  53 #include "io_selector.h"
  54 #include "utils.h"
  55 #include "gui_thread.h"
  56
  57 #include "i18n.h"
  58
  59 using namespace sigc;
  60 using namespace ARDOUR;
  61 using namespace PBD;
  62 using namespace Gtk;
  63 using namespace Gtkmm2ext;
  64
  65 int MixerStrip::scrollbar_height = 0;
  66
  67 #ifdef VARISPEED_IN_MIXER_STRIP
  68 static void
  69 speed_printer (char buf[32], Gtk::Adjustment& adj, void* arg)
  70 {
  71         float val = adj.get_value ();
  72
  73         if (val == 1.0) {
  74                 strcpy (buf, "1");
  75         } else {
  76                 snprintf (buf, 32, "%.3f", val);
  77         }
  78 }
  79 #endif
  80
  81 MixerStrip::MixerStrip (Mixer_UI& mx, Session& sess, boost::shared_ptr<Route> rt, bool in_mixer)
  82         : AxisView(sess),
  83           RouteUI (rt, sess, _("Mute"), _("Solo"), _("Record")),
  84           _mixer(mx),
  85           pre_redirect_box (PreFader, sess, rt, mx.plugin_selector(), mx.selection(), in_mixer),
  86           post_redirect_box (PostFader, sess, rt, mx.plugin_selector(), mx.selection(), in_mixer),
  87           gpm (_route, sess),
  88           panners (_route, sess),
  89           button_table (3, 2),
  90           middle_button_table (1, 2),
  91           bottom_button_table (1, 2),
  92           meter_point_label (_("pre")),
  93           comment_button (_("Comments")),
  94           speed_adjustment (1.0, 0.001, 4.0, 0.001, 0.1),
  95           speed_spinner (&speed_adjustment, "MixerStripSpeedBase", true)
  96
  97 {
  98         if (set_color_from_route()) {
  99                 set_color (unique_random_color());
 100         }
 101
 102         input_selector = 0;
 103         output_selector = 0;
 104         group_menu = 0;
 105         _marked_for_display = false;
 106         route_ops_menu = 0;
 107         ignore_comment_edit = false;
 108         ignore_toggle = false;
 109         ignore_speed_adjustment = false;
 110         comment_window = 0;
 111         comment_area = 0;
 112
 113         width_button.add (*(manage (new Gtk::Image (::get_icon("strip_width")))));
 114         hide_button.add (*(manage (new Gtk::Image (::get_icon("hide")))));
 115
 116         input_label.set_text (_("Input"));
 117         input_button.add (input_label);
 118         input_button.set_name ("MixerIOButton");
 119         input_label.set_name ("MixerIOButtonLabel");
 120
 121         output_label.set_text (_("Output"));
 122         output_button.add (output_label);
 123         output_button.set_name ("MixerIOButton");
 124         output_label.set_name ("MixerIOButtonLabel");
 125
 126         _route->meter_change.connect (mem_fun(*this, &MixerStrip::meter_changed));
 127         meter_point_button.add (meter_point_label);
 128         meter_point_button.set_name ("MixerStripMeterPreButton");
 129         meter_point_label.set_name ("MixerStripMeterPreButton");
 130
 131         switch (_route->meter_point()) {
 132         case MeterInput:
 133                 meter_point_label.set_text (_("input"));
 134                 break;
 135
 136         case MeterPreFader:
 137                 meter_point_label.set_text (_("pre"));
 138                 break;
 139
 140         case MeterPostFader:
 141                 meter_point_label.set_text (_("post"));
 142                 break;
 143         }
 144
 145         /* TRANSLATORS: this string should be longest of the strings
 146            used to describe meter points. In english, it's "input".
 147         */
 148         set_size_request_to_display_given_text (meter_point_button, _("tupni"), 5, 5);
 149
 150         bottom_button_table.attach (meter_point_button, 1, 2, 0, 1);
 151
 152         meter_point_button.signal_button_press_event().connect (mem_fun (gpm, &GainMeter::meter_press), false);
 153         /* XXX what is this meant to do? */
 154         //meter_point_button.signal_button_release_event().connect (mem_fun (gpm, &GainMeter::meter_release), false);
 155
 156         solo_button->set_name ("MixerSoloButton");
 157         mute_button->set_name ("MixerMuteButton");
 158
 159         hide_button.set_events (hide_button.get_events() & ~(Gdk::ENTER_NOTIFY_MASK|Gdk::LEAVE_NOTIFY_MASK));
 160
 161         width_button.unset_flags (Gtk::CAN_FOCUS);
 162         hide_button.unset_flags (Gtk::CAN_FOCUS);
 163         input_button.unset_flags (Gtk::CAN_FOCUS);
 164         output_button.unset_flags (Gtk::CAN_FOCUS);
 165         solo_button->unset_flags (Gtk::CAN_FOCUS);
 166         mute_button->unset_flags (Gtk::CAN_FOCUS);
 167
 168         button_table.set_homogeneous (true);
 169         button_table.set_spacings (0);
 170
 171         button_table.attach (name_button, 0, 2, 0, 1);
 172         button_table.attach (input_button, 0, 2, 1, 2);
 173
 174         middle_button_table.set_homogeneous (true);
 175         middle_button_table.set_spacings (0);
 176         middle_button_table.attach (*mute_button, 0, 1, 0, 1);
 177         middle_button_table.attach (*solo_button, 1, 2, 0, 1);
 178
 179         bottom_button_table.set_col_spacings (0);
 180         bottom_button_table.set_homogeneous (true);
 181         bottom_button_table.attach (group_button, 0, 1, 0, 1);
 182
 183         if (is_audio_track()) {
 184
 185                 rec_enable_button->set_name ("MixerRecordEnableButton");
 186                 rec_enable_button->unset_flags (Gtk::CAN_FOCUS);
 187                 rec_enable_button->signal_button_press_event().connect (mem_fun(*this, &RouteUI::rec_enable_press));
 188
 189                 AudioTrack* at = audio_track();
 190
 191                 at->FreezeChange.connect (mem_fun(*this, &MixerStrip::map_frozen));
 192
 193 #ifdef VARISPEED_IN_MIXER_STRIP
 194                 speed_adjustment.signal_value_changed().connect (mem_fun(*this, &MixerStrip::speed_adjustment_changed));
 195
 196                 speed_frame.set_name ("BaseFrame");
 197                 speed_frame.set_shadow_type (Gtk::SHADOW_IN);
 198                 speed_frame.add (speed_spinner);
 199
 200                 speed_spinner.set_print_func (speed_printer, 0);
 201
 202                 ARDOUR_UI::instance()->tooltips().set_tip (speed_spinner, _("Varispeed"));
 203
 204                 button_table.attach (speed_frame, 0, 2, 5, 6);
 205 #endif /* VARISPEED_IN_MIXER_STRIP */
 206
 207                 button_table.attach (*rec_enable_button, 0, 2, 2, 3);
 208         }
 209
 210         name_button.add (name_label);
 211         name_button.set_name ("MixerNameButton");
 212         Gtkmm2ext::set_size_request_to_display_given_text (name_button, "longest label", 2, 2);
 213
 214         name_label.set_name ("MixerNameButtonLabel");
 215         if (_route->phase_invert()) {
 216                 name_label.set_text (X_("Ø ") + name_label.get_text());
 217         } else {
 218                 name_label.set_text (_route->name());
 219         }
 220
 221         group_button.add (group_label);
 222         group_button.set_name ("MixerGroupButton");
 223         group_label.set_name ("MixerGroupButtonLabel");
 224
 225         comment_button.set_name ("MixerCommentButton");
 226
 227         ARDOUR_UI::instance()->tooltips().set_tip (comment_button, _route->comment()==""        ?
 228                                                         _("Click to Add/Edit Comments"):
 229                                                         _route->comment());
 230
 231         comment_button.signal_clicked().connect (mem_fun(*this, &MixerStrip::comment_button_clicked));
 232
 233         global_vpacker.set_border_width (0);
 234         global_vpacker.set_spacing (0);
 235
 236         Gtk::VBox *whvbox = manage (new Gtk::VBox);
 237
 238         width_button.set_name ("MixerWidthButton");
 239         hide_button.set_name ("MixerHideButton");
 240
 241         width_button.signal_clicked().connect (mem_fun(*this, &MixerStrip::width_clicked));
 242         hide_button.signal_clicked().connect (mem_fun(*this, &MixerStrip::hide_clicked));
 243
 244         width_hide_box.pack_start (width_button, false, true);
 245         width_hide_box.pack_end (hide_button, false, true);
 246         Gtk::Alignment *gain_meter_alignment = Gtk::manage(new Gtk::Alignment());
 247         gain_meter_alignment->set_padding(0, 4, 0, 0);
 248         gain_meter_alignment->add(gpm);
 249
 250         whvbox->pack_start (width_hide_box, true, true);
 251
 252         global_vpacker.pack_start (*whvbox, Gtk::PACK_SHRINK);
 253         global_vpacker.pack_start (button_table,Gtk::PACK_SHRINK);
 254         global_vpacker.pack_start (pre_redirect_box, true, true);
 255         global_vpacker.pack_start (middle_button_table,Gtk::PACK_SHRINK);
 256         global_vpacker.pack_start (*gain_meter_alignment,Gtk::PACK_SHRINK);
 257         global_vpacker.pack_start (bottom_button_table,Gtk::PACK_SHRINK);
 258         global_vpacker.pack_start (post_redirect_box, true, true);
 259         global_vpacker.pack_start (panners, Gtk::PACK_SHRINK);
 260         global_vpacker.pack_start (output_button, Gtk::PACK_SHRINK);
 261         global_vpacker.pack_start (comment_button, Gtk::PACK_SHRINK);
 262
 263         if (route()->master() || route()->control()) {
 264
 265                 if (scrollbar_height == 0) {
 266                         HScrollbar scrollbar;
 267                         Gtk::Requisition requisition;
 268                         scrollbar.size_request (requisition);
 269                         scrollbar_height = requisition.height;
 270                 }
 271
 272                 EventBox* spacer = manage (new EventBox);
 273                 spacer->set_size_request (-1, scrollbar_height);
 274                 global_vpacker.pack_start (*spacer, false, false);
 275         }
 276
 277         global_frame.add (global_vpacker);
 278         global_frame.set_shadow_type (Gtk::SHADOW_IN);
 279         global_frame.set_name ("BaseFrame");
 280
 281         add (global_frame);
 282
 283         /* force setting of visible selected status */
 284
 285         _selected = true;
 286         set_selected (false);
 287
 288         _packed = false;
 289         _embedded = false;
 290
 291         _session.engine().Stopped.connect (mem_fun(*this, &MixerStrip::engine_stopped));
 292         _session.engine().Running.connect (mem_fun(*this, &MixerStrip::engine_running));
 293         _route->input_changed.connect (mem_fun(*this, &MixerStrip::input_changed));
 294         _route->output_changed.connect (mem_fun(*this, &MixerStrip::output_changed));
 295         _route->mute_changed.connect (mem_fun(*this, &RouteUI::mute_changed));
 296         _route->solo_changed.connect (mem_fun(*this, &RouteUI::solo_changed));
 297         _route->solo_safe_changed.connect (mem_fun(*this, &RouteUI::solo_changed));
 298         _route->mix_group_changed.connect (mem_fun(*this, &MixerStrip::mix_group_changed));
 299         _route->panner().Changed.connect (mem_fun(*this, &MixerStrip::connect_to_pan));
 300
 301         if (is_audio_track()) {
 302                 audio_track()->DiskstreamChanged.connect (mem_fun(*this, &MixerStrip::diskstream_changed));
 303                 get_diskstream()->SpeedChanged.connect (mem_fun(*this, &MixerStrip::speed_changed));
 304         }
 305
 306         _route->name_changed.connect (mem_fun(*this, &RouteUI::name_changed));
 307         _route->comment_changed.connect (mem_fun(*this, &MixerStrip::comment_changed));
 308         _route->gui_changed.connect (mem_fun(*this, &MixerStrip::route_gui_changed));
 309
 310         input_button.signal_button_press_event().connect (mem_fun(*this, &MixerStrip::input_press), false);
 311         output_button.signal_button_press_event().connect (mem_fun(*this, &MixerStrip::output_press), false);
 312
 313         solo_button->signal_button_press_event().connect (mem_fun(*this, &RouteUI::solo_press), false);
 314         solo_button->signal_button_release_event().connect (mem_fun(*this, &RouteUI::solo_release), false);
 315         mute_button->signal_button_press_event().connect (mem_fun(*this, &RouteUI::mute_press), false);
 316         mute_button->signal_button_release_event().connect (mem_fun(*this, &RouteUI::mute_release), false);
 317
 318         name_button.signal_button_press_event().connect (mem_fun(*this, &MixerStrip::name_button_button_press), false);
 319         group_button.signal_button_press_event().connect (mem_fun(*this, &MixerStrip::select_mix_group), false);
 320
 321         _width = (Width) -1;
 322         set_stuff_from_route ();
 323
 324         /* start off as a passthru strip. we'll correct this, if necessary,
 325            in update_diskstream_display().
 326         */
 327
 328         set_name ("AudioTrackStripBase");
 329
 330         /* now force an update of all the various elements */
 331
 332         pre_redirect_box.update();
 333         post_redirect_box.update();
 334         mute_changed (0);
 335         solo_changed (0);
 336         name_changed (0);
 337         comment_changed (0);
 338         mix_group_changed (0);
 339
 340         connect_to_pan ();
 341
 342         panners.setup_pan ();
 343
 344         if (is_audio_track()) {
 345                 speed_changed ();
 346         }
 347
 348         update_diskstream_display ();
 349         update_input_display ();
 350         update_output_display ();
 351
 352         add_events (Gdk::BUTTON_RELEASE_MASK);
 353 }
 354
 355 MixerStrip::~MixerStrip ()
 356 {
 357         GoingAway(); /* EMIT_SIGNAL */
 358
 359         if (input_selector) {
 360                 delete input_selector;
 361         }
 362
 363         if (output_selector) {
 364                 delete output_selector;
 365         }
 366 }
 367
 368 void
 369 MixerStrip::set_stuff_from_route ()
 370 {
 371         XMLProperty *prop;
 372
 373         ensure_xml_node ();
 374
 375         if ((prop = xml_node->property ("strip_width")) != 0) {
 376                 if (prop->value() == "wide") {
 377                         set_width (Wide);
 378                 } else if (prop->value() == "narrow") {
 379                         set_width (Narrow);
 380                 }
 381                 else {
 382                         error << string_compose(_("unknown strip width \"%1\" in XML GUI information"), prop->value()) << endmsg;
 383                         set_width (Wide);
 384                 }
 385         }
 386         else {
 387                 set_width (Wide);
 388         }
 389
 390         if ((prop = xml_node->property ("shown_mixer")) != 0) {
 391                 if (prop->value() == "no") {
 392                         _marked_for_display = false;
 393                 } else {
 394                         _marked_for_display = true;
 395                 }
 396         }
 397         else {
 398                 /* backwards compatibility */
 399                 _marked_for_display = true;
 400         }
 401 }
 402
 403 void
 404 MixerStrip::set_width (Width w)
 405 {
 406         /* always set the gpm width again, things may be hidden */
 407         gpm.set_width (w);
 408         panners.set_width (w);
 409         pre_redirect_box.set_width (w);
 410         post_redirect_box.set_width (w);
 411
 412         if (_width == w) {
 413                 return;
 414         }
 415
 416         ensure_xml_node ();
 417
 418         _width = w;
 419
 420         switch (w) {
 421         case Wide:
 422                 set_size_request (-1, -1);
 423                 xml_node->add_property ("strip_width", "wide");
 424
 425                 if (rec_enable_button) {
 426                         rec_enable_button->set_label (_("record"));
 427                 }
 428                 mute_button->set_label  (_("mute"));
 429                 solo_button->set_label (_("solo"));
 430
 431                 if (_route->comment() == "") {
 432                        comment_button.unset_bg (STATE_NORMAL);
 433                        comment_button.set_label (_("comments"));
 434                 } else {
 435                        comment_button.modify_bg (STATE_NORMAL, color());
 436                        comment_button.set_label (_("*comments*"));
 437                 }
 438
 439                 gpm.gain_automation_style_button.set_label (gpm.astyle_string(_route->gain_automation_curve().automation_style()));
 440                 gpm.gain_automation_state_button.set_label (gpm.astate_string(_route->gain_automation_curve().automation_state()));
 441                 panners.pan_automation_style_button.set_label (panners.astyle_string(_route->panner().automation_style()));
 442                 panners.pan_automation_state_button.set_label (panners.astate_string(_route->panner().automation_state()));
 443                 Gtkmm2ext::set_size_request_to_display_given_text (name_button, "long", 2, 2);
 444                 break;
 445
 446         case Narrow:
 447                 set_size_request (50, -1);
 448                 xml_node->add_property ("strip_width", "narrow");
 449
 450                 if (rec_enable_button) {
 451                         rec_enable_button->set_label (_("Rec"));
 452                 }
 453                 mute_button->set_label (_("M"));
 454                 solo_button->set_label (_("S"));
 455
 456                 if (_route->comment() == "") {
 457                        comment_button.unset_bg (STATE_NORMAL);
 458                        comment_button.set_label (_("Cmt"));
 459                 } else {
 460                        comment_button.modify_bg (STATE_NORMAL, color());
 461                        comment_button.set_label (_("*Cmt*"));
 462                 }
 463
 464                 gpm.gain_automation_style_button.set_label (gpm.short_astyle_string(_route->gain_automation_curve().automation_style()));
 465                 gpm.gain_automation_state_button.set_label (gpm.short_astate_string(_route->gain_automation_curve().automation_state()));
 466                 panners.pan_automation_style_button.set_label (panners.short_astyle_string(_route->panner().automation_style()));
 467                 panners.pan_automation_state_button.set_label (panners.short_astate_string(_route->panner().automation_state()));
 468                 Gtkmm2ext::set_size_request_to_display_given_text (name_button, "longest label", 2, 2);
 469                 break;
 470         }
 471
 472         update_input_display ();
 473         update_output_display ();
 474         mix_group_changed (0);
 475         name_changed (0);
 476
 477 }
 478
 479 void
 480 MixerStrip::set_packed (bool yn)
 481 {
 482         _packed = yn;
 483
 484         ensure_xml_node ();
 485
 486         if (_packed) {
 487                 xml_node->add_property ("shown_mixer", "yes");
 488         } else {
 489                 xml_node->add_property ("shown_mixer", "no");
 490         }
 491 }
 492
 493
 494 gint
 495 MixerStrip::output_press (GdkEventButton *ev)
 496 {
 497         using namespace Menu_Helpers;
 498         if (!_session.engine().connected()) {
 499                 MessageDialog msg (_("Not connected to JACK - no I/O changes are possible"));
 500                 msg.run ();
 501                 return true;
 502         }
 503
 504         MenuList& citems = output_menu.items();
 505         switch (ev->button) {
 506
 507         case 1:
 508                 output_menu.set_name ("ArdourContextMenu");
 509                 citems.clear();
 510
 511                 citems.push_back (MenuElem (_("Edit"), mem_fun(*this, &MixerStrip::edit_output_configuration)));
 512                 citems.push_back (SeparatorElem());
 513                 citems.push_back (MenuElem (_("Disconnect"), mem_fun (*(static_cast<RouteUI*>(this)), &RouteUI::disconnect_output)));
 514                 citems.push_back (SeparatorElem());
 515
 516                 _session.foreach_connection (this, &MixerStrip::add_connection_to_output_menu);
 517
 518                 output_menu.popup (1, ev->time);
 519                 break;
 520
 521         default:
 522                 break;
 523         }
 524         return TRUE;
 525 }
 526
 527 void
 528 MixerStrip::edit_output_configuration ()
 529 {
 530         if (output_selector == 0) {
 531                 output_selector = new IOSelectorWindow (_session, _route, false);
 532         }
 533
 534         if (output_selector->is_visible()) {
 535                 output_selector->get_toplevel()->get_window()->raise();
 536         } else {
 537                 output_selector->show_all ();
 538         }
 539 }
 540
 541 void
 542 MixerStrip::edit_input_configuration ()
 543 {
 544         if (input_selector == 0) {
 545                 input_selector = new IOSelectorWindow (_session, _route, true);
 546         }
 547
 548         if (input_selector->is_visible()) {
 549                 input_selector->get_toplevel()->get_window()->raise();
 550         } else {
 551                 input_selector->show_all ();
 552         }
 553 }
 554
 555 gint
 556 MixerStrip::input_press (GdkEventButton *ev)
 557 {
 558         using namespace Menu_Helpers;
 559
 560         MenuList& citems = input_menu.items();
 561         input_menu.set_name ("ArdourContextMenu");
 562         citems.clear();
 563
 564         if (!_session.engine().connected()) {
 565                 MessageDialog msg (_("Not connected to JACK - no I/O changes are possible"));
 566                 msg.run ();
 567                 return true;
 568         }
 569
 570         switch (ev->button) {
 571
 572         case 1:
 573                 citems.push_back (MenuElem (_("Edit"), mem_fun(*this, &MixerStrip::edit_input_configuration)));
 574                 citems.push_back (SeparatorElem());
 575                 citems.push_back (MenuElem (_("Disconnect"), mem_fun (*(static_cast<RouteUI*>(this)), &RouteUI::disconnect_input)));
 576                 citems.push_back (SeparatorElem());
 577
 578                 _session.foreach_connection (this, &MixerStrip::add_connection_to_input_menu);
 579
 580                 input_menu.popup (1, ev->time);
 581                 break;
 582
 583         default:
 584                 break;
 585         }
 586         return TRUE;
 587 }
 588
 589 void
 590 MixerStrip::connection_input_chosen (ARDOUR::Connection *c)
 591 {
 592         if (!ignore_toggle) {
 593
 594                 try {
 595                         _route->use_input_connection (*c, this);
 596                 }
 597
 598                 catch (AudioEngine::PortRegistrationFailure& err) {
 599                         error << _("could not register new ports required for that connection")
 600                               << endmsg;
 601                 }
 602         }
 603 }
 604
 605 void
 606 MixerStrip::connection_output_chosen (ARDOUR::Connection *c)
 607 {
 608         if (!ignore_toggle) {
 609
 610                 try {
 611                         _route->use_output_connection (*c, this);
 612                 }
 613
 614                 catch (AudioEngine::PortRegistrationFailure& err) {
 615                         error << _("could not register new ports required for that connection")
 616                               << endmsg;
 617                 }
 618         }
 619 }
 620
 621 void
 622 MixerStrip::add_connection_to_input_menu (ARDOUR::Connection* c)
 623 {
 624         using namespace Menu_Helpers;
 625
 626         if (dynamic_cast<InputConnection *> (c) == 0) {
 627                 return;
 628         }
 629
 630         MenuList& citems = input_menu.items();
 631
 632         if (c->nports() == _route->n_inputs().get_total()) {
 633
 634                 citems.push_back (CheckMenuElem (c->name(), bind (mem_fun(*this, &MixerStrip::connection_input_chosen), c)));
 635
 636                 ARDOUR::Connection *current = _route->input_connection();
 637
 638                 if (current == c) {
 639                         ignore_toggle = true;
 640                         dynamic_cast<CheckMenuItem *> (&citems.back())->set_active (true);
 641                         ignore_toggle = false;
 642                 }
 643         }
 644 }
 645
 646 void
 647 MixerStrip::add_connection_to_output_menu (ARDOUR::Connection* c)
 648 {
 649         using namespace Menu_Helpers;
 650
 651         if (dynamic_cast<OutputConnection *> (c) == 0) {
 652                 return;
 653         }
 654
 655         if (c->nports() == _route->n_outputs().get_total()) {
 656
 657                 MenuList& citems = output_menu.items();
 658                 citems.push_back (CheckMenuElem (c->name(), bind (mem_fun(*this, &MixerStrip::connection_output_chosen), c)));
 659
 660                 ARDOUR::Connection *current = _route->output_connection();
 661
 662                 if (current == c) {
 663                         ignore_toggle = true;
 664                         dynamic_cast<CheckMenuItem *> (&citems.back())->set_active (true);
 665                         ignore_toggle = false;
 666                 }
 667         }
 668 }
 669
 670 void
 671 MixerStrip::update_diskstream_display ()
 672 {
 673         if (is_audio_track()) {
 674
 675                 map_frozen ();
 676
 677                 update_input_display ();
 678
 679                 if (input_selector) {
 680                         input_selector->hide_all ();
 681                 }
 682
 683                 show_route_color ();
 684
 685         } else {
 686
 687                 map_frozen ();
 688
 689                 update_input_display ();
 690                 show_passthru_color ();
 691         }
 692 }
 693
 694 void
 695 MixerStrip::connect_to_pan ()
 696 {
 697         ENSURE_GUI_THREAD(mem_fun(*this, &MixerStrip::connect_to_pan));
 698
 699         panstate_connection.disconnect ();
 700         panstyle_connection.disconnect ();
 701
 702         if (!_route->panner().empty()) {
 703                 StreamPanner* sp = _route->panner().front();
 704
 705                 panstate_connection = sp->automation().automation_state_changed.connect (mem_fun(panners, &PannerUI::pan_automation_state_changed));
 706                 panstyle_connection = sp->automation().automation_style_changed.connect (mem_fun(panners, &PannerUI::pan_automation_style_changed));
 707         }
 708
 709         panners.pan_changed (this);
 710 }
 711
 712 void
 713 MixerStrip::update_input_display ()
 714 {
 715         ARDOUR::Connection *c;
 716
 717         if ((c = _route->input_connection()) != 0) {
 718                 input_label.set_text (c->name());
 719         } else {
 720                 switch (_width) {
 721                 case Wide:
 722                         input_label.set_text (_(" Input"));
 723                         break;
 724                 case Narrow:
 725                         input_label.set_text (_("I"));
 726                         break;
 727                 }
 728         }
 729         panners.setup_pan ();
 730 }
 731
 732 void
 733 MixerStrip::update_output_display ()
 734 {
 735         ARDOUR::Connection *c;
 736
 737         if ((c = _route->output_connection()) != 0) {
 738                 output_label.set_text (c->name());
 739         } else {
 740                 switch (_width) {
 741                 case Wide:
 742                         output_label.set_text (_("Output"));
 743                         break;
 744                 case Narrow:
 745                         output_label.set_text (_("O"));
 746                         break;
 747                 }
 748         }
 749         gpm.setup_meters ();
 750         panners.setup_pan ();
 751 }
 752
 753 void
 754 MixerStrip::fast_update ()
 755 {
 756         gpm.update_meters ();
 757 }
 758
 759 void
 760 MixerStrip::diskstream_changed ()
 761 {
 762         Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &MixerStrip::update_diskstream_display));
 763 }
 764
 765 void
 766 MixerStrip::input_changed (IOChange change, void *src)
 767 {
 768         Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &MixerStrip::update_input_display));
 769 }
 770
 771 void
 772 MixerStrip::output_changed (IOChange change, void *src)
 773 {
 774         Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &MixerStrip::update_output_display));
 775 }
 776
 777
 778 void
 779 MixerStrip::comment_editor_done_editing() {
 780         string str =  comment_area->get_buffer()->get_text();
 781         if (_route->comment() != str) {
 782                 _route->set_comment (str, this);
 783
 784                 switch (_width) {
 785
 786                 case Wide:
 787                         if (! str.empty()) {
 788                                 comment_button.modify_bg (STATE_NORMAL, color());
 789                                 comment_button.set_label (_("*Comments*"));
 790                         } else {
 791                                 comment_button.unset_bg (STATE_NORMAL);
 792                                 comment_button.set_label (_("Comments"));
 793                         }
 794                         break;
 795
 796                 case Narrow:
 797                         if (! str.empty()) {
 798                                 comment_button.modify_bg (STATE_NORMAL, color());
 799                                 comment_button.set_label (_("*Cmt*"));
 800                         } else {
 801                                 comment_button.unset_bg (STATE_NORMAL);
 802                                 comment_button.set_label (_("Cmt"));
 803                         }
 804                         break;
 805                 }
 806
 807                 ARDOUR_UI::instance()->tooltips().set_tip (comment_button,
 808                                 str.empty() ? _("Click to Add/Edit Comments") : str);
 809         }
 810
 811 }
 812
 813 void
 814 MixerStrip::comment_button_clicked ()
 815 {
 816         if (comment_window == 0) {
 817                 setup_comment_editor ();
 818         }
 819
 820     int x, y, cw_width, cw_height;
 821
 822         if (comment_window->is_visible()) {
 823                 comment_window->hide ();
 824                 return;
 825         }
 826
 827         comment_window->get_size (cw_width, cw_height);
 828         comment_window->get_position(x, y);
 829         comment_window->move(x, y - (cw_height / 2) - 45);
 830         /*
 831            half the dialog height minus the comments button height
 832            with some window decoration fudge thrown in.
 833         */
 834
 835         comment_window->show();
 836         comment_window->present();
 837 }
 838
 839 void
 840 MixerStrip::setup_comment_editor ()
 841 {
 842         string title;
 843         title = _route->name();
 844         title += _(": comment editor");
 845
 846         comment_window = new ArdourDialog (title, false);
 847         comment_window->set_position (Gtk::WIN_POS_MOUSE);
 848         comment_window->set_skip_taskbar_hint (true);
 849         comment_window->signal_hide().connect (mem_fun(*this, &MixerStrip::comment_editor_done_editing));
 850
 851         comment_area = manage (new TextView());
 852         comment_area->set_name ("MixerTrackCommentArea");
 853         comment_area->set_size_request (110, 178);
 854         comment_area->set_wrap_mode (WRAP_WORD);
 855         comment_area->set_editable (true);
 856         comment_area->get_buffer()->set_text (_route->comment());
 857         comment_area->show ();
 858
 859         comment_window->get_vbox()->pack_start (*comment_area);
 860         comment_window->get_action_area()->hide();
 861 }
 862
 863 void
 864 MixerStrip::comment_changed (void *src)
 865 {
 866         ENSURE_GUI_THREAD(bind (mem_fun(*this, &MixerStrip::comment_changed), src));
 867
 868         if (src != this) {
 869                 ignore_comment_edit = true;
 870                 if (comment_area) {
 871                         comment_area->get_buffer()->set_text (_route->comment());
 872                 }
 873                 ignore_comment_edit = false;
 874         }
 875 }
 876
 877 void
 878 MixerStrip::set_mix_group (RouteGroup *rg)
 879 {
 880         _route->set_mix_group (rg, this);
 881 }
 882
 883 void
 884 MixerStrip::add_mix_group_to_menu (RouteGroup *rg, RadioMenuItem::Group* group)
 885 {
 886         using namespace Menu_Helpers;
 887
 888         MenuList& items = group_menu->items();
 889
 890         items.push_back (RadioMenuElem (*group, rg->name(), bind (mem_fun(*this, &MixerStrip::set_mix_group), rg)));
 891
 892         if (_route->mix_group() == rg) {
 893                 static_cast<RadioMenuItem*>(&items.back())->set_active ();
 894         }
 895 }
 896
 897 bool
 898 MixerStrip::select_mix_group (GdkEventButton *ev)
 899 {
 900         using namespace Menu_Helpers;
 901
 902         if (group_menu == 0) {
 903                 group_menu = new Menu;
 904         }
 905         group_menu->set_name ("ArdourContextMenu");
 906         MenuList& items = group_menu->items();
 907         RadioMenuItem::Group group;
 908
 909         switch (ev->button) {
 910         case 1:
 911
 912                 items.clear ();
 913                 items.push_back (RadioMenuElem (group, _("No group"), bind (mem_fun(*this, &MixerStrip::set_mix_group), (RouteGroup *) 0)));
 914
 915                 _session.foreach_mix_group (bind (mem_fun (*this, &MixerStrip::add_mix_group_to_menu), &group));
 916
 917                 group_menu->popup (1, ev->time);
 918                 break;
 919
 920         default:
 921                 break;
 922         }
 923
 924         return true;
 925 }
 926
 927 void
 928 MixerStrip::mix_group_changed (void *ignored)
 929 {
 930         ENSURE_GUI_THREAD(bind (mem_fun(*this, &MixerStrip::mix_group_changed), ignored));
 931
 932         RouteGroup *rg = _route->mix_group();
 933
 934         if (rg) {
 935                 group_label.set_text (rg->name());
 936         } else {
 937                 switch (_width) {
 938                 case Wide:
 939                         group_label.set_text (_("Grp"));
 940                         break;
 941                 case Narrow:
 942                         group_label.set_text (_("~G"));
 943                         break;
 944                 }
 945         }
 946 }
 947
 948
 949 void
 950 MixerStrip::route_gui_changed (string what_changed, void* ignored)
 951 {
 952         ENSURE_GUI_THREAD(bind (mem_fun(*this, &MixerStrip::route_gui_changed), what_changed, ignored));
 953
 954         if (what_changed == "color") {
 955                 if (set_color_from_route () == 0) {
 956                         show_route_color ();
 957                 }
 958         }
 959 }
 960
 961 void
 962 MixerStrip::show_route_color ()
 963 {
 964         name_button.modify_bg (STATE_NORMAL, color());
 965         route_active_changed ();
 966 }
 967
 968 void
 969 MixerStrip::show_passthru_color ()
 970 {
 971         route_active_changed ();
 972 }
 973
 974 void
 975 MixerStrip::build_route_ops_menu ()
 976 {
 977         using namespace Menu_Helpers;
 978
 979         route_ops_menu = manage (new Menu);
 980         route_ops_menu->set_name ("ArdourContextMenu");
 981
 982         MenuList& items = route_ops_menu->items();
 983
 984         items.push_back (MenuElem (_("Rename"), mem_fun(*this, &RouteUI::route_rename)));
 985         items.push_back (SeparatorElem());
 986         items.push_back (CheckMenuElem (_("Active"), mem_fun (*this, &RouteUI::toggle_route_active)));
 987         route_active_menu_item = dynamic_cast<CheckMenuItem *> (&items.back());
 988         route_active_menu_item->set_active (_route->active());
 989         items.push_back (SeparatorElem());
 990         items.push_back (CheckMenuElem (_("Invert Polarity"), mem_fun (*this, &RouteUI::toggle_polarity)));
 991         polarity_menu_item = dynamic_cast<CheckMenuItem *> (&items.back());
 992         polarity_menu_item->set_active (_route->phase_invert());
 993
 994         build_remote_control_menu ();
 995
 996         items.push_back (SeparatorElem());
 997         items.push_back (MenuElem (_("Remote Control ID"), *remote_control_menu));
 998
 999         items.push_back (SeparatorElem());
1000         items.push_back (MenuElem (_("Remove"), mem_fun(*this, &RouteUI::remove_this_route)));
1001 }
1002
1003 gint
1004 MixerStrip::name_button_button_press (GdkEventButton* ev)
1005 {
1006         if (ev->button == 1) {
1007                 list_route_operations ();
1008                 route_ops_menu->popup (1, ev->time);
1009         }
1010         return FALSE;
1011 }
1012
1013 void
1014 MixerStrip::list_route_operations ()
1015 {
1016         if (route_ops_menu == 0) {
1017                 build_route_ops_menu ();
1018         }
1019
1020         refresh_remote_control_menu();
1021 }
1022
1023
1024 void
1025 MixerStrip::speed_adjustment_changed ()
1026 {
1027         /* since there is a usable speed adjustment, there has to be a diskstream */
1028         if (!ignore_speed_adjustment) {
1029                 get_diskstream()->set_speed (speed_adjustment.get_value());
1030         }
1031 }
1032
1033 void
1034 MixerStrip::speed_changed ()
1035 {
1036         Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &MixerStrip::update_speed_display));
1037 }
1038
1039 void
1040 MixerStrip::update_speed_display ()
1041 {
1042         float val;
1043
1044         val = get_diskstream()->speed();
1045
1046         if (val != 1.0) {
1047                 speed_spinner.set_name ("MixerStripSpeedBaseNotOne");
1048         } else {
1049                 speed_spinner.set_name ("MixerStripSpeedBase");
1050         }
1051
1052         if (speed_adjustment.get_value() != val) {
1053                 ignore_speed_adjustment = true;
1054                 speed_adjustment.set_value (val);
1055                 ignore_speed_adjustment = false;
1056         }
1057 }
1058
1059
1060 void
1061 MixerStrip::set_selected (bool yn)
1062 {
1063         AxisView::set_selected (yn);
1064         if (_selected) {
1065                 global_frame.set_shadow_type (Gtk::SHADOW_ETCHED_OUT);
1066                 global_frame.set_name ("MixerStripSelectedFrame");
1067         } else {
1068                 global_frame.set_shadow_type (Gtk::SHADOW_IN);
1069                 global_frame.set_name ("MixerStripFrame");
1070         }
1071         global_frame.queue_draw ();
1072 }
1073
1074 void
1075 MixerStrip::name_changed (void *src)
1076 {
1077         switch (_width) {
1078         case Wide:
1079                 RouteUI::name_changed (src);
1080                 break;
1081         case Narrow:
1082                 name_label.set_text (PBD::short_version (_route->name(), 5));
1083                 break;
1084         }
1085         if (_route->phase_invert()) {
1086                 name_label.set_text (X_("Ø ") + name_label.get_text());
1087         }
1088 }
1089
1090 void
1091 MixerStrip::width_clicked ()
1092 {
1093         switch (_width) {
1094         case Wide:
1095                 set_width (Narrow);
1096                 break;
1097         case Narrow:
1098                 set_width (Wide);
1099                 break;
1100         }
1101 }
1102
1103 void
1104 MixerStrip::hide_clicked ()
1105 {
1106     // LAME fix to reset the button status for when it is redisplayed (part 1)
1107     hide_button.set_sensitive(false);
1108
1109         if (_embedded) {
1110                  Hiding(); /* EMIT_SIGNAL */
1111         } else {
1112                 _mixer.hide_strip (this);
1113         }
1114
1115     // (part 2)
1116         hide_button.set_sensitive(true);
1117 }
1118
1119 void
1120 MixerStrip::set_embedded (bool yn)
1121 {
1122         _embedded = yn;
1123 }
1124
1125 void
1126 MixerStrip::map_frozen ()
1127 {
1128         ENSURE_GUI_THREAD (mem_fun(*this, &MixerStrip::map_frozen));
1129
1130         AudioTrack* at = audio_track();
1131
1132         if (at) {
1133                 switch (at->freeze_state()) {
1134                 case AudioTrack::Frozen:
1135                         pre_redirect_box.set_sensitive (false);
1136                         post_redirect_box.set_sensitive (false);
1137                         speed_spinner.set_sensitive (false);
1138                         break;
1139                 default:
1140                         pre_redirect_box.set_sensitive (true);
1141                         post_redirect_box.set_sensitive (true);
1142                         speed_spinner.set_sensitive (true);
1143                         break;
1144                 }
1145         }
1146         _route->foreach_redirect (this, &MixerStrip::hide_redirect_editor);
1147 }
1148
1149 void
1150 MixerStrip::hide_redirect_editor (boost::shared_ptr<Redirect> redirect)
1151 {
1152         void* gui = redirect->get_gui ();
1153
1154         if (gui) {
1155                 static_cast<Gtk::Widget*>(gui)->hide ();
1156         }
1157 }
1158
1159 void
1160 MixerStrip::route_active_changed ()
1161 {
1162         RouteUI::route_active_changed ();
1163
1164         if (is_midi_track()) {
1165                 if (_route->active()) {
1166                         set_name ("MidiTrackStripBase");
1167                         gpm.set_meter_strip_name ("MidiTrackStripBase");
1168                 } else {
1169                         set_name ("MidiTrackStripBaseInactive");
1170                         gpm.set_meter_strip_name ("MidiTrackStripBaseInactive");
1171                 }
1172         } else if (is_audio_track()) {
1173                 if (_route->active()) {
1174                         set_name ("AudioTrackStripBase");
1175                         gpm.set_meter_strip_name ("AudioTrackStripBase");
1176                 } else {
1177                         set_name ("AudioTrackStripBaseInactive");
1178                         gpm.set_meter_strip_name ("AudioTrackStripBaseInactive");
1179                 }
1180                 gpm.set_fader_name ("AudioTrackFader");
1181         } else {
1182                 if (_route->active()) {
1183                         set_name ("AudioBusStripBase");
1184                         gpm.set_meter_strip_name ("AudioBusStripBase");
1185                 } else {
1186                         set_name ("AudioBusStripBaseInactive");
1187                         gpm.set_meter_strip_name ("AudioBusStripBaseInactive");
1188                 }
1189                 gpm.set_fader_name ("AudioBusFader");
1190         }
1191 }
1192
1193 RouteGroup*
1194 MixerStrip::mix_group() const
1195 {
1196         return _route->mix_group();
1197 }
1198
1199 void
1200 MixerStrip::engine_stopped ()
1201 {
1202 }
1203
1204 void
1205 MixerStrip::engine_running ()
1206 {
1207 }
1208
1209 void
1210 MixerStrip::meter_changed (void *src)
1211 {
1212
1213         ENSURE_GUI_THREAD (bind (mem_fun(*this, &MixerStrip::meter_changed), src));
1214
1215                 switch (_route->meter_point()) {
1216                 case MeterInput:
1217                         meter_point_label.set_text (_("input"));
1218                         break;
1219
1220                 case MeterPreFader:
1221                         meter_point_label.set_text (_("pre"));
1222                         break;
1223
1224                 case MeterPostFader:
1225                         meter_point_label.set_text (_("post"));
1226                         break;
1227                 }
1228
1229                 gpm.setup_meters ();
1230 }
1231