gtk2_ardour/route_ui.cc

   1 /*
   2     Copyright (C) 2002-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
  20 #include <gtkmm2ext/gtk_ui.h>
  21 #include <gtkmm2ext/stop_signal.h>
  22 #include <gtkmm2ext/choice.h>
  23 #include <gtkmm2ext/doi.h>
  24 #include <gtkmm2ext/bindable_button.h>
  25 #include <gtkmm2ext/barcontroller.h>
  26 #include <gtkmm2ext/gtk_ui.h>
  27
  28 #include "ardour/route_group.h"
  29 #include "ardour/dB.h"
  30 #include "pbd/memento_command.h"
  31 #include "pbd/stacktrace.h"
  32 #include "pbd/controllable.h"
  33 #include "pbd/enumwriter.h"
  34
  35 #include "ardour_ui.h"
  36 #include "editor.h"
  37 #include "route_ui.h"
  38 #include "keyboard.h"
  39 #include "utils.h"
  40 #include "prompter.h"
  41 #include "gui_thread.h"
  42 #include "ardour_dialog.h"
  43 #include "latency_gui.h"
  44 #include "mixer_strip.h"
  45 #include "automation_time_axis.h"
  46 #include "route_time_axis.h"
  47
  48 #include "ardour/route.h"
  49 #include "ardour/event_type_map.h"
  50 #include "ardour/session.h"
  51 #include "ardour/audioengine.h"
  52 #include "ardour/audio_track.h"
  53 #include "ardour/audio_diskstream.h"
  54 #include "ardour/midi_track.h"
  55 #include "ardour/midi_diskstream.h"
  56 #include "ardour/template_utils.h"
  57 #include "ardour/filename_extensions.h"
  58 #include "ardour/directory_names.h"
  59 #include "ardour/profile.h"
  60
  61 #include "i18n.h"
  62 using namespace Gtk;
  63 using namespace Gtkmm2ext;
  64 using namespace ARDOUR;
  65 using namespace PBD;
  66
  67 RouteUI::RouteUI (ARDOUR::Session* sess)
  68         : AxisView(sess)
  69 {
  70         init ();
  71 }
  72
  73 RouteUI::RouteUI (boost::shared_ptr<ARDOUR::Route> rt, ARDOUR::Session* sess)
  74         : AxisView(sess)
  75 {
  76         init ();
  77         set_route (rt);
  78 }
  79
  80 RouteUI::~RouteUI()
  81 {
  82         _route.reset (); /* drop reference to route, so that it can be cleaned up */
  83         route_connections.drop_connections ();
  84
  85         delete solo_menu;
  86         delete mute_menu;
  87         delete sends_menu;
  88 }
  89
  90 void
  91 RouteUI::init ()
  92 {
  93         self_destruct = true;
  94         xml_node = 0;
  95         mute_menu = 0;
  96         solo_menu = 0;
  97         sends_menu = 0;
  98         pre_fader_mute_check = 0;
  99         post_fader_mute_check = 0;
 100         listen_mute_check = 0;
 101         main_mute_check = 0;
 102         ignore_toggle = false;
 103         _solo_release = 0;
 104         _mute_release = 0;
 105         route_active_menu_item = 0;
 106         polarity_menu_item = 0;
 107         denormal_menu_item = 0;
 108         multiple_mute_change = false;
 109         multiple_solo_change = false;
 110
 111         mute_button = manage (new BindableToggleButton ());
 112         mute_button->set_self_managed (true);
 113         mute_button->set_name ("MuteButton");
 114         mute_button->add (mute_button_label);
 115         mute_button_label.show ();
 116         UI::instance()->set_tip (mute_button, _("Mute this track"), "");
 117
 118         solo_button = manage (new BindableToggleButton ());
 119         solo_button->set_self_managed (true);
 120         solo_button->set_name ("SoloButton");
 121         solo_button->add (solo_button_label);
 122         solo_button_label.show ();
 123         UI::instance()->set_tip (solo_button, _("Mute other (non-soloed) tracks"), "");
 124         solo_button->set_no_show_all (true);
 125
 126         rec_enable_button = manage (new BindableToggleButton ());
 127         rec_enable_button->set_name ("RecordEnableButton");
 128         rec_enable_button->set_self_managed (true);
 129         rec_enable_button->add (rec_enable_button_label);
 130         rec_enable_button_label.show ();
 131         UI::instance()->set_tip (rec_enable_button, _("Enable recording on this track"), "");
 132
 133         show_sends_button = manage (new BindableToggleButton (""));
 134         show_sends_button->set_name ("SendAlert");
 135         show_sends_button->set_self_managed (true);
 136         UI::instance()->set_tip (show_sends_button, _("make mixer strips show sends to this bus"), "");
 137
 138         _session->SoloChanged.connect (_session_connections, boost::bind (&RouteUI::solo_changed_so_update_mute, this), gui_context());
 139         _session->TransportStateChange.connect (_session_connections, boost::bind (&RouteUI::check_rec_enable_sensitivity, this), gui_context());
 140         _session->RecordStateChanged.connect (_session_connections, boost::bind (&RouteUI::session_rec_enable_changed, this), gui_context());
 141
 142         Config->ParameterChanged.connect (*this, ui_bind (&RouteUI::parameter_changed, this, _1), gui_context());
 143
 144         rec_enable_button->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::rec_enable_press), false);
 145         rec_enable_button->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::rec_enable_release), false);
 146
 147         show_sends_button->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::show_sends_press), false);
 148         show_sends_button->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::show_sends_release));
 149
 150         solo_button->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::solo_press), false);
 151         solo_button->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::solo_release), false);
 152         mute_button->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::mute_press), false);
 153         mute_button->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::mute_release), false);
 154 }
 155
 156 void
 157 RouteUI::reset ()
 158 {
 159         route_connections.drop_connections ();
 160
 161         delete solo_menu;
 162         solo_menu = 0;
 163
 164         delete mute_menu;
 165         mute_menu = 0;
 166
 167         if (xml_node) {
 168                 /* do not delete the node - its owned by the route */
 169                 xml_node = 0;
 170         }
 171
 172         route_active_menu_item = 0;
 173         polarity_menu_item = 0;
 174         denormal_menu_item = 0;
 175 }
 176
 177 void
 178 RouteUI::self_delete ()
 179 {
 180         /* This may be called from a non-GUI thread. Keep it safe */
 181
 182         delete_when_idle (this);
 183 }
 184
 185 void
 186 RouteUI::set_route (boost::shared_ptr<Route> rp)
 187 {
 188         reset ();
 189
 190         _route = rp;
 191
 192         if (set_color_from_route()) {
 193                 set_color (unique_random_color());
 194         }
 195
 196         if (self_destruct) {
 197                 rp->DropReferences.connect (route_connections, boost::bind (&RouteUI::self_delete, this), gui_context());
 198         }
 199
 200         mute_button->set_controllable (_route->mute_control());
 201         solo_button->set_controllable (_route->solo_control());
 202
 203         _route->active_changed.connect (route_connections, boost::bind (&RouteUI::route_active_changed, this), gui_context());
 204         _route->mute_changed.connect (route_connections, ui_bind (&RouteUI::mute_changed, this, _1), gui_context());
 205         _route->solo_changed.connect (route_connections, ui_bind (&RouteUI::solo_changed, this, _1), gui_context());
 206         _route->listen_changed.connect (route_connections, ui_bind (&RouteUI::listen_changed, this, _1), gui_context());
 207         _route->solo_isolated_changed.connect (route_connections, ui_bind (&RouteUI::solo_changed, this, _1), gui_context());
 208         _route->PropertyChanged.connect (route_connections, ui_bind (&RouteUI::property_changed, this, _1), gui_context());
 209
 210         if (_session->writable() && is_track()) {
 211                 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track>(_route);
 212
 213                 t->diskstream()->RecordEnableChanged.connect (route_connections, boost::bind (&RouteUI::route_rec_enable_changed, this), gui_context());
 214
 215                 rec_enable_button->show();
 216                 rec_enable_button->set_controllable (t->rec_enable_control());
 217
 218                 update_rec_display ();
 219         }
 220
 221         mute_button->unset_flags (Gtk::CAN_FOCUS);
 222         solo_button->unset_flags (Gtk::CAN_FOCUS);
 223
 224         mute_button->show();
 225
 226         if (_route->is_monitor()) {
 227                 solo_button->hide ();
 228         } else {
 229                 solo_button->show();
 230         }
 231
 232         /* map the current state */
 233
 234         mute_changed (0);
 235         solo_changed (0);
 236
 237         map_frozen ();
 238 }
 239
 240 bool
 241 RouteUI::mute_press (GdkEventButton* ev)
 242 {
 243         if (ev->type == GDK_2BUTTON_PRESS || ev->type == GDK_3BUTTON_PRESS ) {
 244                 return true;
 245         }
 246
 247         multiple_mute_change = false;
 248
 249         if (!ignore_toggle) {
 250
 251                 if (Keyboard::is_context_menu_event (ev)) {
 252
 253                         if (mute_menu == 0){
 254                                 build_mute_menu();
 255                         }
 256
 257                         mute_menu->popup(0,ev->time);
 258
 259                 } else {
 260
 261                         if (Keyboard::is_button2_event (ev)) {
 262                                 // Primary-button2 click is the midi binding click
 263                                 // button2-click is "momentary"
 264
 265
 266                                 if (mute_button->on_button_press_event (ev)) {
 267                                         return true;
 268                                 }
 269
 270                                 _mute_release = new SoloMuteRelease (_route->muted ());
 271                         }
 272
 273                         if (ev->button == 1 || Keyboard::is_button2_event (ev)) {
 274
 275                                 if (Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier))) {
 276
 277                                         if (_mute_release) {
 278                                                 _mute_release->routes = _session->get_routes ();
 279                                         }
 280
 281                                         _session->set_mute (_session->get_routes(), !_route->muted());
 282
 283                                 } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
 284
 285                                         /* Primary-button1 applies change to the mix group even if it is not active
 286                                            NOTE: Primary-button2 is MIDI learn.
 287                                         */
 288
 289                                         if (ev->button == 1 && _route->route_group()) {
 290                                                 if (_mute_release) {
 291                                                         _mute_release->routes = _session->get_routes ();
 292                                                 }
 293
 294                                                 _session->set_mute (_session->get_routes(), !_route->muted(), Session::rt_cleanup, true);
 295                                         }
 296
 297                                 } else {
 298
 299                                         /* plain click applies change to this route */
 300
 301                                         boost::shared_ptr<RouteList> rl (new RouteList);
 302                                         rl->push_back (_route);
 303
 304                                         if (_mute_release) {
 305                                                 _mute_release->routes = rl;
 306                                         }
 307
 308                                         _session->set_mute (rl, !_route->muted());
 309
 310                                 }
 311                         }
 312                 }
 313
 314         }
 315
 316         return true;
 317 }
 318
 319 bool
 320 RouteUI::mute_release (GdkEventButton*)
 321 {
 322         if (!ignore_toggle) {
 323                 if (_mute_release){
 324                         _session->set_mute (_mute_release->routes, _mute_release->active, Session::rt_cleanup, true);
 325                         delete _mute_release;
 326                         _mute_release = 0;
 327                 }
 328         }
 329
 330         return true;
 331 }
 332
 333 bool
 334 RouteUI::solo_press(GdkEventButton* ev)
 335 {
 336         /* ignore double/triple clicks */
 337
 338         if (ev->type == GDK_2BUTTON_PRESS || ev->type == GDK_3BUTTON_PRESS ) {
 339                 return true;
 340         }
 341
 342         multiple_solo_change = false;
 343
 344         if (!ignore_toggle) {
 345
 346                 if (Keyboard::is_context_menu_event (ev)) {
 347
 348                         if (solo_menu == 0) {
 349                                 build_solo_menu ();
 350                         }
 351
 352                         solo_menu->popup (1, ev->time);
 353
 354                 } else {
 355
 356                         if (Keyboard::is_button2_event (ev)) {
 357
 358                                 // Primary-button2 click is the midi binding click
 359                                 // button2-click is "momentary"
 360
 361                                 if (solo_button->on_button_press_event (ev)) {
 362                                         return true;
 363                                 }
 364
 365                                 _solo_release = new SoloMuteRelease (_route->soloed());
 366                         }
 367
 368                         if (ev->button == 1 || Keyboard::is_button2_event (ev)) {
 369
 370                                 if (Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier))) {
 371
 372                                         /* Primary-Tertiary-click applies change to all routes */
 373
 374                                         if (_solo_release) {
 375                                                 _solo_release->routes = _session->get_routes ();
 376                                         }
 377
 378                                         if (Config->get_solo_control_is_listen_control()) {
 379                                                 _session->set_listen (_session->get_routes(), !_route->listening(),  Session::rt_cleanup, true);
 380                                         } else {
 381                                                 _session->set_solo (_session->get_routes(), !_route->soloed(),  Session::rt_cleanup, true);
 382                                         }
 383
 384                                 } else if (Keyboard::modifier_state_contains (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::SecondaryModifier))) {
 385
 386                                         // Primary-Secondary-click: exclusively solo this track
 387
 388                                         if (_solo_release) {
 389                                                 _solo_release->exclusive = true;
 390
 391                                                 boost::shared_ptr<RouteList> routes = _session->get_routes();
 392
 393                                                 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
 394                                                         if ((*i)->soloed ()) {
 395                                                                 _solo_release->routes_on->push_back (*i);
 396                                                         } else {
 397                                                                 _solo_release->routes_off->push_back (*i);
 398                                                         }
 399                                                 }
 400                                         }
 401
 402                                         if (Config->get_solo_control_is_listen_control()) {
 403                                                 /* ??? we need a just_one_listen() method */
 404                                         } else {
 405                                                 _session->set_just_one_solo (_route, true);
 406                                         }
 407
 408                                 } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
 409
 410                                         // shift-click: toggle solo isolated status
 411
 412                                         _route->set_solo_isolated (!_route->solo_isolated(), this);
 413                                         delete _solo_release;
 414                                         _solo_release = 0;
 415
 416                                 } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
 417
 418                                         /* Primary-button1: solo mix group.
 419                                            NOTE: Primary-button2 is MIDI learn.
 420                                         */
 421
 422                                         if (ev->button == 1 && _route->route_group()) {
 423
 424                                                 if (_solo_release) {
 425                                                         _solo_release->routes = _route->route_group()->route_list();
 426                                                 }
 427
 428                                                 if (Config->get_solo_control_is_listen_control()) {
 429                                                         _session->set_listen (_route->route_group()->route_list(), !_route->listening(),  Session::rt_cleanup, true);
 430                                                 } else {
 431                                                         _session->set_solo (_route->route_group()->route_list(), !_route->soloed(),  Session::rt_cleanup, true);
 432                                                 }
 433                                         }
 434
 435                                 } else {
 436
 437                                         /* click: solo this route */
 438
 439                                         boost::shared_ptr<RouteList> rl (new RouteList);
 440                                         rl->push_back (route());
 441
 442                                         if (_solo_release) {
 443                                                 _solo_release->routes = rl;
 444                                         }
 445
 446                                         if (Config->get_solo_control_is_listen_control()) {
 447                                                 _session->set_listen (rl, !_route->listening());
 448                                         } else {
 449                                                 _session->set_solo (rl, !_route->soloed());
 450                                         }
 451                                 }
 452                         }
 453                 }
 454         }
 455
 456         return true;
 457 }
 458
 459 bool
 460 RouteUI::solo_release (GdkEventButton*)
 461 {
 462         if (!ignore_toggle) {
 463
 464                 if (_solo_release) {
 465
 466                         if (_solo_release->exclusive) {
 467
 468                         } else {
 469                                 if (Config->get_solo_control_is_listen_control()) {
 470                                         _session->set_listen (_solo_release->routes, _solo_release->active, Session::rt_cleanup, true);
 471                                 } else {
 472                                         _session->set_solo (_solo_release->routes, _solo_release->active, Session::rt_cleanup, true);
 473                                 }
 474                         }
 475
 476                         delete _solo_release;
 477                         _solo_release = 0;
 478                 }
 479         }
 480
 481         return true;
 482 }
 483
 484 bool
 485 RouteUI::rec_enable_press(GdkEventButton* ev)
 486 {
 487         if (ev->type == GDK_2BUTTON_PRESS || ev->type == GDK_3BUTTON_PRESS ) {
 488                 return true;
 489         }
 490
 491         if (!_session->engine().connected()) {
 492                 MessageDialog msg (_("Not connected to JACK - cannot engage record"));
 493                 msg.run ();
 494                 return true;
 495         }
 496
 497         if (!ignore_toggle && is_track() && rec_enable_button) {
 498
 499                 if (Keyboard::is_button2_event (ev)) {
 500
 501                         // do nothing on midi sigc::bind event
 502                         return rec_enable_button->on_button_press_event (ev);
 503
 504                 } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier))) {
 505
 506                         _session->set_record_enable (_session->get_routes(), !rec_enable_button->get_active());
 507
 508                 } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
 509
 510                         /* Primary-button1 applies change to the route group (even if it is not active)
 511                            NOTE: Primary-button2 is MIDI learn.
 512                         */
 513                         if (ev->button == 1 && _route->route_group()) {
 514                                 _session->set_record_enable (_route->route_group()->route_list(), !rec_enable_button->get_active(), Session::rt_cleanup, true);
 515                         }
 516
 517                 } else if (Keyboard::is_context_menu_event (ev)) {
 518
 519                         /* do this on release */
 520
 521                 } else {
 522
 523                         boost::shared_ptr<RouteList> rl (new RouteList);
 524                         rl->push_back (route());
 525                         _session->set_record_enable (rl, !rec_enable_button->get_active());
 526                 }
 527         }
 528
 529         return true;
 530 }
 531
 532 bool
 533 RouteUI::rec_enable_release (GdkEventButton*)
 534 {
 535         return true;
 536 }
 537
 538 void
 539 RouteUI::build_sends_menu ()
 540 {
 541         using namespace Menu_Helpers;
 542
 543         sends_menu = new Menu;
 544         sends_menu->set_name ("ArdourContextMenu");
 545         MenuList& items = sends_menu->items();
 546
 547         items.push_back (MenuElem(_("Assign all tracks (prefader)"), sigc::bind (sigc::mem_fun (*this, &RouteUI::create_sends), PreFader)));
 548         items.push_back (MenuElem(_("Assign all tracks (postfader)"), sigc::bind (sigc::mem_fun (*this, &RouteUI::create_sends), PostFader)));
 549         items.push_back (MenuElem(_("Assign selected tracks (prefader)"), sigc::bind (sigc::mem_fun (*this, &RouteUI::create_selected_sends), PreFader)));
 550         items.push_back (MenuElem(_("Assign selected tracks (postfader)"), sigc::bind (sigc::mem_fun (*this, &RouteUI::create_selected_sends), PostFader)));
 551         items.push_back (MenuElem(_("Copy track gains to sends"), sigc::mem_fun (*this, &RouteUI::set_sends_gain_from_track)));
 552         items.push_back (MenuElem(_("Set sends gain to -inf"), sigc::mem_fun (*this, &RouteUI::set_sends_gain_to_zero)));
 553         items.push_back (MenuElem(_("Set sends gain to 0dB"), sigc::mem_fun (*this, &RouteUI::set_sends_gain_to_unity)));
 554
 555 }
 556
 557 void
 558 RouteUI::create_sends (Placement p)
 559 {
 560         _session->globally_add_internal_sends (_route, p);
 561 }
 562
 563 void
 564 RouteUI::create_selected_sends (Placement p)
 565 {
 566         boost::shared_ptr<RouteList> rlist (new RouteList);
 567         TrackSelection& selected_tracks (ARDOUR_UI::instance()->the_editor().get_selection().tracks);
 568
 569         for (TrackSelection::iterator i = selected_tracks.begin(); i != selected_tracks.end(); ++i) {
 570                 RouteTimeAxisView* rtv;
 571                 RouteUI* rui;
 572                 if ((rtv = dynamic_cast<RouteTimeAxisView*>(*i)) != 0) {
 573                         if ((rui = dynamic_cast<RouteUI*>(rtv)) != 0) {
 574                                 if (boost::dynamic_pointer_cast<AudioTrack>(rui->route())) {
 575                                         rlist->push_back (rui->route());
 576                                 }
 577                         }
 578                 }
 579         }
 580
 581         _session->add_internal_sends (_route, p, rlist);
 582 }
 583
 584 void
 585 RouteUI::set_sends_gain_from_track ()
 586 {
 587         _session->globally_set_send_gains_from_track (_route);
 588 }
 589
 590 void
 591 RouteUI::set_sends_gain_to_zero ()
 592 {
 593         _session->globally_set_send_gains_to_zero (_route);
 594 }
 595
 596 void
 597 RouteUI::set_sends_gain_to_unity ()
 598 {
 599         _session->globally_set_send_gains_to_unity (_route);
 600 }
 601
 602 bool
 603 RouteUI::show_sends_press(GdkEventButton* ev)
 604 {
 605         if (ev->type == GDK_2BUTTON_PRESS || ev->type == GDK_3BUTTON_PRESS ) {
 606                 return true;
 607         }
 608
 609         if (!ignore_toggle && !is_track() && show_sends_button) {
 610
 611                 if (Keyboard::is_button2_event (ev) && Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
 612
 613                         // do nothing on midi sigc::bind event
 614                         return false;
 615
 616                 } else if (Keyboard::is_context_menu_event (ev)) {
 617
 618                         if (sends_menu == 0) {
 619                                 build_sends_menu ();
 620                         }
 621
 622                         sends_menu->popup (0, ev->time);
 623
 624                 } else {
 625
 626                         /* change button state */
 627
 628                         show_sends_button->set_active (!show_sends_button->get_active());
 629
 630                         /* start blinking */
 631
 632                         if (show_sends_button->get_active()) {
 633                                 /* show sends to this bus */
 634                                 MixerStrip::SwitchIO (_route);
 635                                 send_blink_connection = ARDOUR_UI::instance()->Blink.connect (sigc::mem_fun(*this, &RouteUI::send_blink));
 636                         } else {
 637                                 /* everybody back to normal */
 638                                 send_blink_connection.disconnect ();
 639                                 MixerStrip::SwitchIO (boost::shared_ptr<Route>());
 640                         }
 641
 642                 }
 643         }
 644
 645         return true;
 646 }
 647
 648 bool
 649 RouteUI::show_sends_release (GdkEventButton*)
 650 {
 651         return true;
 652 }
 653
 654 void
 655 RouteUI::send_blink (bool onoff)
 656 {
 657         if (!show_sends_button) {
 658                 return;
 659         }
 660
 661         if (onoff) {
 662                 show_sends_button->set_state (STATE_ACTIVE);
 663         } else {
 664                 show_sends_button->set_state (STATE_NORMAL);
 665         }
 666 }
 667
 668 void
 669 RouteUI::solo_changed(void* /*src*/)
 670 {
 671         Gtkmm2ext::UI::instance()->call_slot (boost::bind (&RouteUI::update_solo_display, this));
 672 }
 673
 674
 675 void
 676 RouteUI::listen_changed(void* /*src*/)
 677 {
 678         Gtkmm2ext::UI::instance()->call_slot (boost::bind (&RouteUI::update_solo_display, this));
 679 }
 680
 681 int
 682 RouteUI::solo_visual_state (boost::shared_ptr<Route> r)
 683 {
 684         if (r->is_master() || r->is_monitor()) {
 685                 return 0;
 686         }
 687
 688         if (Config->get_solo_control_is_listen_control()) {
 689
 690                 if (r->listening()) {
 691                         return 1;
 692                 } else {
 693                         return 0;
 694                 }
 695
 696         }
 697
 698         if (r->soloed()) {
 699                 return 1;
 700         } else {
 701                 return 0;
 702         }
 703 }
 704
 705 int
 706 RouteUI::solo_visual_state_with_isolate (boost::shared_ptr<Route> r)
 707 {
 708         if (r->is_master() || r->is_monitor()) {
 709                 return 0;
 710         }
 711
 712         if (Config->get_solo_control_is_listen_control()) {
 713
 714                 if (r->listening()) {
 715                         return 1;
 716                 } else {
 717                         return 0;
 718                 }
 719
 720         }
 721
 722         if (r->solo_isolated()) {
 723                 return 2;
 724         } else if (r->soloed()) {
 725                 return 1;
 726         } else {
 727                 return 0;
 728         }
 729 }
 730
 731 int
 732 RouteUI::solo_isolate_visual_state (boost::shared_ptr<Route> r)
 733 {
 734         if (r->is_master() || r->is_monitor()) {
 735                 return 0;
 736         }
 737
 738         if (r->solo_isolated()) {
 739                         return 1;
 740         } else {
 741                 return 0;
 742         }
 743 }
 744
 745 void
 746 RouteUI::update_solo_display ()
 747 {
 748         bool x;
 749
 750         if (Config->get_solo_control_is_listen_control()) {
 751
 752                 if (solo_button->get_active() != (x = _route->listening())) {
 753                         ignore_toggle = true;
 754                         solo_button->set_active(x);
 755                         ignore_toggle = false;
 756                 }
 757
 758         } else {
 759
 760                 if (solo_button->get_active() != (x = _route->soloed())) {
 761                         ignore_toggle = true;
 762                         solo_button->set_active (x);
 763                         ignore_toggle = false;
 764                 }
 765
 766         }
 767
 768         solo_button->set_visual_state (solo_visual_state_with_isolate (_route));
 769 }
 770
 771 void
 772 RouteUI::solo_changed_so_update_mute ()
 773 {
 774         update_mute_display ();
 775 }
 776
 777 void
 778 RouteUI::mute_changed(void* /*src*/)
 779 {
 780         update_mute_display ();
 781 }
 782
 783 int
 784 RouteUI::mute_visual_state (Session* s, boost::shared_ptr<Route> r)
 785 {
 786         if (r->is_master() || r->is_monitor()) {
 787                 return 0;
 788         }
 789
 790         if (Config->get_show_solo_mutes()) {
 791
 792                 if (r->muted ()) {
 793                         /* full mute */
 794                         return 2;
 795                 } else if (s->soloing() && !r->soloed() && !r->solo_isolated()) {
 796                         /* mute-because-not-soloed */
 797                         return 1;
 798                 } else {
 799                         /* no mute at all */
 800                         return 0;
 801                 }
 802
 803         } else {
 804
 805                 if (r->muted()) {
 806                         /* full mute */
 807                         return 2;
 808                 } else {
 809                         /* no mute at all */
 810                         return 0;
 811                 }
 812         }
 813
 814         return 0;
 815 }
 816
 817 void
 818 RouteUI::update_mute_display ()
 819 {
 820         if (!_route) {
 821                 return;
 822         }
 823
 824         bool model = _route->muted();
 825         bool view = mute_button->get_active();
 826
 827         /* first make sure the button's "depressed" visual
 828            is correct.
 829         */
 830
 831         if (model != view) {
 832                 ignore_toggle = true;
 833                 mute_button->set_active (model);
 834                 ignore_toggle = false;
 835         }
 836
 837         mute_button->set_visual_state (mute_visual_state (_session, _route));
 838 }
 839
 840 void
 841 RouteUI::route_rec_enable_changed ()
 842 {
 843         Gtkmm2ext::UI::instance()->call_slot (boost::bind (&RouteUI::update_rec_display, this));
 844 }
 845
 846 void
 847 RouteUI::session_rec_enable_changed ()
 848 {
 849         update_rec_display ();
 850 }
 851
 852 void
 853 RouteUI::update_rec_display ()
 854 {
 855         if (!rec_enable_button || !_route) {
 856                 return;
 857         }
 858
 859         bool model = _route->record_enabled();
 860         bool view = rec_enable_button->get_active();
 861
 862         /* first make sure the button's "depressed" visual
 863            is correct.
 864         */
 865
 866         if (model != view) {
 867                 ignore_toggle = true;
 868                 rec_enable_button->set_active (model);
 869                 ignore_toggle = false;
 870         }
 871
 872         /* now make sure its color state is correct */
 873
 874         if (model) {
 875
 876                 switch (_session->record_status ()) {
 877                 case Session::Recording:
 878                         rec_enable_button->set_visual_state (1);
 879                         break;
 880
 881                 case Session::Disabled:
 882                 case Session::Enabled:
 883                         rec_enable_button->set_visual_state (2);
 884                         break;
 885
 886                 }
 887
 888         } else {
 889                 rec_enable_button->set_visual_state (0);
 890         }
 891
 892         check_rec_enable_sensitivity ();
 893 }
 894
 895 void
 896 RouteUI::build_solo_menu (void)
 897 {
 898         using namespace Menu_Helpers;
 899
 900         solo_menu = new Menu;
 901         solo_menu->set_name ("ArdourContextMenu");
 902         MenuList& items = solo_menu->items();
 903         CheckMenuItem* check;
 904
 905         check = new CheckMenuItem(_("Solo Isolate"));
 906         check->set_active (_route->solo_isolated());
 907         check->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_solo_isolated), check));
 908         _route->solo_isolated_changed.connect (route_connections, ui_bind (&RouteUI::solo_isolated_toggle, this, _1, check), gui_context());
 909         items.push_back (CheckMenuElem(*check));
 910         check->show_all();
 911
 912         check = new CheckMenuItem(_("Solo Safe"));
 913         check->set_active (_route->solo_safe());
 914         check->signal_toggled().connect (sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_solo_safe), check));
 915         _route->solo_safe_changed.connect (route_connections, ui_bind (&RouteUI::solo_safe_toggle, this, _1, check), gui_context());
 916         items.push_back (CheckMenuElem(*check));
 917         check->show_all();
 918
 919         //items.push_back (SeparatorElem());
 920         // items.push_back (MenuElem (_("MIDI Bind"), sigc::mem_fun (*mute_button, &BindableToggleButton::midi_learn)));
 921
 922 }
 923
 924 void
 925 RouteUI::build_mute_menu(void)
 926 {
 927         using namespace Menu_Helpers;
 928
 929         mute_menu = new Menu;
 930         mute_menu->set_name ("ArdourContextMenu");
 931
 932         MenuList& items = mute_menu->items();
 933
 934         pre_fader_mute_check = manage (new CheckMenuItem(_("Pre Fader")));
 935         init_mute_menu(MuteMaster::PreFader, pre_fader_mute_check);
 936         pre_fader_mute_check->signal_toggled().connect(sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_mute_menu), MuteMaster::PreFader, pre_fader_mute_check));
 937         items.push_back (CheckMenuElem(*pre_fader_mute_check));
 938         pre_fader_mute_check->show_all();
 939
 940         post_fader_mute_check = manage (new CheckMenuItem(_("Post Fader")));
 941         init_mute_menu(MuteMaster::PostFader, post_fader_mute_check);
 942         post_fader_mute_check->signal_toggled().connect(sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_mute_menu), MuteMaster::PostFader, post_fader_mute_check));
 943         items.push_back (CheckMenuElem(*post_fader_mute_check));
 944         post_fader_mute_check->show_all();
 945
 946         listen_mute_check = manage (new CheckMenuItem(_("Control Outs")));
 947         init_mute_menu(MuteMaster::Listen, listen_mute_check);
 948         listen_mute_check->signal_toggled().connect(sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_mute_menu), MuteMaster::Listen, listen_mute_check));
 949         items.push_back (CheckMenuElem(*listen_mute_check));
 950         listen_mute_check->show_all();
 951
 952         main_mute_check = manage (new CheckMenuItem(_("Main Outs")));
 953         init_mute_menu(MuteMaster::Main, main_mute_check);
 954         main_mute_check->signal_toggled().connect(sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_mute_menu), MuteMaster::Main, main_mute_check));
 955         items.push_back (CheckMenuElem(*main_mute_check));
 956         main_mute_check->show_all();
 957
 958         //items.push_back (SeparatorElem());
 959         // items.push_back (MenuElem (_("MIDI Bind"), sigc::mem_fun (*mute_button, &BindableToggleButton::midi_learn)));
 960
 961         _route->mute_points_changed.connect (route_connections, boost::bind (&RouteUI::muting_change, this), gui_context());
 962 }
 963
 964 void
 965 RouteUI::init_mute_menu(MuteMaster::MutePoint mp, CheckMenuItem* check)
 966 {
 967         check->set_active (_route->mute_points() & mp);
 968 }
 969
 970 void
 971 RouteUI::toggle_mute_menu(MuteMaster::MutePoint mp, Gtk::CheckMenuItem* check)
 972 {
 973         if (check->get_active()) {
 974                 _route->set_mute_points (MuteMaster::MutePoint (_route->mute_points() | mp));
 975         } else {
 976                 _route->set_mute_points (MuteMaster::MutePoint (_route->mute_points() & ~mp));
 977         }
 978 }
 979
 980 void
 981 RouteUI::muting_change ()
 982 {
 983         ENSURE_GUI_THREAD (*this, &RouteUI::muting_change)
 984
 985         bool yn;
 986         MuteMaster::MutePoint current = _route->mute_points ();
 987
 988         yn = (current & MuteMaster::PreFader);
 989
 990         if (pre_fader_mute_check->get_active() != yn) {
 991                 pre_fader_mute_check->set_active (yn);
 992         }
 993
 994         yn = (current & MuteMaster::PostFader);
 995
 996         if (post_fader_mute_check->get_active() != yn) {
 997                 post_fader_mute_check->set_active (yn);
 998         }
 999
1000         yn = (current & MuteMaster::Listen);
1001
1002         if (listen_mute_check->get_active() != yn) {
1003                 listen_mute_check->set_active (yn);
1004         }
1005
1006         yn = (current & MuteMaster::Main);
1007
1008         if (main_mute_check->get_active() != yn) {
1009                 main_mute_check->set_active (yn);
1010         }
1011 }
1012
1013 void
1014 RouteUI::toggle_solo_isolated (Gtk::CheckMenuItem* check)
1015 {
1016         _route->set_solo_isolated (check->get_active(), this);
1017 }
1018
1019 void
1020 RouteUI::toggle_solo_safe (Gtk::CheckMenuItem* check)
1021 {
1022         _route->set_solo_safe (check->get_active(), this);
1023 }
1024
1025 bool
1026 RouteUI::choose_color()
1027 {
1028         bool picked;
1029         Gdk::Color color;
1030
1031         color = Gtkmm2ext::UI::instance()->get_color (_("ardour: color selection"), picked, &_color);
1032
1033         if (picked) {
1034                 set_color (color);
1035         }
1036
1037         return picked;
1038 }
1039
1040 void
1041 RouteUI::set_color (const Gdk::Color & c)
1042 {
1043         char buf[64];
1044
1045         _color = c;
1046
1047         ensure_xml_node ();
1048         snprintf (buf, sizeof (buf), "%d:%d:%d", c.get_red(), c.get_green(), c.get_blue());
1049         xml_node->add_property ("color", buf);
1050
1051         _route->gui_changed ("color", (void *) 0); /* EMIT_SIGNAL */
1052 }
1053
1054
1055 void
1056 RouteUI::ensure_xml_node ()
1057 {
1058         if (xml_node == 0) {
1059                 if ((xml_node = _route->extra_xml ("GUI")) == 0) {
1060                         xml_node = new XMLNode ("GUI");
1061                         _route->add_extra_xml (*xml_node);
1062                 }
1063         }
1064 }
1065
1066 XMLNode*
1067 RouteUI::get_automation_child_xml_node (Evoral::Parameter param)
1068 {
1069         ensure_xml_node ();
1070
1071         XMLNodeList kids = xml_node->children();
1072         XMLNodeConstIterator iter;
1073
1074         const string sym = ARDOUR::EventTypeMap::instance().to_symbol(param);
1075
1076         for (iter = kids.begin(); iter != kids.end(); ++iter) {
1077                 if ((*iter)->name() == AutomationTimeAxisView::state_node_name) {
1078                         XMLProperty* type = (*iter)->property("automation-id");
1079                         if (type && type->value() == sym)
1080                                 return *iter;
1081                 }
1082         }
1083
1084         // Didn't find it, make a new one
1085         XMLNode* child = new XMLNode (AutomationTimeAxisView::state_node_name);
1086         child->add_property("automation-id", sym);
1087         xml_node->add_child_nocopy (*child);
1088
1089         return child;
1090 }
1091
1092 int
1093 RouteUI::set_color_from_route ()
1094 {
1095         XMLProperty *prop;
1096
1097         RouteUI::ensure_xml_node ();
1098
1099         if ((prop = xml_node->property ("color")) != 0) {
1100                 int r, g, b;
1101                 sscanf (prop->value().c_str(), "%d:%d:%d", &r, &g, &b);
1102                 _color.set_red(r);
1103                 _color.set_green(g);
1104                 _color.set_blue(b);
1105                 return 0;
1106         }
1107         return 1;
1108 }
1109
1110 void
1111 RouteUI::remove_this_route ()
1112 {
1113         vector<string> choices;
1114         string prompt;
1115
1116         if (is_track()) {
1117                 prompt  = string_compose (_("Do you really want to remove track \"%1\" ?\n\nYou may also lose the playlist used by this track.\n(this cannot be undone)"), _route->name());
1118         } else {
1119                 prompt  = string_compose (_("Do you really want to remove bus \"%1\" ?\n(this cannot be undone)"), _route->name());
1120         }
1121
1122         choices.push_back (_("No, do nothing."));
1123         choices.push_back (_("Yes, remove it."));
1124
1125         string title;
1126         if (is_track()) {
1127                 title = _("Remove track");
1128         } else {
1129                 title = _("Remove bus");
1130         }
1131
1132         Choice prompter (title, prompt, choices);
1133
1134         if (prompter.run () == 1) {
1135                 Glib::signal_idle().connect (sigc::bind (sigc::ptr_fun (&RouteUI::idle_remove_this_route), this));
1136         }
1137 }
1138
1139 gint
1140 RouteUI::idle_remove_this_route (RouteUI *rui)
1141 {
1142         rui->_session->remove_route (rui->_route);
1143         return false;
1144 }
1145
1146 void
1147 RouteUI::route_rename ()
1148 {
1149         ArdourPrompter name_prompter (true);
1150         string result;
1151         name_prompter.set_prompt (_("New Name: "));
1152         name_prompter.set_initial_text (_route->name());
1153         name_prompter.add_button (_("Rename"), Gtk::RESPONSE_ACCEPT);
1154         name_prompter.set_response_sensitive (Gtk::RESPONSE_ACCEPT, false);
1155         name_prompter.show_all ();
1156
1157         switch (name_prompter.run ()) {
1158
1159         case Gtk::RESPONSE_ACCEPT:
1160         name_prompter.get_result (result);
1161         if (result.length()) {
1162                         _route->set_name (result);
1163                 }
1164                 break;
1165         }
1166
1167         return;
1168
1169 }
1170
1171 void
1172 RouteUI::property_changed (const PropertyChange& what_changed)
1173 {
1174         if (what_changed.contains (ARDOUR::Properties::name)) {
1175                 name_label.set_text (_route->name());
1176         }
1177 }
1178
1179 void
1180 RouteUI::toggle_route_active ()
1181 {
1182         bool yn;
1183
1184         if (route_active_menu_item) {
1185                 if (route_active_menu_item->get_active() != (yn = _route->active())) {
1186                         _route->set_active (!yn);
1187                 }
1188         }
1189 }
1190
1191 void
1192 RouteUI::route_active_changed ()
1193 {
1194         if (route_active_menu_item) {
1195                 Gtkmm2ext::UI::instance()->call_slot (boost::bind (&CheckMenuItem::set_active, route_active_menu_item, _route->active()));
1196         }
1197 }
1198
1199 void
1200 RouteUI::toggle_polarity ()
1201 {
1202         if (polarity_menu_item) {
1203
1204                 bool x;
1205
1206                 ENSURE_GUI_THREAD (*this, &RouteUI::toggle_polarity)
1207
1208                 if ((x = polarity_menu_item->get_active()) != _route->phase_invert()) {
1209                         _route->set_phase_invert (x);
1210                         if (x) {
1211                                 name_label.set_text (X_("Ø ") + name_label.get_text());
1212                         } else {
1213                                 name_label.set_text (_route->name());
1214                         }
1215                 }
1216         }
1217 }
1218
1219 void
1220 RouteUI::polarity_changed ()
1221 {
1222         if (_route->phase_invert()) {
1223                 name_label.set_text (X_("Ø ") + name_label.get_text());
1224         } else {
1225                 name_label.set_text (_route->name());
1226         }
1227 }
1228
1229 void
1230 RouteUI::toggle_denormal_protection ()
1231 {
1232         if (denormal_menu_item) {
1233
1234                 bool x;
1235
1236                 ENSURE_GUI_THREAD (*this, &RouteUI::toggle_denormal_protection)
1237
1238                 if ((x = denormal_menu_item->get_active()) != _route->denormal_protection()) {
1239                         _route->set_denormal_protection (x);
1240                 }
1241         }
1242 }
1243
1244 void
1245 RouteUI::denormal_protection_changed ()
1246 {
1247         if (denormal_menu_item) {
1248                 denormal_menu_item->set_active (_route->denormal_protection());
1249         }
1250 }
1251
1252 void
1253 RouteUI::solo_isolated_toggle(void* /*src*/, Gtk::CheckMenuItem* check)
1254 {
1255         bool yn = _route->solo_isolated ();
1256
1257         if (check->get_active() != yn) {
1258                 check->set_active (yn);
1259         }
1260 }
1261
1262
1263 void
1264 RouteUI::solo_safe_toggle(void* /*src*/, Gtk::CheckMenuItem* check)
1265 {
1266         bool yn = _route->solo_safe ();
1267
1268         if (check->get_active() != yn) {
1269                 check->set_active (yn);
1270         }
1271 }
1272
1273 void
1274 RouteUI::disconnect_input ()
1275 {
1276         _route->input()->disconnect (this);
1277 }
1278
1279 void
1280 RouteUI::disconnect_output ()
1281 {
1282         _route->output()->disconnect (this);
1283 }
1284
1285 bool
1286 RouteUI::is_track () const
1287 {
1288         return boost::dynamic_pointer_cast<Track>(_route) != 0;
1289 }
1290
1291 boost::shared_ptr<Track>
1292 RouteUI::track() const
1293 {
1294         return boost::dynamic_pointer_cast<Track>(_route);
1295 }
1296
1297 bool
1298 RouteUI::is_audio_track () const
1299 {
1300         return boost::dynamic_pointer_cast<AudioTrack>(_route) != 0;
1301 }
1302
1303 boost::shared_ptr<AudioTrack>
1304 RouteUI::audio_track() const
1305 {
1306         return boost::dynamic_pointer_cast<AudioTrack>(_route);
1307 }
1308
1309 bool
1310 RouteUI::is_midi_track () const
1311 {
1312         return boost::dynamic_pointer_cast<MidiTrack>(_route) != 0;
1313 }
1314
1315 boost::shared_ptr<MidiTrack>
1316 RouteUI::midi_track() const
1317 {
1318         return boost::dynamic_pointer_cast<MidiTrack>(_route);
1319 }
1320
1321 boost::shared_ptr<Diskstream>
1322 RouteUI::get_diskstream () const
1323 {
1324         boost::shared_ptr<Track> t;
1325
1326         if ((t = boost::dynamic_pointer_cast<Track>(_route)) != 0) {
1327                 return t->diskstream();
1328         } else {
1329                 return boost::shared_ptr<Diskstream> ((Diskstream*) 0);
1330         }
1331 }
1332
1333 string
1334 RouteUI::name() const
1335 {
1336         return _route->name();
1337 }
1338
1339 void
1340 RouteUI::map_frozen ()
1341 {
1342         ENSURE_GUI_THREAD (*this, &RouteUI::map_frozen)
1343
1344         AudioTrack* at = dynamic_cast<AudioTrack*>(_route.get());
1345
1346         if (at) {
1347                 switch (at->freeze_state()) {
1348                 case AudioTrack::Frozen:
1349                         rec_enable_button->set_sensitive (false);
1350                         break;
1351                 default:
1352                         rec_enable_button->set_sensitive (true);
1353                         break;
1354                 }
1355         }
1356 }
1357
1358 void
1359 RouteUI::adjust_latency ()
1360 {
1361         LatencyDialog dialog (_route->name() + _(" latency"), *(_route->output()), _session->frame_rate(), _session->engine().frames_per_cycle());
1362 }
1363
1364 void
1365 RouteUI::save_as_template ()
1366 {
1367         sys::path path;
1368         Glib::ustring safe_name;
1369         string name;
1370
1371         path = ARDOUR::user_route_template_directory ();
1372
1373         if (g_mkdir_with_parents (path.to_string().c_str(), 0755)) {
1374                 error << string_compose (_("Cannot create route template directory %1"), path.to_string()) << endmsg;
1375                 return;
1376         }
1377
1378         Prompter p (true); // modal
1379
1380         p.set_prompt (_("Template name:"));
1381         switch (p.run()) {
1382         case RESPONSE_ACCEPT:
1383                 break;
1384         default:
1385                 return;
1386         }
1387
1388         p.hide ();
1389         p.get_result (name, true);
1390
1391         safe_name = legalize_for_path (name);
1392         safe_name += template_suffix;
1393
1394         path /= safe_name;
1395
1396         _route->save_as_template (path.to_string(), name);
1397 }
1398
1399 void
1400 RouteUI::check_rec_enable_sensitivity ()
1401 {
1402         if (_session->transport_rolling() && rec_enable_button->get_active() && Config->get_disable_disarm_during_roll()) {
1403                 rec_enable_button->set_sensitive (false);
1404         } else {
1405                 rec_enable_button->set_sensitive (true);
1406         }
1407 }
1408
1409 void
1410 RouteUI::parameter_changed (string const & p)
1411 {
1412         if (p == "disable-disarm-during-roll") {
1413                 check_rec_enable_sensitivity ();
1414         } else if (p == "solo-control-is-listen-control") {
1415                 set_button_names ();
1416         } else if (p == "listen-position") {
1417                 set_button_names ();
1418         }
1419 }
1420
1421 void
1422 RouteUI::step_gain_up ()
1423 {
1424         _route->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route->gain_control()->get_value()) + 0.1), this);
1425 }
1426
1427 void
1428 RouteUI::page_gain_up ()
1429 {
1430         _route->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route->gain_control()->get_value()) + 0.5), this);
1431 }
1432
1433 void
1434 RouteUI::step_gain_down ()
1435 {
1436         _route->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route->gain_control()->get_value()) - 0.1), this);
1437 }
1438
1439 void
1440 RouteUI::page_gain_down ()
1441 {
1442         _route->set_gain (dB_to_coefficient (accurate_coefficient_to_dB (_route->gain_control()->get_value()) - 0.5), this);
1443 }
1444
1445 void
1446 RouteUI::open_remote_control_id_dialog ()
1447 {
1448         ArdourDialog dialog (_("Remote Control ID"));
1449
1450         uint32_t const limit = _session->ntracks() + _session->nbusses () + 4;
1451
1452         HBox* hbox = manage (new HBox);
1453         hbox->set_spacing (6);
1454         hbox->pack_start (*manage (new Label (_("Remote control ID:"))));
1455         SpinButton* spin = manage (new SpinButton);
1456         spin->set_digits (0);
1457         spin->set_increments (1, 10);
1458         spin->set_range (0, limit);
1459         spin->set_value (_route->remote_control_id());
1460         hbox->pack_start (*spin);
1461         dialog.get_vbox()->pack_start (*hbox);
1462
1463         dialog.add_button (Stock::CANCEL, RESPONSE_CANCEL);
1464         dialog.add_button (Stock::APPLY, RESPONSE_ACCEPT);
1465
1466         dialog.show_all ();
1467         int const r = dialog.run ();
1468
1469         if (r == RESPONSE_ACCEPT) {
1470                 _route->set_remote_control_id (spin->get_value_as_int ());
1471         }
1472 }