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