gtk2_ardour/editor_routes.cc

   1 /*
   2     Copyright (C) 2000-2009 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 <cstdlib>
  21 #include <cassert>
  22 #include <cmath>
  23 #include <list>
  24 #include <vector>
  25 #include <algorithm>
  26
  27 #include "pbd/unknown_type.h"
  28 #include "pbd/unwind.h"
  29
  30 #include "ardour/debug.h"
  31 #include "ardour/midi_track.h"
  32 #include "ardour/route.h"
  33 #include "ardour/session.h"
  34
  35 #include "gtkmm2ext/cell_renderer_pixbuf_multi.h"
  36 #include "gtkmm2ext/cell_renderer_pixbuf_toggle.h"
  37 #include "gtkmm2ext/treeutils.h"
  38
  39 #include "actions.h"
  40 #include "ardour_ui.h"
  41 #include "audio_time_axis.h"
  42 #include "editor.h"
  43 #include "editor_group_tabs.h"
  44 #include "editor_routes.h"
  45 #include "gui_thread.h"
  46 #include "keyboard.h"
  47 #include "midi_time_axis.h"
  48 #include "mixer_strip.h"
  49 #include "plugin_setup_dialog.h"
  50 #include "route_sorter.h"
  51 #include "tooltips.h"
  52 #include "utils.h"
  53
  54 #include "i18n.h"
  55
  56 using namespace std;
  57 using namespace ARDOUR;
  58 using namespace ARDOUR_UI_UTILS;
  59 using namespace PBD;
  60 using namespace Gtk;
  61 using namespace Gtkmm2ext;
  62 using namespace Glib;
  63 using Gtkmm2ext::Keyboard;
  64
  65 struct ColumnInfo {
  66         int         index;
  67         const char* label;
  68         const char* tooltip;
  69 };
  70
  71 EditorRoutes::EditorRoutes (Editor* e)
  72         : EditorComponent (e)
  73         , _ignore_reorder (false)
  74         , _no_redisplay (false)
  75         , _adding_routes (false)
  76         , _route_deletion_in_progress (false)
  77         , _redisplay_on_resume (false)
  78         , _redisplay_active (0)
  79         , _queue_tv_update (0)
  80         , _menu (0)
  81         , old_focus (0)
  82         , selection_countdown (0)
  83         , name_editable (0)
  84 {
  85         static const int column_width = 22;
  86
  87         _scroller.add (_display);
  88         _scroller.set_policy (POLICY_NEVER, POLICY_AUTOMATIC);
  89
  90         _model = ListStore::create (_columns);
  91         _display.set_model (_model);
  92
  93         // Record enable toggle
  94         CellRendererPixbufMulti* rec_col_renderer = manage (new CellRendererPixbufMulti());
  95
  96         rec_col_renderer->set_pixbuf (0, ::get_icon("record-normal-disabled"));
  97         rec_col_renderer->set_pixbuf (1, ::get_icon("record-normal-in-progress"));
  98         rec_col_renderer->set_pixbuf (2, ::get_icon("record-normal-enabled"));
  99         rec_col_renderer->set_pixbuf (3, ::get_icon("record-step"));
 100         rec_col_renderer->signal_changed().connect (sigc::mem_fun (*this, &EditorRoutes::on_tv_rec_enable_changed));
 101
 102         TreeViewColumn* rec_state_column = manage (new TreeViewColumn("R", *rec_col_renderer));
 103
 104         rec_state_column->add_attribute(rec_col_renderer->property_state(), _columns.rec_state);
 105         rec_state_column->add_attribute(rec_col_renderer->property_visible(), _columns.is_track);
 106
 107         rec_state_column->set_sizing(TREE_VIEW_COLUMN_FIXED);
 108         rec_state_column->set_alignment(ALIGN_CENTER);
 109         rec_state_column->set_expand(false);
 110         rec_state_column->set_fixed_width(column_width);
 111
 112
 113         // Record safe toggle
 114         CellRendererPixbufMulti* rec_safe_renderer = manage (new CellRendererPixbufMulti ());
 115
 116         rec_safe_renderer->set_pixbuf (0, ::get_icon("rec-safe-disabled"));
 117         rec_safe_renderer->set_pixbuf (1, ::get_icon("rec-safe-enabled"));
 118         rec_safe_renderer->signal_changed().connect (sigc::mem_fun (*this, &EditorRoutes::on_tv_rec_safe_toggled));
 119
 120         TreeViewColumn* rec_safe_column = manage (new TreeViewColumn(_("RS"), *rec_safe_renderer));
 121         rec_safe_column->add_attribute(rec_safe_renderer->property_state(), _columns.rec_safe);
 122         rec_safe_column->add_attribute(rec_safe_renderer->property_visible(), _columns.is_track);
 123         rec_safe_column->set_sizing(TREE_VIEW_COLUMN_FIXED);
 124         rec_safe_column->set_alignment(ALIGN_CENTER);
 125         rec_safe_column->set_expand(false);
 126         rec_safe_column->set_fixed_width(column_width);
 127
 128
 129         // MIDI Input Active
 130
 131         CellRendererPixbufMulti* input_active_col_renderer = manage (new CellRendererPixbufMulti());
 132         input_active_col_renderer->set_pixbuf (0, ::get_icon("midi-input-inactive"));
 133         input_active_col_renderer->set_pixbuf (1, ::get_icon("midi-input-active"));
 134         input_active_col_renderer->signal_changed().connect (sigc::mem_fun (*this, &EditorRoutes::on_input_active_changed));
 135
 136         TreeViewColumn* input_active_column = manage (new TreeViewColumn ("I", *input_active_col_renderer));
 137
 138         input_active_column->add_attribute(input_active_col_renderer->property_state(), _columns.is_input_active);
 139         input_active_column->add_attribute (input_active_col_renderer->property_visible(), _columns.is_midi);
 140
 141         input_active_column->set_sizing(TREE_VIEW_COLUMN_FIXED);
 142         input_active_column->set_alignment(ALIGN_CENTER);
 143         input_active_column->set_expand(false);
 144         input_active_column->set_fixed_width(column_width);
 145
 146         // Mute enable toggle
 147         CellRendererPixbufMulti* mute_col_renderer = manage (new CellRendererPixbufMulti());
 148
 149         mute_col_renderer->set_pixbuf (Gtkmm2ext::Off, ::get_icon("mute-disabled"));
 150         mute_col_renderer->set_pixbuf (Gtkmm2ext::ImplicitActive, ::get_icon("muted-by-others"));
 151         mute_col_renderer->set_pixbuf (Gtkmm2ext::ExplicitActive, ::get_icon("mute-enabled"));
 152         mute_col_renderer->signal_changed().connect (sigc::mem_fun (*this, &EditorRoutes::on_tv_mute_enable_toggled));
 153
 154         TreeViewColumn* mute_state_column = manage (new TreeViewColumn("M", *mute_col_renderer));
 155
 156         mute_state_column->add_attribute(mute_col_renderer->property_state(), _columns.mute_state);
 157         mute_state_column->set_sizing(TREE_VIEW_COLUMN_FIXED);
 158         mute_state_column->set_alignment(ALIGN_CENTER);
 159         mute_state_column->set_expand(false);
 160         mute_state_column->set_fixed_width(15);
 161
 162         // Solo enable toggle
 163         CellRendererPixbufMulti* solo_col_renderer = manage (new CellRendererPixbufMulti());
 164
 165         solo_col_renderer->set_pixbuf (Gtkmm2ext::Off, ::get_icon("solo-disabled"));
 166         solo_col_renderer->set_pixbuf (Gtkmm2ext::ExplicitActive, ::get_icon("solo-enabled"));
 167         solo_col_renderer->set_pixbuf (Gtkmm2ext::ImplicitActive, ::get_icon("soloed-by-others"));
 168         solo_col_renderer->signal_changed().connect (sigc::mem_fun (*this, &EditorRoutes::on_tv_solo_enable_toggled));
 169
 170         TreeViewColumn* solo_state_column = manage (new TreeViewColumn("S", *solo_col_renderer));
 171
 172         solo_state_column->add_attribute(solo_col_renderer->property_state(), _columns.solo_state);
 173         solo_state_column->add_attribute(solo_col_renderer->property_visible(), _columns.solo_visible);
 174         solo_state_column->set_sizing(TREE_VIEW_COLUMN_FIXED);
 175         solo_state_column->set_alignment(ALIGN_CENTER);
 176         solo_state_column->set_expand(false);
 177         solo_state_column->set_fixed_width(column_width);
 178
 179         // Solo isolate toggle
 180         CellRendererPixbufMulti* solo_iso_renderer = manage (new CellRendererPixbufMulti());
 181
 182         solo_iso_renderer->set_pixbuf (0, ::get_icon("solo-isolate-disabled"));
 183         solo_iso_renderer->set_pixbuf (1, ::get_icon("solo-isolate-enabled"));
 184         solo_iso_renderer->signal_changed().connect (sigc::mem_fun (*this, &EditorRoutes::on_tv_solo_isolate_toggled));
 185
 186         TreeViewColumn* solo_isolate_state_column = manage (new TreeViewColumn("SI", *solo_iso_renderer));
 187
 188         solo_isolate_state_column->add_attribute(solo_iso_renderer->property_state(), _columns.solo_isolate_state);
 189         solo_isolate_state_column->add_attribute(solo_iso_renderer->property_visible(), _columns.solo_visible);
 190         solo_isolate_state_column->set_sizing(TREE_VIEW_COLUMN_FIXED);
 191         solo_isolate_state_column->set_alignment(ALIGN_CENTER);
 192         solo_isolate_state_column->set_expand(false);
 193         solo_isolate_state_column->set_fixed_width(column_width);
 194
 195         // Solo safe toggle
 196         CellRendererPixbufMulti* solo_safe_renderer = manage (new CellRendererPixbufMulti ());
 197
 198         solo_safe_renderer->set_pixbuf (0, ::get_icon("solo-safe-disabled"));
 199         solo_safe_renderer->set_pixbuf (1, ::get_icon("solo-safe-enabled"));
 200         solo_safe_renderer->signal_changed().connect (sigc::mem_fun (*this, &EditorRoutes::on_tv_solo_safe_toggled));
 201
 202         TreeViewColumn* solo_safe_state_column = manage (new TreeViewColumn(_("SS"), *solo_safe_renderer));
 203         solo_safe_state_column->add_attribute(solo_safe_renderer->property_state(), _columns.solo_safe_state);
 204         solo_safe_state_column->add_attribute(solo_safe_renderer->property_visible(), _columns.solo_visible);
 205         solo_safe_state_column->set_sizing(TREE_VIEW_COLUMN_FIXED);
 206         solo_safe_state_column->set_alignment(ALIGN_CENTER);
 207         solo_safe_state_column->set_expand(false);
 208         solo_safe_state_column->set_fixed_width(column_width);
 209
 210         _name_column = _display.append_column ("", _columns.text) - 1;
 211         _visible_column = _display.append_column ("", _columns.visible) - 1;
 212         _active_column = _display.append_column ("", _columns.active) - 1;
 213
 214         _display.append_column (*input_active_column);
 215         _display.append_column (*rec_state_column);
 216         _display.append_column (*rec_safe_column);
 217         _display.append_column (*mute_state_column);
 218         _display.append_column (*solo_state_column);
 219         _display.append_column (*solo_isolate_state_column);
 220         _display.append_column (*solo_safe_state_column);
 221
 222
 223         TreeViewColumn* col;
 224         Gtk::Label* l;
 225
 226         ColumnInfo ci[] = {
 227                 { 0,  _("Name"),        _("Track/Bus Name") },
 228                 { 1, S_("Visible|V"),   _("Track/Bus visible ?") },
 229                 { 2, S_("Active|A"),    _("Track/Bus active ?") },
 230                 { 3, S_("MidiInput|I"), _("MIDI input enabled") },
 231                 { 4, S_("Rec|R"),       _("Record enabled") },
 232                 { 5, S_("Rec|RS"),      _("Record Safe") },
 233                 { 6, S_("Mute|M"),      _("Muted") },
 234                 { 7, S_("Solo|S"),      _("Soloed") },
 235                 { 8, S_("SoloIso|SI"),  _("Solo Isolated") },
 236                 { 9, S_("SoloLock|SS"), _("Solo Safe (Locked)") },
 237                 { -1, 0, 0 }
 238         };
 239
 240         for (int i = 0; ci[i].index >= 0; ++i) {
 241                 col = _display.get_column (ci[i].index);
 242                 l = manage (new Label (ci[i].label));
 243                 set_tooltip (*l, ci[i].tooltip);
 244                 col->set_widget (*l);
 245                 l->show ();
 246         }
 247
 248         _display.set_headers_visible (true);
 249         _display.get_selection()->set_mode (SELECTION_SINGLE);
 250         _display.get_selection()->set_select_function (sigc::mem_fun (*this, &EditorRoutes::selection_filter));
 251         _display.get_selection()->signal_changed().connect (sigc::mem_fun (*this, &EditorRoutes::selection_changed));
 252         _display.set_reorderable (true);
 253         _display.set_name (X_("EditGroupList"));
 254         _display.set_rules_hint (true);
 255         _display.set_size_request (100, -1);
 256         _display.add_object_drag (_columns.route.index(), "routes");
 257
 258         CellRendererText* name_cell = dynamic_cast<CellRendererText*> (_display.get_column_cell_renderer (_name_column));
 259
 260         assert (name_cell);
 261         name_cell->signal_editing_started().connect (sigc::mem_fun (*this, &EditorRoutes::name_edit_started));
 262
 263         TreeViewColumn* name_column = _display.get_column (_name_column);
 264
 265         assert (name_column);
 266
 267         name_column->add_attribute (name_cell->property_editable(), _columns.name_editable);
 268         name_column->set_sizing(TREE_VIEW_COLUMN_FIXED);
 269         name_column->set_expand(true);
 270         name_column->set_min_width(50);
 271
 272         name_cell->property_editable() = true;
 273         name_cell->signal_edited().connect (sigc::mem_fun (*this, &EditorRoutes::name_edit));
 274
 275         // Set the visible column cell renderer to radio toggle
 276         CellRendererToggle* visible_cell = dynamic_cast<CellRendererToggle*> (_display.get_column_cell_renderer (_visible_column));
 277
 278         visible_cell->property_activatable() = true;
 279         visible_cell->property_radio() = false;
 280         visible_cell->signal_toggled().connect (sigc::mem_fun (*this, &EditorRoutes::visible_changed));
 281
 282         TreeViewColumn* visible_col = dynamic_cast<TreeViewColumn*> (_display.get_column (_visible_column));
 283         visible_col->set_expand(false);
 284         visible_col->set_sizing(TREE_VIEW_COLUMN_FIXED);
 285         visible_col->set_fixed_width(30);
 286         visible_col->set_alignment(ALIGN_CENTER);
 287
 288         CellRendererToggle* active_cell = dynamic_cast<CellRendererToggle*> (_display.get_column_cell_renderer (_active_column));
 289
 290         active_cell->property_activatable() = true;
 291         active_cell->property_radio() = false;
 292         active_cell->signal_toggled().connect (sigc::mem_fun (*this, &EditorRoutes::active_changed));
 293
 294         TreeViewColumn* active_col = dynamic_cast<TreeViewColumn*> (_display.get_column (_active_column));
 295         active_col->set_expand (false);
 296         active_col->set_sizing (TREE_VIEW_COLUMN_FIXED);
 297         active_col->set_fixed_width (30);
 298         active_col->set_alignment (ALIGN_CENTER);
 299
 300         _model->signal_row_deleted().connect (sigc::mem_fun (*this, &EditorRoutes::row_deleted));
 301         _model->signal_rows_reordered().connect (sigc::mem_fun (*this, &EditorRoutes::reordered));
 302
 303         _display.signal_button_press_event().connect (sigc::mem_fun (*this, &EditorRoutes::button_press), false);
 304         _scroller.signal_key_press_event().connect (sigc::mem_fun(*this, &EditorRoutes::key_press), false);
 305
 306         _scroller.signal_focus_in_event().connect (sigc::mem_fun (*this, &EditorRoutes::focus_in), false);
 307         _scroller.signal_focus_out_event().connect (sigc::mem_fun (*this, &EditorRoutes::focus_out));
 308
 309         _display.signal_enter_notify_event().connect (sigc::mem_fun (*this, &EditorRoutes::enter_notify), false);
 310         _display.signal_leave_notify_event().connect (sigc::mem_fun (*this, &EditorRoutes::leave_notify), false);
 311
 312         _display.set_enable_search (false);
 313
 314         Route::SyncOrderKeys.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::sync_treeview_from_order_keys, this), gui_context());
 315         Route::PluginSetup.connect_same_thread (*this, boost::bind (&EditorRoutes::plugin_setup, this, _1, _2, _3));
 316
 317 }
 318
 319 bool
 320 EditorRoutes::focus_in (GdkEventFocus*)
 321 {
 322         Window* win = dynamic_cast<Window*> (_scroller.get_toplevel ());
 323
 324         if (win) {
 325                 old_focus = win->get_focus ();
 326         } else {
 327                 old_focus = 0;
 328         }
 329
 330         name_editable = 0;
 331
 332         /* try to do nothing on focus in (doesn't work, hence selection_count nonsense) */
 333         return true;
 334 }
 335
 336 bool
 337 EditorRoutes::focus_out (GdkEventFocus*)
 338 {
 339         if (old_focus) {
 340                 old_focus->grab_focus ();
 341                 old_focus = 0;
 342         }
 343
 344         return false;
 345 }
 346
 347 bool
 348 EditorRoutes::enter_notify (GdkEventCrossing*)
 349 {
 350         if (name_editable) {
 351                 return true;
 352         }
 353
 354         /* arm counter so that ::selection_filter() will deny selecting anything for the
 355          * next two attempts to change selection status.
 356          */
 357         selection_countdown = 2;
 358         _scroller.grab_focus ();
 359         Keyboard::magic_widget_grab_focus ();
 360         return false;
 361 }
 362
 363 bool
 364 EditorRoutes::leave_notify (GdkEventCrossing*)
 365 {
 366         selection_countdown = 0;
 367
 368         if (old_focus) {
 369                 old_focus->grab_focus ();
 370                 old_focus = 0;
 371         }
 372
 373         Keyboard::magic_widget_drop_focus ();
 374         return false;
 375 }
 376
 377 void
 378 EditorRoutes::set_session (Session* s)
 379 {
 380         SessionHandlePtr::set_session (s);
 381
 382         initial_display ();
 383
 384         if (_session) {
 385                 _session->SoloChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::solo_changed_so_update_mute, this), gui_context());
 386                 _session->RecordStateChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_rec_display, this), gui_context());
 387
 388                 /* TODO: check if these needs to be tied in with DisplaySuspender
 389                  * Given that the UI is single-threaded and DisplaySuspender is only used
 390                  * in loops in the UI thread all should be fine.
 391                  */
 392                 _session->BatchUpdateStart.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::suspend_redisplay, this), gui_context());
 393                 _session->BatchUpdateEnd.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::resume_redisplay, this), gui_context());
 394         }
 395 }
 396
 397 void
 398 EditorRoutes::on_input_active_changed (std::string const & path_string)
 399 {
 400         // Get the model row that has been toggled.
 401         Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string));
 402
 403         TimeAxisView* tv = row[_columns.tv];
 404         RouteTimeAxisView *rtv = dynamic_cast<RouteTimeAxisView*> (tv);
 405
 406         if (rtv) {
 407                 boost::shared_ptr<MidiTrack> mt;
 408                 mt = rtv->midi_track();
 409                 if (mt) {
 410                         mt->set_input_active (!mt->input_active());
 411                 }
 412         }
 413 }
 414
 415 void
 416 EditorRoutes::on_tv_rec_enable_changed (std::string const & path_string)
 417 {
 418         // Get the model row that has been toggled.
 419         Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string));
 420
 421         TimeAxisView* tv = row[_columns.tv];
 422         RouteTimeAxisView *rtv = dynamic_cast<RouteTimeAxisView*> (tv);
 423
 424         if (rtv && rtv->track()) {
 425                 DisplaySuspender ds;
 426                 boost::shared_ptr<RouteList> rl (new RouteList);
 427                 // TODO check rec-safe and ...
 428                 rl->push_back (rtv->route());
 429                 _session->set_record_enabled (rl, !rtv->track()->record_enabled(), Session::rt_cleanup);
 430         }
 431 }
 432
 433 void
 434 EditorRoutes::on_tv_rec_safe_toggled (std::string const & path_string)
 435 {
 436         Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string));
 437         TimeAxisView* tv = row[_columns.tv];
 438         RouteTimeAxisView *rtv = dynamic_cast<RouteTimeAxisView*> (tv);
 439
 440         if (rtv && rtv->track() && !rtv->track()->record_enabled()) {
 441                 DisplaySuspender ds;
 442                 boost::shared_ptr<RouteList> rl (new RouteList);
 443                 rl->push_back (rtv->route());
 444                 _session->set_record_safe (rl, !rtv->track()->record_safe(), Session::rt_cleanup);
 445         }
 446 }
 447
 448 void
 449 EditorRoutes::on_tv_mute_enable_toggled (std::string const & path_string)
 450 {
 451         // Get the model row that has been toggled.
 452         Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string));
 453
 454         TimeAxisView *tv = row[_columns.tv];
 455         RouteTimeAxisView *rtv = dynamic_cast<RouteTimeAxisView*> (tv);
 456
 457         if (rtv != 0) {
 458                 boost::shared_ptr<RouteList> rl (new RouteList);
 459                 rl->push_back (rtv->route());
 460                 _session->set_mute (rl, !rtv->route()->muted(), Session::rt_cleanup);
 461         }
 462 }
 463
 464 void
 465 EditorRoutes::on_tv_solo_enable_toggled (std::string const & path_string)
 466 {
 467         // Get the model row that has been toggled.
 468         Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string));
 469
 470         TimeAxisView *tv = row[_columns.tv];
 471         RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tv);
 472
 473         if (rtv != 0) {
 474                 boost::shared_ptr<RouteList> rl (new RouteList);
 475                 rl->push_back (rtv->route());
 476                 if (Config->get_solo_control_is_listen_control()) {
 477                         _session->set_listen (rl, !rtv->route()->listening_via_monitor(), Session::rt_cleanup);
 478                 } else {
 479                         _session->set_solo (rl, !rtv->route()->self_soloed(), Session::rt_cleanup);
 480                 }
 481         }
 482 }
 483
 484 void
 485 EditorRoutes::on_tv_solo_isolate_toggled (std::string const & path_string)
 486 {
 487         // Get the model row that has been toggled.
 488         Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string));
 489
 490         TimeAxisView *tv = row[_columns.tv];
 491         RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tv);
 492
 493         if (rtv) {
 494                 rtv->route()->set_solo_isolated (!rtv->route()->solo_isolated(), Controllable::UseGroup);
 495         }
 496 }
 497
 498 void
 499 EditorRoutes::on_tv_solo_safe_toggled (std::string const & path_string)
 500 {
 501         // Get the model row that has been toggled.
 502         Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string));
 503
 504         TimeAxisView *tv = row[_columns.tv];
 505         RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tv);
 506
 507         if (rtv) {
 508                 rtv->route()->set_solo_safe (!rtv->route()->solo_safe(), Controllable::UseGroup);
 509         }
 510 }
 511
 512 void
 513 EditorRoutes::build_menu ()
 514 {
 515         using namespace Menu_Helpers;
 516         using namespace Gtk;
 517
 518         _menu = new Menu;
 519
 520         MenuList& items = _menu->items();
 521         _menu->set_name ("ArdourContextMenu");
 522
 523         items.push_back (MenuElem (_("Show All"), sigc::mem_fun (*this, &EditorRoutes::show_all_routes)));
 524         items.push_back (MenuElem (_("Hide All"), sigc::mem_fun (*this, &EditorRoutes::hide_all_routes)));
 525         items.push_back (MenuElem (_("Show All Audio Tracks"), sigc::mem_fun (*this, &EditorRoutes::show_all_audiotracks)));
 526         items.push_back (MenuElem (_("Hide All Audio Tracks"), sigc::mem_fun (*this, &EditorRoutes::hide_all_audiotracks)));
 527         items.push_back (MenuElem (_("Show All Audio Busses"), sigc::mem_fun (*this, &EditorRoutes::show_all_audiobus)));
 528         items.push_back (MenuElem (_("Hide All Audio Busses"), sigc::mem_fun (*this, &EditorRoutes::hide_all_audiobus)));
 529         items.push_back (MenuElem (_("Show All Midi Tracks"), sigc::mem_fun (*this, &EditorRoutes::show_all_miditracks)));
 530         items.push_back (MenuElem (_("Hide All Midi Tracks"), sigc::mem_fun (*this, &EditorRoutes::hide_all_miditracks)));
 531         items.push_back (MenuElem (_("Only Show Tracks with Regions Under Playhead"), sigc::mem_fun (*this, &EditorRoutes::show_tracks_with_regions_at_playhead)));
 532 }
 533
 534 void
 535 EditorRoutes::show_menu ()
 536 {
 537         if (_menu == 0) {
 538                 build_menu ();
 539         }
 540
 541         _menu->popup (1, gtk_get_current_event_time());
 542 }
 543
 544 void
 545 EditorRoutes::redisplay_real ()
 546 {
 547         TreeModel::Children rows = _model->children();
 548         TreeModel::Children::iterator i;
 549         uint32_t position;
 550
 551         /* n will be the count of tracks plus children (updated by TimeAxisView::show_at),
 552          * so we will use that to know where to put things.
 553          */
 554         int n;
 555
 556         for (n = 0, position = 0, i = rows.begin(); i != rows.end(); ++i) {
 557                 TimeAxisView *tv = (*i)[_columns.tv];
 558                 boost::shared_ptr<Route> route = (*i)[_columns.route];
 559
 560                 if (tv == 0) {
 561                         // just a "title" row
 562                         continue;
 563                 }
 564
 565                 bool visible = tv->marked_for_display ();
 566
 567                 /* show or hide the TimeAxisView */
 568                 if (visible) {
 569                         position += tv->show_at (position, n, &_editor->edit_controls_vbox);
 570                 } else {
 571                         tv->hide ();
 572                 }
 573
 574                 n++;
 575         }
 576
 577         /* whenever we go idle, update the track view list to reflect the new order.
 578          * we can't do this here, because we could mess up something that is traversing
 579          * the track order and has caused a redisplay of the list.
 580          */
 581         Glib::signal_idle().connect (sigc::mem_fun (*_editor, &Editor::sync_track_view_list_and_routes));
 582
 583         _editor->reset_controls_layout_height (position);
 584         _editor->reset_controls_layout_width ();
 585         _editor->_full_canvas_height = position;
 586
 587         if ((_editor->vertical_adjustment.get_value() + _editor->_visible_canvas_height) > _editor->vertical_adjustment.get_upper()) {
 588                 /*
 589                  * We're increasing the size of the canvas while the bottom is visible.
 590                  * We scroll down to keep in step with the controls layout.
 591                  */
 592                 _editor->vertical_adjustment.set_value (_editor->_full_canvas_height - _editor->_visible_canvas_height);
 593         }
 594 }
 595
 596 void
 597 EditorRoutes::redisplay ()
 598 {
 599         if (!_session || _session->deletion_in_progress()) {
 600                 return;
 601         }
 602
 603         if (_no_redisplay) {
 604                 _redisplay_on_resume = true;
 605                 return;
 606         }
 607
 608         // model deprecated g_atomic_int_exchange_and_add(, 1)
 609         g_atomic_int_inc(const_cast<gint*>(&_redisplay_active));
 610         if (!g_atomic_int_compare_and_exchange (const_cast<gint*>(&_redisplay_active), 1, 1)) {
 611                 /* recursive re-display can happen if redisplay shows/hides a TrackView
 612                  * which has children and their display status changes as result.
 613                  */
 614                 return;
 615         }
 616
 617         redisplay_real ();
 618
 619         while (!g_atomic_int_compare_and_exchange (const_cast<gint*>(&_redisplay_active), 1, 0)) {
 620                 g_atomic_int_set(const_cast<gint*>(&_redisplay_active), 1);
 621                 redisplay_real ();
 622         }
 623 }
 624
 625 void
 626 EditorRoutes::row_deleted (Gtk::TreeModel::Path const &)
 627 {
 628         if (!_session || _session->deletion_in_progress()) {
 629                 return;
 630         }
 631         /* this happens as the second step of a DnD within the treeview, and
 632          * when a route is actually removed. we don't differentiate between
 633          * the two cases.
 634          *
 635          * note that the sync_orders_keys() step may not actually change any
 636          * RID's (e.g. the last track may be removed, so all other tracks keep
 637          * the same RID), which means that no redisplay would happen. so we
 638          * have to force a redisplay.
 639          */
 640
 641         DEBUG_TRACE (DEBUG::OrderKeys, "editor routes treeview row deleted\n");
 642
 643         DisplaySuspender ds;
 644         sync_order_keys_from_treeview ();
 645 }
 646
 647 void
 648 EditorRoutes::reordered (TreeModel::Path const &, TreeModel::iterator const &, int* /*what*/)
 649 {
 650         /* reordering implies that RID's will change, so sync_order_keys() will
 651            cause a redisplay.
 652         */
 653
 654         DEBUG_TRACE (DEBUG::OrderKeys, "editor routes treeview reordered\n");
 655         sync_order_keys_from_treeview ();
 656 }
 657
 658 void
 659 EditorRoutes::visible_changed (std::string const & path)
 660 {
 661         if (_session && _session->deletion_in_progress()) {
 662                 return;
 663         }
 664
 665         DisplaySuspender ds;
 666         TreeIter iter;
 667
 668         if ((iter = _model->get_iter (path))) {
 669                 TimeAxisView* tv = (*iter)[_columns.tv];
 670                 if (tv) {
 671                         bool visible = (*iter)[_columns.visible];
 672
 673                         if (tv->set_marked_for_display (!visible)) {
 674                                 update_visibility ();
 675                         }
 676                 }
 677         }
 678 }
 679
 680 void
 681 EditorRoutes::active_changed (std::string const & path)
 682 {
 683         if (_session && _session->deletion_in_progress ()) {
 684                 return;
 685         }
 686
 687         Gtk::TreeModel::Row row = *_model->get_iter (path);
 688         boost::shared_ptr<Route> route = row[_columns.route];
 689         bool const active = row[_columns.active];
 690         route->set_active (!active, this);
 691 }
 692
 693 void
 694 EditorRoutes::routes_added (list<RouteTimeAxisView*> routes)
 695 {
 696         PBD::Unwinder<bool> at (_adding_routes, true);
 697         bool from_scratch = (_model->children().size() == 0);
 698         Gtk::TreeModel::Children::iterator insert_iter = _model->children().end();
 699
 700         for (Gtk::TreeModel::Children::iterator it = _model->children().begin(); it != _model->children().end(); ++it) {
 701                 boost::shared_ptr<Route> r = (*it)[_columns.route];
 702
 703                 if (r->order_key() == (routes.front()->route()->order_key() + routes.size())) {
 704                         insert_iter = it;
 705                         break;
 706                 }
 707         }
 708
 709         DisplaySuspender ds;
 710
 711         _display.set_model (Glib::RefPtr<ListStore>());
 712
 713         for (list<RouteTimeAxisView*>::iterator x = routes.begin(); x != routes.end(); ++x) {
 714
 715                 boost::shared_ptr<MidiTrack> midi_trk = boost::dynamic_pointer_cast<MidiTrack> ((*x)->route());
 716
 717                 TreeModel::Row row = *(_model->insert (insert_iter));
 718
 719                 row[_columns.text] = (*x)->route()->name();
 720                 row[_columns.visible] = (*x)->marked_for_display();
 721                 row[_columns.active] = (*x)->route()->active ();
 722                 row[_columns.tv] = *x;
 723                 row[_columns.route] = (*x)->route ();
 724                 row[_columns.is_track] = (boost::dynamic_pointer_cast<Track> ((*x)->route()) != 0);
 725
 726                 if (midi_trk) {
 727                         row[_columns.is_input_active] = midi_trk->input_active ();
 728                         row[_columns.is_midi] = true;
 729                 } else {
 730                         row[_columns.is_input_active] = false;
 731                         row[_columns.is_midi] = false;
 732                 }
 733
 734                 row[_columns.mute_state] = (*x)->route()->muted() ? Gtkmm2ext::ExplicitActive : Gtkmm2ext::Off;
 735                 row[_columns.solo_state] = RouteUI::solo_active_state ((*x)->route());
 736                 row[_columns.solo_visible] = !(*x)->route()->is_master ();
 737                 row[_columns.solo_isolate_state] = (*x)->route()->solo_isolated();
 738                 row[_columns.solo_safe_state] = (*x)->route()->solo_safe();
 739                 row[_columns.name_editable] = true;
 740
 741                 boost::weak_ptr<Route> wr ((*x)->route());
 742
 743                 (*x)->route()->gui_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::handle_gui_changes, this, _1, _2), gui_context());
 744                 (*x)->route()->PropertyChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::route_property_changed, this, _1, wr), gui_context());
 745
 746                 if ((*x)->is_track()) {
 747                         boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> ((*x)->route());
 748                         t->RecordEnableChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_rec_display, this), gui_context());
 749                         t->RecordSafeChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_rec_display, this), gui_context());
 750                 }
 751
 752                 if ((*x)->is_midi_track()) {
 753                         boost::shared_ptr<MidiTrack> t = boost::dynamic_pointer_cast<MidiTrack> ((*x)->route());
 754                         t->StepEditStatusChange.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_rec_display, this), gui_context());
 755                         t->InputActiveChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_input_active_display, this), gui_context());
 756                 }
 757
 758                 (*x)->route()->mute_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_mute_display, this), gui_context());
 759                 (*x)->route()->solo_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_solo_display, this), gui_context());
 760                 (*x)->route()->listen_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_solo_display, this), gui_context());
 761                 (*x)->route()->solo_isolated_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_solo_isolate_display, this), gui_context());
 762                 (*x)->route()->solo_safe_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_solo_safe_display, this), gui_context());
 763                 (*x)->route()->active_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_active_display, this), gui_context ());
 764
 765         }
 766
 767         update_rec_display ();
 768         update_mute_display ();
 769         update_solo_display ();
 770         update_solo_isolate_display ();
 771         update_solo_safe_display ();
 772         update_input_active_display ();
 773         update_active_display ();
 774
 775         _display.set_model (_model);
 776
 777         /* now update route order keys from the treeview/track display order */
 778         if (!from_scratch) {
 779                 sync_order_keys_from_treeview ();
 780         }
 781 }
 782
 783 void
 784 EditorRoutes::handle_gui_changes (string const & what, void*)
 785 {
 786         if (_adding_routes) {
 787                 return;
 788         }
 789
 790         if (what == "track_height") {
 791                 /* Optional :make tracks change height while it happens, instead
 792                    of on first-idle
 793                 */
 794                 redisplay ();
 795         }
 796
 797         if (what == "visible_tracks") {
 798                 redisplay ();
 799         }
 800 }
 801
 802 void
 803 EditorRoutes::route_removed (TimeAxisView *tv)
 804 {
 805         ENSURE_GUI_THREAD (*this, &EditorRoutes::route_removed, tv)
 806
 807         TreeModel::Children rows = _model->children();
 808         TreeModel::Children::iterator ri;
 809
 810         for (ri = rows.begin(); ri != rows.end(); ++ri) {
 811                 if ((*ri)[_columns.tv] == tv) {
 812                         PBD::Unwinder<bool> uw (_route_deletion_in_progress, true);
 813                         _model->erase (ri);
 814                         break;
 815                 }
 816         }
 817
 818         /* the deleted signal for the treeview/model will take
 819            care of any updates.
 820         */
 821 }
 822
 823 void
 824 EditorRoutes::route_property_changed (const PropertyChange& what_changed, boost::weak_ptr<Route> r)
 825 {
 826         if (!what_changed.contains (ARDOUR::Properties::name)) {
 827                 return;
 828         }
 829
 830         ENSURE_GUI_THREAD (*this, &EditorRoutes::route_name_changed, r)
 831
 832         boost::shared_ptr<Route> route = r.lock ();
 833
 834         if (!route) {
 835                 return;
 836         }
 837
 838         TreeModel::Children rows = _model->children();
 839         TreeModel::Children::iterator i;
 840
 841         for (i = rows.begin(); i != rows.end(); ++i) {
 842                 boost::shared_ptr<Route> t = (*i)[_columns.route];
 843                 if (t == route) {
 844                         (*i)[_columns.text] = route->name();
 845                         break;
 846                 }
 847         }
 848 }
 849
 850 void
 851 EditorRoutes::update_active_display ()
 852 {
 853         if (g_atomic_int_compare_and_exchange (const_cast<gint*>(&_queue_tv_update), 0, 1)) {
 854                 Glib::signal_idle().connect (sigc::mem_fun (*this, &EditorRoutes::idle_update_mute_rec_solo_etc));
 855         }
 856 }
 857
 858 void
 859 EditorRoutes::update_visibility ()
 860 {
 861         TreeModel::Children rows = _model->children();
 862         TreeModel::Children::iterator i;
 863
 864         DisplaySuspender ds;
 865
 866         for (i = rows.begin(); i != rows.end(); ++i) {
 867                 TimeAxisView *tv = (*i)[_columns.tv];
 868                 (*i)[_columns.visible] = tv->marked_for_display ();
 869         }
 870
 871         /* force route order keys catch up with visibility changes
 872          */
 873
 874         sync_order_keys_from_treeview ();
 875 }
 876
 877 void
 878 EditorRoutes::hide_track_in_display (TimeAxisView& tv)
 879 {
 880         TreeModel::Children rows = _model->children();
 881         TreeModel::Children::iterator i;
 882
 883         for (i = rows.begin(); i != rows.end(); ++i) {
 884                 if ((*i)[_columns.tv] == &tv) {
 885                         tv.set_marked_for_display (false);
 886                         (*i)[_columns.visible] = false;
 887                         redisplay ();
 888                         break;
 889                 }
 890         }
 891 }
 892
 893 void
 894 EditorRoutes::show_track_in_display (TimeAxisView& tv)
 895 {
 896         TreeModel::Children rows = _model->children();
 897         TreeModel::Children::iterator i;
 898
 899
 900         for (i = rows.begin(); i != rows.end(); ++i) {
 901                 if ((*i)[_columns.tv] == &tv) {
 902                         tv.set_marked_for_display (true);
 903                         (*i)[_columns.visible] = true;
 904                         redisplay ();
 905                         break;
 906                 }
 907         }
 908 }
 909
 910 void
 911 EditorRoutes::reset_remote_control_ids ()
 912 {
 913         if (Config->get_remote_model() == UserOrdered || !_session || _session->deletion_in_progress()) {
 914                 return;
 915         }
 916
 917         TreeModel::Children rows = _model->children();
 918
 919         if (rows.empty()) {
 920                 return;
 921         }
 922
 923
 924         DEBUG_TRACE (DEBUG::OrderKeys, "editor reset remote control ids\n");
 925
 926         TreeModel::Children::iterator ri;
 927         bool rid_change = false;
 928         uint32_t rid = 1;
 929         uint32_t invisible_key = UINT32_MAX;
 930
 931         for (ri = rows.begin(); ri != rows.end(); ++ri) {
 932
 933                 /* skip two special values */
 934
 935                 if (rid == Route::MasterBusRemoteControlID) {
 936                         rid++;
 937                 }
 938
 939                 if (rid == Route::MonitorBusRemoteControlID) {
 940                         rid++;
 941                 }
 942
 943                 boost::shared_ptr<Route> route = (*ri)[_columns.route];
 944                 bool visible = (*ri)[_columns.visible];
 945
 946                 if (!route->is_master() && !route->is_monitor()) {
 947
 948                         uint32_t new_rid = (visible ? rid : invisible_key--);
 949
 950                         if (new_rid != route->remote_control_id()) {
 951                                 route->set_remote_control_id_explicit (new_rid);
 952                                 rid_change = true;
 953                         }
 954
 955                         if (visible) {
 956                                 rid++;
 957                         }
 958
 959                 }
 960         }
 961
 962         if (rid_change) {
 963                 /* tell the world that we changed the remote control IDs */
 964                 _session->notify_remote_id_change ();
 965         }
 966 }
 967
 968
 969 void
 970 EditorRoutes::sync_order_keys_from_treeview ()
 971 {
 972         if (_ignore_reorder || !_session || _session->deletion_in_progress()) {
 973                 return;
 974         }
 975
 976         TreeModel::Children rows = _model->children();
 977
 978         if (rows.empty()) {
 979                 return;
 980         }
 981
 982
 983         DEBUG_TRACE (DEBUG::OrderKeys, "editor sync order keys from treeview\n");
 984
 985         TreeModel::Children::iterator ri;
 986         bool changed = false;
 987         bool rid_change = false;
 988         uint32_t order = 0;
 989         uint32_t rid = 1;
 990         uint32_t invisible_key = UINT32_MAX;
 991
 992         for (ri = rows.begin(); ri != rows.end(); ++ri) {
 993
 994                 boost::shared_ptr<Route> route = (*ri)[_columns.route];
 995                 bool visible = (*ri)[_columns.visible];
 996
 997                 uint32_t old_key = route->order_key ();
 998
 999                 if (order != old_key) {
1000                         route->set_order_key (order);
1001
1002                         changed = true;
1003                 }
1004
1005                 if ((Config->get_remote_model() == MixerOrdered) && !route->is_master() && !route->is_monitor()) {
1006
1007                         uint32_t new_rid = (visible ? rid : invisible_key--);
1008
1009                         if (new_rid != route->remote_control_id()) {
1010                                 route->set_remote_control_id_explicit (new_rid);
1011                                 rid_change = true;
1012                         }
1013
1014                         if (visible) {
1015                                 rid++;
1016                         }
1017
1018                 }
1019
1020                 ++order;
1021         }
1022
1023         if (changed) {
1024                 /* tell the world that we changed the editor sort keys */
1025                 _session->sync_order_keys ();
1026         }
1027
1028         if (rid_change) {
1029                 /* tell the world that we changed the remote control IDs */
1030                 _session->notify_remote_id_change ();
1031         }
1032 }
1033
1034 void
1035 EditorRoutes::sync_treeview_from_order_keys ()
1036 {
1037         /* Some route order key(s) have been changed, make sure that
1038            we update out tree/list model and GUI to reflect the change.
1039         */
1040
1041         if (_ignore_reorder || !_session || _session->deletion_in_progress()) {
1042                 return;
1043         }
1044
1045         DEBUG_TRACE (DEBUG::OrderKeys, "editor sync model from order keys.\n");
1046
1047         /* we could get here after either a change in the Mixer or Editor sort
1048          * order, but either way, the mixer order keys reflect the intended
1049          * order for the GUI, so reorder the treeview model to match it.
1050          */
1051
1052         vector<int> neworder;
1053         TreeModel::Children rows = _model->children();
1054         uint32_t old_order = 0;
1055         bool changed = false;
1056
1057         if (rows.empty()) {
1058                 return;
1059         }
1060
1061         OrderingKeys sorted;
1062
1063         for (TreeModel::Children::iterator ri = rows.begin(); ri != rows.end(); ++ri, ++old_order) {
1064                 boost::shared_ptr<Route> route = (*ri)[_columns.route];
1065                 sorted.push_back (OrderKeys (old_order, route->order_key ()));
1066         }
1067
1068         SortByNewDisplayOrder cmp;
1069
1070         sort (sorted.begin(), sorted.end(), cmp);
1071         neworder.assign (sorted.size(), 0);
1072
1073         uint32_t n = 0;
1074
1075         for (OrderingKeys::iterator sr = sorted.begin(); sr != sorted.end(); ++sr, ++n) {
1076
1077                 neworder[n] = sr->old_display_order;
1078
1079                 if (sr->old_display_order != n) {
1080                         changed = true;
1081                 }
1082
1083                 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("EDITOR change order from %1 to %2\n",
1084                                                                sr->old_display_order, n));
1085         }
1086
1087         if (changed) {
1088                 Unwinder<bool> uw (_ignore_reorder, true);
1089                 _model->reorder (neworder);
1090         }
1091
1092         redisplay ();
1093 }
1094
1095 void
1096 EditorRoutes::hide_all_tracks (bool /*with_select*/)
1097 {
1098         TreeModel::Children rows = _model->children();
1099         TreeModel::Children::iterator i;
1100
1101         DisplaySuspender ds;
1102
1103         for (i = rows.begin(); i != rows.end(); ++i) {
1104
1105                 TreeModel::Row row = (*i);
1106                 TimeAxisView *tv = row[_columns.tv];
1107
1108                 if (tv == 0) {
1109                         continue;
1110                 }
1111
1112                 row[_columns.visible] = false;
1113         }
1114 }
1115
1116 void
1117 EditorRoutes::set_all_tracks_visibility (bool yn)
1118 {
1119         TreeModel::Children rows = _model->children();
1120         TreeModel::Children::iterator i;
1121
1122         DisplaySuspender ds;
1123
1124         for (i = rows.begin(); i != rows.end(); ++i) {
1125
1126                 TreeModel::Row row = (*i);
1127                 TimeAxisView* tv = row[_columns.tv];
1128
1129                 if (tv == 0) {
1130                         continue;
1131                 }
1132
1133                 tv->set_marked_for_display (yn);
1134                 (*i)[_columns.visible] = yn;
1135         }
1136
1137         /* force route order keys catch up with visibility changes
1138          */
1139
1140         sync_order_keys_from_treeview ();
1141 }
1142
1143 void
1144 EditorRoutes::set_all_audio_midi_visibility (int tracks, bool yn)
1145 {
1146         TreeModel::Children rows = _model->children();
1147         TreeModel::Children::iterator i;
1148
1149         DisplaySuspender ds;
1150
1151         for (i = rows.begin(); i != rows.end(); ++i) {
1152
1153                 TreeModel::Row row = (*i);
1154                 TimeAxisView* tv = row[_columns.tv];
1155
1156                 AudioTimeAxisView* atv;
1157                 MidiTimeAxisView* mtv;
1158
1159                 if (tv == 0) {
1160                         continue;
1161                 }
1162
1163                 if ((atv = dynamic_cast<AudioTimeAxisView*>(tv)) != 0) {
1164                         switch (tracks) {
1165                         case 0:
1166                                 atv->set_marked_for_display (yn);
1167                                 (*i)[_columns.visible] = yn;
1168                                 break;
1169
1170                         case 1:
1171                                 if (atv->is_audio_track()) {
1172                                         atv->set_marked_for_display (yn);
1173                                         (*i)[_columns.visible] = yn;
1174                                 }
1175                                 break;
1176
1177                         case 2:
1178                                 if (!atv->is_audio_track()) {
1179                                         atv->set_marked_for_display (yn);
1180                                         (*i)[_columns.visible] = yn;
1181                                 }
1182                                 break;
1183                         }
1184                 }
1185                 else if ((mtv = dynamic_cast<MidiTimeAxisView*>(tv)) != 0) {
1186                         switch (tracks) {
1187                         case 0:
1188                                 mtv->set_marked_for_display (yn);
1189                                 (*i)[_columns.visible] = yn;
1190                                 break;
1191
1192                         case 3:
1193                                 if (mtv->is_midi_track()) {
1194                                         mtv->set_marked_for_display (yn);
1195                                         (*i)[_columns.visible] = yn;
1196                                 }
1197                                 break;
1198                         }
1199                 }
1200         }
1201
1202         /* force route order keys catch up with visibility changes
1203          */
1204
1205         sync_order_keys_from_treeview ();
1206 }
1207
1208 void
1209 EditorRoutes::hide_all_routes ()
1210 {
1211         set_all_tracks_visibility (false);
1212 }
1213
1214 void
1215 EditorRoutes::show_all_routes ()
1216 {
1217         set_all_tracks_visibility (true);
1218 }
1219
1220 void
1221 EditorRoutes::show_all_audiotracks()
1222 {
1223         set_all_audio_midi_visibility (1, true);
1224 }
1225 void
1226 EditorRoutes::hide_all_audiotracks ()
1227 {
1228         set_all_audio_midi_visibility (1, false);
1229 }
1230
1231 void
1232 EditorRoutes::show_all_audiobus ()
1233 {
1234         set_all_audio_midi_visibility (2, true);
1235 }
1236 void
1237 EditorRoutes::hide_all_audiobus ()
1238 {
1239         set_all_audio_midi_visibility (2, false);
1240 }
1241
1242 void
1243 EditorRoutes::show_all_miditracks()
1244 {
1245         set_all_audio_midi_visibility (3, true);
1246 }
1247 void
1248 EditorRoutes::hide_all_miditracks ()
1249 {
1250         set_all_audio_midi_visibility (3, false);
1251 }
1252
1253 bool
1254 EditorRoutes::key_press (GdkEventKey* ev)
1255 {
1256         TreeViewColumn *col;
1257         boost::shared_ptr<RouteList> rl (new RouteList);
1258         TreePath path;
1259
1260         switch (ev->keyval) {
1261                 case GDK_Tab:
1262                 case GDK_ISO_Left_Tab:
1263
1264                         /* If we appear to be editing something, leave that cleanly and appropriately. */
1265                         if (name_editable) {
1266                                 name_editable->editing_done ();
1267                                 name_editable = 0;
1268                         }
1269
1270                         col = _display.get_column (_name_column); // select&focus on name column
1271
1272                         if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
1273                                 treeview_select_previous (_display, _model, col);
1274                         } else {
1275                                 treeview_select_next (_display, _model, col);
1276                         }
1277
1278                         return true;
1279                         break;
1280
1281                 case 'm':
1282                         if (get_relevant_routes (rl)) {
1283                                 _session->set_mute (rl, !rl->front()->muted(), Session::rt_cleanup);
1284                         }
1285                         return true;
1286                         break;
1287
1288                 case 's':
1289                         if (get_relevant_routes (rl)) {
1290                                 if (Config->get_solo_control_is_listen_control()) {
1291                                         _session->set_listen (rl, !rl->front()->listening_via_monitor(), Session::rt_cleanup);
1292                                 } else {
1293                                         _session->set_solo (rl, !rl->front()->self_soloed(), Session::rt_cleanup);
1294                                 }
1295                         }
1296                         return true;
1297                         break;
1298
1299                 case 'r':
1300                         if (get_relevant_routes (rl)) {
1301                                 _session->set_record_enabled (rl, !rl->front()->record_enabled(), Session::rt_cleanup);
1302                         }
1303                         break;
1304
1305                 default:
1306                         break;
1307         }
1308
1309         return false;
1310 }
1311
1312 bool
1313 EditorRoutes::get_relevant_routes (boost::shared_ptr<RouteList> rl)
1314 {
1315         TimeAxisView* tv;
1316         RouteTimeAxisView* rtv;
1317         RefPtr<TreeSelection> selection = _display.get_selection();
1318         TreePath path;
1319         TreeIter iter;
1320
1321         if (selection->count_selected_rows() != 0) {
1322
1323                 /* use selection */
1324
1325                 RefPtr<TreeModel> tm = RefPtr<TreeModel>::cast_dynamic (_model);
1326                 iter = selection->get_selected (tm);
1327
1328         } else {
1329                 /* use mouse pointer */
1330
1331                 int x, y;
1332                 int bx, by;
1333
1334                 _display.get_pointer (x, y);
1335                 _display.convert_widget_to_bin_window_coords (x, y, bx, by);
1336
1337                 if (_display.get_path_at_pos (bx, by, path)) {
1338                         iter = _model->get_iter (path);
1339                 }
1340         }
1341
1342         if (iter) {
1343                 tv = (*iter)[_columns.tv];
1344                 if (tv) {
1345                         rtv = dynamic_cast<RouteTimeAxisView*>(tv);
1346                         if (rtv) {
1347                                 rl->push_back (rtv->route());
1348                         }
1349                 }
1350         }
1351
1352         return !rl->empty();
1353 }
1354
1355 bool
1356 EditorRoutes::button_press (GdkEventButton* ev)
1357 {
1358         if (Keyboard::is_context_menu_event (ev)) {
1359                 show_menu ();
1360                 return true;
1361         }
1362
1363         TreeModel::Path path;
1364         TreeViewColumn *tvc;
1365         int cell_x;
1366         int cell_y;
1367
1368         if (!_display.get_path_at_pos ((int) ev->x, (int) ev->y, path, tvc, cell_x, cell_y)) {
1369                 /* cancel selection */
1370                 _display.get_selection()->unselect_all ();
1371                 /* end any editing by grabbing focus */
1372                 _display.grab_focus ();
1373                 return true;
1374         }
1375
1376         //Scroll editor canvas to selected track
1377         if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
1378
1379                 Gtk::TreeModel::Row row = *_model->get_iter (path);
1380                 TimeAxisView *tv = row[_columns.tv];
1381
1382                 if (tv) {
1383                         _editor->ensure_time_axis_view_is_visible (*tv, true);
1384                 }
1385         }
1386
1387         return false;
1388 }
1389
1390 void
1391 EditorRoutes::selection_changed ()
1392 {
1393         _editor->begin_reversible_selection_op (X_("Select Track from Route List"));
1394
1395         if (_display.get_selection()->count_selected_rows() > 0) {
1396
1397                 TreeIter iter;
1398                 TreeView::Selection::ListHandle_Path rows = _display.get_selection()->get_selected_rows ();
1399                 TrackViewList selected;
1400
1401                 _editor->get_selection().clear_regions ();
1402
1403                 for (TreeView::Selection::ListHandle_Path::iterator i = rows.begin(); i != rows.end(); ++i) {
1404
1405                         if ((iter = _model->get_iter (*i))) {
1406
1407                                 TimeAxisView* tv = (*iter)[_columns.tv];
1408                                 selected.push_back (tv);
1409                         }
1410
1411                 }
1412
1413                 _editor->get_selection().set (selected);
1414                 _editor->ensure_time_axis_view_is_visible (*(selected.front()), true);
1415
1416         } else {
1417                 _editor->get_selection().clear_tracks ();
1418         }
1419
1420         _editor->commit_reversible_selection_op ();
1421 }
1422
1423 bool
1424 EditorRoutes::selection_filter (Glib::RefPtr<TreeModel> const &, TreeModel::Path const&, bool /*selected*/)
1425 {
1426         if (selection_countdown) {
1427                 if (--selection_countdown == 0) {
1428                         return true;
1429                 } else {
1430                         /* no selection yet ... */
1431                         return false;
1432                 }
1433         }
1434         return true;
1435 }
1436
1437 struct EditorOrderRouteSorter
1438 {
1439         bool operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b) {
1440                 if (a->is_master()) {
1441                         /* master before everything else */
1442                         return true;
1443                 } else if (b->is_master()) {
1444                         /* everything else before master */
1445                         return false;
1446                 }
1447                 return a->order_key () < b->order_key ();
1448         }
1449 };
1450
1451 void
1452 EditorRoutes::initial_display ()
1453 {
1454         DisplaySuspender ds;
1455         _model->clear ();
1456
1457         if (!_session) {
1458                 return;
1459         }
1460
1461         RouteList r (*_session->get_routes());
1462
1463         r.sort (EditorOrderRouteSorter ());
1464         _editor->add_routes (r);
1465 }
1466
1467 void
1468 EditorRoutes::display_drag_data_received (const RefPtr<Gdk::DragContext>& context,
1469                                              int x, int y,
1470                                              const SelectionData& data,
1471                                              guint info, guint time)
1472 {
1473         if (data.get_target() == "GTK_TREE_MODEL_ROW") {
1474                 _display.on_drag_data_received (context, x, y, data, info, time);
1475                 return;
1476         }
1477
1478         context->drag_finish (true, false, time);
1479 }
1480
1481 void
1482 EditorRoutes::move_selected_tracks (bool up)
1483 {
1484         if (_editor->selection->tracks.empty()) {
1485                 return;
1486         }
1487
1488         typedef std::pair<TimeAxisView*,boost::shared_ptr<Route> > ViewRoute;
1489         std::list<ViewRoute> view_routes;
1490         std::vector<int> neworder;
1491         TreeModel::Children rows = _model->children();
1492         TreeModel::Children::iterator ri;
1493
1494         for (ri = rows.begin(); ri != rows.end(); ++ri) {
1495                 TimeAxisView* tv = (*ri)[_columns.tv];
1496                 boost::shared_ptr<Route> route = (*ri)[_columns.route];
1497
1498                 view_routes.push_back (ViewRoute (tv, route));
1499         }
1500
1501         list<ViewRoute>::iterator trailing;
1502         list<ViewRoute>::iterator leading;
1503
1504         if (up) {
1505
1506                 trailing = view_routes.begin();
1507                 leading = view_routes.begin();
1508
1509                 ++leading;
1510
1511                 while (leading != view_routes.end()) {
1512                         if (_editor->selection->selected (leading->first)) {
1513                                 view_routes.insert (trailing, ViewRoute (leading->first, leading->second));
1514                                 leading = view_routes.erase (leading);
1515                         } else {
1516                                 ++leading;
1517                                 ++trailing;
1518                         }
1519                 }
1520
1521         } else {
1522
1523                 /* if we could use reverse_iterator in list::insert, this code
1524                    would be a beautiful reflection of the code above. but we can't
1525                    and so it looks like a bit of a mess.
1526                 */
1527
1528                 trailing = view_routes.end();
1529                 leading = view_routes.end();
1530
1531                 --leading; if (leading == view_routes.begin()) { return; }
1532                 --leading;
1533                 --trailing;
1534
1535                 while (1) {
1536
1537                         if (_editor->selection->selected (leading->first)) {
1538                                 list<ViewRoute>::iterator tmp;
1539
1540                                 /* need to insert *after* trailing, not *before* it,
1541                                    which is what insert (iter, val) normally does.
1542                                 */
1543
1544                                 tmp = trailing;
1545                                 tmp++;
1546
1547                                 view_routes.insert (tmp, ViewRoute (leading->first, leading->second));
1548
1549                                 /* can't use iter = cont.erase (iter); form here, because
1550                                    we need iter to move backwards.
1551                                 */
1552
1553                                 tmp = leading;
1554                                 --tmp;
1555
1556                                 bool done = false;
1557
1558                                 if (leading == view_routes.begin()) {
1559                                         /* the one we've just inserted somewhere else
1560                                            was the first in the list. erase this copy,
1561                                            and then break, because we're done.
1562                                         */
1563                                         done = true;
1564                                 }
1565
1566                                 view_routes.erase (leading);
1567
1568                                 if (done) {
1569                                         break;
1570                                 }
1571
1572                                 leading = tmp;
1573
1574                         } else {
1575                                 if (leading == view_routes.begin()) {
1576                                         break;
1577                                 }
1578                                 --leading;
1579                                 --trailing;
1580                         }
1581                 };
1582         }
1583
1584         for (leading = view_routes.begin(); leading != view_routes.end(); ++leading) {
1585                 uint32_t order = leading->second->order_key ();
1586                 neworder.push_back (order);
1587         }
1588
1589 #ifndef NDEBUG
1590         DEBUG_TRACE (DEBUG::OrderKeys, "New order after moving tracks:\n");
1591         for (vector<int>::iterator i = neworder.begin(); i != neworder.end(); ++i) {
1592                 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("\t%1\n", *i));
1593         }
1594         DEBUG_TRACE (DEBUG::OrderKeys, "-------\n");
1595
1596         for (vector<int>::iterator i = neworder.begin(); i != neworder.end(); ++i) {
1597                 if (*i >= (int) neworder.size()) {
1598                         cerr << "Trying to move something to " << *i << " of " << neworder.size() << endl;
1599                 }
1600                 assert (*i < (int) neworder.size ());
1601         }
1602 #endif
1603
1604         _model->reorder (neworder);
1605 }
1606
1607 void
1608 EditorRoutes::update_input_active_display ()
1609 {
1610         TreeModel::Children rows = _model->children();
1611         TreeModel::Children::iterator i;
1612
1613         for (i = rows.begin(); i != rows.end(); ++i) {
1614                 boost::shared_ptr<Route> route = (*i)[_columns.route];
1615
1616                 if (boost::dynamic_pointer_cast<Track> (route)) {
1617                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (route);
1618
1619                         if (mt) {
1620                                 (*i)[_columns.is_input_active] = mt->input_active();
1621                         }
1622                 }
1623         }
1624 }
1625
1626 void
1627 EditorRoutes::update_rec_display ()
1628 {
1629         if (g_atomic_int_compare_and_exchange (const_cast<gint*>(&_queue_tv_update), 0, 1)) {
1630                 Glib::signal_idle().connect (sigc::mem_fun (*this, &EditorRoutes::idle_update_mute_rec_solo_etc));
1631         }
1632 }
1633
1634 bool
1635 EditorRoutes::idle_update_mute_rec_solo_etc()
1636 {
1637         g_atomic_int_set (const_cast<gint*>(&_queue_tv_update), 0);
1638         TreeModel::Children rows = _model->children();
1639         TreeModel::Children::iterator i;
1640
1641         for (i = rows.begin(); i != rows.end(); ++i) {
1642                 boost::shared_ptr<Route> route = (*i)[_columns.route];
1643                 (*i)[_columns.mute_state] = RouteUI::mute_active_state (_session, route);
1644                 (*i)[_columns.solo_state] = RouteUI::solo_active_state (route);
1645                 (*i)[_columns.solo_isolate_state] = RouteUI::solo_isolate_active_state (route) ? 1 : 0;
1646                 (*i)[_columns.solo_safe_state] = RouteUI::solo_safe_active_state (route) ? 1 : 0;
1647                 (*i)[_columns.active] = route->active ();
1648                 if (boost::dynamic_pointer_cast<Track> (route)) {
1649                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (route);
1650
1651                         if (route->record_enabled()) {
1652                                 if (_session->record_status() == Session::Recording) {
1653                                         (*i)[_columns.rec_state] = 1;
1654                                 } else {
1655                                         (*i)[_columns.rec_state] = 2;
1656                                 }
1657                         } else if (mt && mt->step_editing()) {
1658                                 (*i)[_columns.rec_state] = 3;
1659                         } else {
1660                                 (*i)[_columns.rec_state] = 0;
1661                         }
1662
1663                         (*i)[_columns.rec_safe] = route->record_safe () ? 1 : 0;
1664                         (*i)[_columns.name_editable] = !route->record_enabled ();
1665                 }
1666         }
1667
1668         return false; // do not call again (until needed)
1669 }
1670
1671
1672 void
1673 EditorRoutes::update_mute_display ()
1674 {
1675         if (g_atomic_int_compare_and_exchange (const_cast<gint*>(&_queue_tv_update), 0, 1)) {
1676                 Glib::signal_idle().connect (sigc::mem_fun (*this, &EditorRoutes::idle_update_mute_rec_solo_etc));
1677         }
1678 }
1679
1680 void
1681 EditorRoutes::update_solo_display ()
1682 {
1683         if (g_atomic_int_compare_and_exchange (const_cast<gint*>(&_queue_tv_update), 0, 1)) {
1684                 Glib::signal_idle().connect (sigc::mem_fun (*this, &EditorRoutes::idle_update_mute_rec_solo_etc));
1685         }
1686 }
1687
1688 void
1689 EditorRoutes::update_solo_isolate_display ()
1690 {
1691         if (g_atomic_int_compare_and_exchange (const_cast<gint*>(&_queue_tv_update), 0, 1)) {
1692                 Glib::signal_idle().connect (sigc::mem_fun (*this, &EditorRoutes::idle_update_mute_rec_solo_etc));
1693         }
1694 }
1695
1696 void
1697 EditorRoutes::update_solo_safe_display ()
1698 {
1699         if (g_atomic_int_compare_and_exchange (const_cast<gint*>(&_queue_tv_update), 0, 1)) {
1700                 Glib::signal_idle().connect (sigc::mem_fun (*this, &EditorRoutes::idle_update_mute_rec_solo_etc));
1701         }
1702 }
1703
1704 list<TimeAxisView*>
1705 EditorRoutes::views () const
1706 {
1707         list<TimeAxisView*> v;
1708         for (TreeModel::Children::iterator i = _model->children().begin(); i != _model->children().end(); ++i) {
1709                 v.push_back ((*i)[_columns.tv]);
1710         }
1711
1712         return v;
1713 }
1714
1715 void
1716 EditorRoutes::clear ()
1717 {
1718         _display.set_model (Glib::RefPtr<Gtk::TreeStore> (0));
1719         _model->clear ();
1720         _display.set_model (_model);
1721 }
1722
1723 void
1724 EditorRoutes::name_edit_started (CellEditable* ce, const Glib::ustring&)
1725 {
1726         name_editable = ce;
1727
1728         /* give it a special name */
1729
1730         Gtk::Entry *e = dynamic_cast<Gtk::Entry*> (ce);
1731
1732         if (e) {
1733                 e->set_name (X_("RouteNameEditorEntry"));
1734         }
1735 }
1736
1737 void
1738 EditorRoutes::name_edit (std::string const & path, std::string const & new_text)
1739 {
1740         name_editable = 0;
1741
1742         TreeIter iter = _model->get_iter (path);
1743
1744         if (!iter) {
1745                 return;
1746         }
1747
1748         boost::shared_ptr<Route> route = (*iter)[_columns.route];
1749
1750         if (route && route->name() != new_text) {
1751                 route->set_name (new_text);
1752         }
1753 }
1754
1755 void
1756 EditorRoutes::solo_changed_so_update_mute ()
1757 {
1758         update_mute_display ();
1759 }
1760
1761 void
1762 EditorRoutes::show_tracks_with_regions_at_playhead ()
1763 {
1764         boost::shared_ptr<RouteList> const r = _session->get_routes_with_regions_at (_session->transport_frame ());
1765
1766         set<TimeAxisView*> show;
1767         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
1768                 TimeAxisView* tav = _editor->axis_view_from_route (*i);
1769                 if (tav) {
1770                         show.insert (tav);
1771                 }
1772         }
1773
1774         DisplaySuspender ds;
1775
1776         TreeModel::Children rows = _model->children ();
1777         for (TreeModel::Children::iterator i = rows.begin(); i != rows.end(); ++i) {
1778                 TimeAxisView* tv = (*i)[_columns.tv];
1779                 bool to_show = (show.find (tv) != show.end());
1780
1781                 tv->set_marked_for_display (to_show);
1782                 (*i)[_columns.visible] = to_show;
1783         }
1784
1785         /* force route order keys catch up with visibility changes
1786          */
1787
1788         sync_order_keys_from_treeview ();
1789 }
1790
1791 int
1792 EditorRoutes::plugin_setup (boost::shared_ptr<Route> r, boost::shared_ptr<PluginInsert> pi, ARDOUR::Route::PluginSetupOptions flags)
1793 {
1794         PluginSetupDialog psd (r, pi, flags);
1795         return psd.run ();
1796 }