gtk2_ardour/route_time_axis.cc

   1 /*
   2     Copyright (C) 2006 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17 */
  18
  19 #include <cstdlib>
  20 #include <cmath>
  21 #include <cassert>
  22
  23 #include <algorithm>
  24 #include <string>
  25 #include <vector>
  26 #include <map>
  27 #include <utility>
  28
  29 #include <sigc++/bind.h>
  30
  31 #include "pbd/error.h"
  32 #include "pbd/stl_delete.h"
  33 #include "pbd/whitespace.h"
  34 #include "pbd/memento_command.h"
  35 #include "pbd/enumwriter.h"
  36 #include "pbd/stateful_diff_command.h"
  37
  38 #include <gtkmm/menu.h>
  39 #include <gtkmm/menuitem.h>
  40 #include <gtkmm2ext/gtk_ui.h>
  41 #include <gtkmm2ext/selector.h>
  42 #include <gtkmm2ext/bindable_button.h>
  43 #include <gtkmm2ext/utils.h>
  44
  45 #include "ardour/amp.h"
  46 #include "ardour/meter.h"
  47 #include "ardour/event_type_map.h"
  48 #include "ardour/pannable.h"
  49 #include "ardour/panner.h"
  50 #include "ardour/processor.h"
  51 #include "ardour/profile.h"
  52 #include "ardour/route_group.h"
  53 #include "ardour/session.h"
  54 #include "ardour/session_playlists.h"
  55
  56 #include "evoral/Parameter.hpp"
  57
  58 #include "canvas/debug.h"
  59
  60 #include "ardour_ui.h"
  61 #include "ardour_button.h"
  62 #include "audio_streamview.h"
  63 #include "debug.h"
  64 #include "enums_convert.h"
  65 #include "route_time_axis.h"
  66 #include "automation_time_axis.h"
  67 #include "enums.h"
  68 #include "gui_thread.h"
  69 #include "item_counts.h"
  70 #include "keyboard.h"
  71 #include "paste_context.h"
  72 #include "playlist_selector.h"
  73 #include "point_selection.h"
  74 #include "prompter.h"
  75 #include "public_editor.h"
  76 #include "region_view.h"
  77 #include "rgb_macros.h"
  78 #include "selection.h"
  79 #include "streamview.h"
  80 #include "tooltips.h"
  81 #include "ui_config.h"
  82 #include "utils.h"
  83 #include "route_group_menu.h"
  84
  85 #include "ardour/track.h"
  86
  87 #include "pbd/i18n.h"
  88
  89 using namespace ARDOUR;
  90 using namespace ARDOUR_UI_UTILS;
  91 using namespace PBD;
  92 using namespace Gtkmm2ext;
  93 using namespace Gtk;
  94 using namespace Editing;
  95 using namespace std;
  96 using std::list;
  97
  98 RouteTimeAxisView::RouteTimeAxisView (PublicEditor& ed, Session* sess, ArdourCanvas::Canvas& canvas)
  99         : RouteUI(sess)
 100         , StripableTimeAxisView(ed, sess, canvas)
 101         , _view (0)
 102         , button_table (3, 3)
 103         , route_group_button (S_("RTAV|G"))
 104         , playlist_button (S_("RTAV|P"))
 105         , automation_button (S_("RTAV|A"))
 106         , automation_action_menu (0)
 107         , plugins_submenu_item (0)
 108         , route_group_menu (0)
 109         , playlist_action_menu (0)
 110         , mode_menu (0)
 111         , color_mode_menu (0)
 112         , gm (sess, true, 75, 14)
 113         , _ignore_set_layer_display (false)
 114         , pan_automation_item(NULL)
 115 {
 116         number_label.set_name("tracknumber label");
 117         number_label.set_elements((ArdourButton::Element)(ArdourButton::Edge|ArdourButton::Body|ArdourButton::Text|ArdourButton::Inactive));
 118         number_label.set_alignment(.5, .5);
 119         number_label.set_fallthrough_to_parent (true);
 120
 121         sess->config.ParameterChanged.connect (*this, invalidator (*this), boost::bind (&RouteTimeAxisView::parameter_changed, this, _1), gui_context());
 122         UIConfiguration::instance().ParameterChanged.connect (sigc::mem_fun (*this, &RouteTimeAxisView::parameter_changed));
 123
 124         parameter_changed ("editor-stereo-only-meters");
 125 }
 126
 127 void
 128 RouteTimeAxisView::route_property_changed (const PBD::PropertyChange& what_changed)
 129 {
 130         if (what_changed.contains (ARDOUR::Properties::name)) {
 131                 label_view ();
 132         }
 133 }
 134
 135 void
 136 RouteTimeAxisView::set_route (boost::shared_ptr<Route> rt)
 137 {
 138         RouteUI::set_route (rt);
 139         StripableTimeAxisView::set_stripable (rt);
 140
 141         CANVAS_DEBUG_NAME (_canvas_display, string_compose ("main for %1", rt->name()));
 142         CANVAS_DEBUG_NAME (selection_group, string_compose ("selections for %1", rt->name()));
 143         CANVAS_DEBUG_NAME (_ghost_group, string_compose ("ghosts for %1", rt->name()));
 144
 145         int meter_width = 3;
 146         if (_route && _route->shared_peak_meter()->input_streams().n_total() == 1) {
 147                 meter_width = 6;
 148         }
 149         gm.set_controls (_route, _route->shared_peak_meter(), _route->amp(), _route->gain_control());
 150         gm.get_level_meter().set_no_show_all();
 151         gm.get_level_meter().setup_meters(50, meter_width);
 152         gm.update_gain_sensitive ();
 153
 154         uint32_t height;
 155         if (get_gui_property ("height", height)) {
 156                 set_height (height);
 157         } else {
 158                 set_height (preset_height (HeightNormal));
 159         }
 160
 161         if (!_route->is_auditioner()) {
 162                 if (gui_property ("visible").empty()) {
 163                         set_gui_property ("visible", true);
 164                 }
 165         } else {
 166                 set_gui_property ("visible", false);
 167         }
 168
 169         timestretch_rect = 0;
 170         no_redraw = false;
 171
 172         ignore_toggle = false;
 173
 174         route_group_button.set_name ("route button");
 175         playlist_button.set_name ("route button");
 176         automation_button.set_name ("route button");
 177
 178         route_group_button.signal_button_press_event().connect (sigc::mem_fun(*this, &RouteTimeAxisView::route_group_click), false);
 179         playlist_button.signal_button_press_event().connect (sigc::mem_fun(*this, &RouteTimeAxisView::playlist_click), false);
 180         automation_button.signal_button_press_event().connect (sigc::mem_fun(*this, &RouteTimeAxisView::automation_click), false);
 181
 182         if (is_track()) {
 183
 184                 if (ARDOUR::Profile->get_mixbus()) {
 185                         controls_table.attach (*rec_enable_button, 0, 1, 0, 1, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
 186                 } else {
 187                         controls_table.attach (*rec_enable_button, 2, 3, 0, 1, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
 188                 }
 189
 190                 if (is_midi_track()) {
 191                         set_tooltip(*rec_enable_button, _("Record (Right-click for Step Edit)"));
 192                         gm.set_fader_name ("MidiTrackFader");
 193                 } else {
 194                         set_tooltip(*rec_enable_button, _("Record"));
 195                         gm.set_fader_name ("AudioTrackFader");
 196                 }
 197
 198                 /* set playlist button tip to the current playlist, and make it update when it changes */
 199                 update_playlist_tip ();
 200                 track()->PlaylistChanged.connect (*this, invalidator (*this), ui_bind(&RouteTimeAxisView::update_playlist_tip, this), gui_context());
 201
 202         } else {
 203                 gm.set_fader_name ("AudioBusFader");
 204                 Gtk::Fixed *blank = manage(new Gtk::Fixed());
 205                 controls_button_size_group->add_widget(*blank);
 206                 if (ARDOUR::Profile->get_mixbus() ) {
 207                         controls_table.attach (*blank, 0, 1, 0, 1, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
 208                 } else {
 209                         controls_table.attach (*blank, 2, 3, 0, 1, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
 210                 }
 211                 blank->show();
 212         }
 213
 214         top_hbox.pack_end(gm.get_level_meter(), false, false, 2);
 215
 216         if (!ARDOUR::Profile->get_mixbus()) {
 217                 controls_meters_size_group->add_widget (gm.get_level_meter());
 218         }
 219
 220         if (_route->is_master()) {
 221                 route_group_button.set_sensitive(false);
 222         }
 223
 224         _route->meter_change.connect (*this, invalidator (*this), bind (&RouteTimeAxisView::meter_changed, this), gui_context());
 225         _route->input()->changed.connect (*this, invalidator (*this), boost::bind (&RouteTimeAxisView::io_changed, this, _1, _2), gui_context());
 226         _route->output()->changed.connect (*this, invalidator (*this), boost::bind (&RouteTimeAxisView::io_changed, this, _1, _2), gui_context());
 227         _route->track_number_changed.connect (*this, invalidator (*this), boost::bind (&RouteTimeAxisView::label_view, this), gui_context());
 228
 229         if (ARDOUR::Profile->get_mixbus()) {
 230                 controls_table.attach (*mute_button, 1, 2, 0, 1, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
 231         } else {
 232                 controls_table.attach (*mute_button, 3, 4, 0, 1, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
 233         }
 234         // mute button is always present, it is used to
 235         // force the 'blank' placeholders to the proper size
 236         controls_button_size_group->add_widget(*mute_button);
 237
 238         if (!_route->is_master()) {
 239                 if (ARDOUR::Profile->get_mixbus()) {
 240                         controls_table.attach (*solo_button, 2, 3, 0, 1, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
 241                 } else {
 242                         controls_table.attach (*solo_button, 4, 5, 0, 1, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
 243                 }
 244         } else {
 245                 Gtk::Fixed *blank = manage(new Gtk::Fixed());
 246                 controls_button_size_group->add_widget(*blank);
 247                 if (ARDOUR::Profile->get_mixbus()) {
 248                         controls_table.attach (*blank, 2, 3, 0, 1, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
 249                 } else {
 250                         controls_table.attach (*blank, 4, 5, 0, 1, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
 251                 }
 252                 blank->show();
 253         }
 254
 255         if (ARDOUR::Profile->get_mixbus()) {
 256                 controls_table.attach (route_group_button, 2, 3, 2, 3, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
 257                 controls_table.attach (gm.get_gain_slider(), 3, 5, 2, 3, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 1, 0);
 258         }
 259         else if (!ARDOUR::Profile->get_trx()) {
 260                 controls_table.attach (route_group_button, 4, 5, 2, 3, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
 261                 controls_table.attach (gm.get_gain_slider(), 0, 2, 2, 3, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 1, 0);
 262         }
 263
 264         set_tooltip(*solo_button,_("Solo"));
 265         set_tooltip(*mute_button,_("Mute"));
 266         set_tooltip(route_group_button, _("Route Group"));
 267
 268         mute_button->set_tweaks(ArdourButton::TrackHeader);
 269         solo_button->set_tweaks(ArdourButton::TrackHeader);
 270         rec_enable_button->set_tweaks(ArdourButton::TrackHeader);
 271         playlist_button.set_tweaks(ArdourButton::TrackHeader);
 272         automation_button.set_tweaks(ArdourButton::TrackHeader);
 273         route_group_button.set_tweaks(ArdourButton::TrackHeader);
 274
 275         if (is_midi_track()) {
 276                 set_tooltip(automation_button, _("MIDI Controllers and Automation"));
 277         } else {
 278                 set_tooltip(automation_button, _("Automation"));
 279         }
 280
 281         update_track_number_visibility();
 282         label_view ();
 283
 284         if (ARDOUR::Profile->get_mixbus()) {
 285                 controls_table.attach (automation_button, 1, 2, 2, 3, Gtk::SHRINK, Gtk::SHRINK);
 286         }
 287         else if (!ARDOUR::Profile->get_trx()) {
 288                 controls_table.attach (automation_button, 3, 4, 2, 3, Gtk::SHRINK, Gtk::SHRINK);
 289         }
 290
 291         if (is_track() && track()->mode() == ARDOUR::Normal) {
 292                 if (ARDOUR::Profile->get_mixbus()) {
 293                         controls_table.attach (playlist_button, 0, 1, 2, 3, Gtk::SHRINK, Gtk::SHRINK);
 294                 }
 295                 else if (!ARDOUR::Profile->get_trx()) {
 296                         controls_table.attach (playlist_button, 2, 3, 2, 3, Gtk::SHRINK, Gtk::SHRINK);
 297                 }
 298         }
 299
 300         _y_position = -1;
 301
 302         _route->processors_changed.connect (*this, invalidator (*this), boost::bind (&RouteTimeAxisView::processors_changed, this, _1), gui_context());
 303
 304         if (is_track()) {
 305
 306                 LayerDisplay layer_display;
 307                 if (get_gui_property ("layer-display", layer_display)) {
 308                         set_layer_display (layer_display);
 309                 }
 310
 311                 track()->FreezeChange.connect (*this, invalidator (*this), boost::bind (&RouteTimeAxisView::map_frozen, this), gui_context());
 312                 track()->SpeedChanged.connect (*this, invalidator (*this), boost::bind (&RouteTimeAxisView::speed_changed, this), gui_context());
 313
 314                 /* pick up the correct freeze state */
 315                 map_frozen ();
 316
 317         }
 318
 319         UIConfiguration::instance().ColorsChanged.connect (sigc::mem_fun (*this, &RouteTimeAxisView::color_handler));
 320
 321         PropertyList* plist = new PropertyList();
 322
 323         plist->add (ARDOUR::Properties::group_mute, true);
 324         plist->add (ARDOUR::Properties::group_solo, true);
 325
 326         route_group_menu = new RouteGroupMenu (_session, plist);
 327
 328         gm.get_level_meter().signal_scroll_event().connect (sigc::mem_fun (*this, &RouteTimeAxisView::controls_ebox_scroll), false);
 329 }
 330
 331 RouteTimeAxisView::~RouteTimeAxisView ()
 332 {
 333         cleanup_gui_properties ();
 334
 335         for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
 336                 delete *i;
 337         }
 338
 339         delete playlist_action_menu;
 340         playlist_action_menu = 0;
 341
 342         delete _view;
 343         _view = 0;
 344
 345         _automation_tracks.clear ();
 346
 347         delete route_group_menu;
 348         CatchDeletion (this);
 349 }
 350
 351 string
 352 RouteTimeAxisView::name() const
 353 {
 354         if (_route) {
 355                 return _route->name();
 356         }
 357         return string();
 358 }
 359
 360 void
 361 RouteTimeAxisView::post_construct ()
 362 {
 363         /* map current state of the route */
 364
 365         update_diskstream_display ();
 366         setup_processor_menu_and_curves ();
 367         reset_processor_automation_curves ();
 368 }
 369
 370 /** Set up the processor menu for the current set of processors, and
 371  *  display automation curves for any parameters which have data.
 372  */
 373 void
 374 RouteTimeAxisView::setup_processor_menu_and_curves ()
 375 {
 376         _subplugin_menu_map.clear ();
 377         subplugin_menu.items().clear ();
 378         _route->foreach_processor (sigc::mem_fun (*this, &RouteTimeAxisView::add_processor_to_subplugin_menu));
 379         _route->foreach_processor (sigc::mem_fun (*this, &RouteTimeAxisView::add_existing_processor_automation_curves));
 380 }
 381
 382 bool
 383 RouteTimeAxisView::route_group_click (GdkEventButton *ev)
 384 {
 385         if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
 386                 if (_route->route_group()) {
 387                         _route->route_group()->remove (_route);
 388                 }
 389                 return false;
 390         }
 391
 392         WeakRouteList r;
 393         r.push_back (route ());
 394
 395         route_group_menu->build (r);
 396         if (ev->button == 1) {
 397                 Gtkmm2ext::anchored_menu_popup(route_group_menu->menu(),
 398                                                &route_group_button,
 399                                                "", 1, ev->time);
 400         } else {
 401                 route_group_menu->menu()->popup (ev->button, ev->time);
 402         }
 403
 404         return true;
 405 }
 406
 407 void
 408 RouteTimeAxisView::playlist_changed ()
 409 {
 410         label_view ();
 411 }
 412
 413 void
 414 RouteTimeAxisView::label_view ()
 415 {
 416         string x = _route->name ();
 417         if (x != name_label.get_text ()) {
 418                 name_label.set_text (x);
 419         }
 420         const int64_t track_number = _route->track_number ();
 421         if (track_number == 0) {
 422                 number_label.set_text ("");
 423         } else {
 424                 number_label.set_text (PBD::to_string (abs(_route->track_number ())));
 425         }
 426 }
 427
 428 void
 429 RouteTimeAxisView::update_track_number_visibility ()
 430 {
 431         DisplaySuspender ds;
 432         bool show_label = _session->config.get_track_name_number();
 433
 434         if (_route && _route->is_master()) {
 435                 show_label = false;
 436         }
 437
 438         if (number_label.get_parent()) {
 439                 controls_table.remove (number_label);
 440         }
 441         if (show_label) {
 442                 if (ARDOUR::Profile->get_mixbus()) {
 443                         controls_table.attach (number_label, 3, 4, 0, 1, Gtk::SHRINK, Gtk::EXPAND|Gtk::FILL, 1, 0);
 444                 } else {
 445                         controls_table.attach (number_label, 0, 1, 0, 1, Gtk::SHRINK, Gtk::EXPAND|Gtk::FILL, 1, 0);
 446                 }
 447                 // see ArdourButton::on_size_request(), we should probably use a global size-group here instead.
 448                 // except the width of the number label is subtracted from the name-hbox, so we
 449                 // need to explictly calculate it anyway until the name-label & entry become ArdourWidgets.
 450                 int tnw = (2 + std::max(2u, _session->track_number_decimals())) * number_label.char_pixel_width();
 451                 if (tnw & 1) --tnw;
 452                 number_label.set_size_request(tnw, -1);
 453                 number_label.show ();
 454         } else {
 455                 number_label.hide ();
 456         }
 457 }
 458
 459 void
 460 RouteTimeAxisView::parameter_changed (string const & p)
 461 {
 462         if (p == "track-name-number") {
 463                 update_track_number_visibility();
 464         } else if (p == "editor-stereo-only-meters") {
 465                 if (UIConfiguration::instance().get_editor_stereo_only_meters()) {
 466                         gm.get_level_meter().set_max_audio_meter_count (2);
 467                 } else {
 468                         gm.get_level_meter().set_max_audio_meter_count (0);
 469                 }
 470         }
 471 }
 472
 473 void
 474 RouteTimeAxisView::take_name_changed (void *src)
 475 {
 476         if (src != this) {
 477                 label_view ();
 478         }
 479 }
 480
 481 bool
 482 RouteTimeAxisView::playlist_click (GdkEventButton *ev)
 483 {
 484         if (ev->button != 1) {
 485                 return true;
 486         }
 487
 488         build_playlist_menu ();
 489         conditionally_add_to_selection ();
 490         Gtkmm2ext::anchored_menu_popup(playlist_action_menu, &playlist_button,
 491                                        "", 1, ev->time);
 492         return true;
 493 }
 494
 495 bool
 496 RouteTimeAxisView::automation_click (GdkEventButton *ev)
 497 {
 498         if (ev->button != 1) {
 499                 return true;
 500         }
 501
 502         conditionally_add_to_selection ();
 503         build_automation_action_menu (false);
 504         Gtkmm2ext::anchored_menu_popup(automation_action_menu, &automation_button,
 505                                        "", 1, ev->time);
 506         return true;
 507 }
 508
 509 void
 510 RouteTimeAxisView::build_automation_action_menu (bool for_selection)
 511 {
 512         using namespace Menu_Helpers;
 513
 514         /* detach subplugin_menu from automation_action_menu before we delete automation_action_menu,
 515            otherwise bad things happen (see comment for similar case in MidiTimeAxisView::build_automation_action_menu)
 516         */
 517
 518         detach_menu (subplugin_menu);
 519
 520         _main_automation_menu_map.clear ();
 521         delete automation_action_menu;
 522         automation_action_menu = new Menu;
 523
 524         MenuList& items = automation_action_menu->items();
 525
 526         automation_action_menu->set_name ("ArdourContextMenu");
 527
 528         items.push_back (MenuElem (_("Show All Automation"),
 529                                    sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::show_all_automation), for_selection)));
 530
 531         items.push_back (MenuElem (_("Show Existing Automation"),
 532                                    sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::show_existing_automation), for_selection)));
 533
 534         items.push_back (MenuElem (_("Hide All Automation"),
 535                                    sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::hide_all_automation), for_selection)));
 536
 537         /* Attach the plugin submenu. It may have previously been used elsewhere,
 538            so it was detached above
 539         */
 540
 541         bool single_track_selected = (!for_selection || _editor.get_selection().tracks.size() == 1);
 542
 543         if (!subplugin_menu.items().empty()) {
 544                 items.push_back (SeparatorElem ());
 545                 items.push_back (MenuElem (_("Processor automation"), subplugin_menu));
 546                 items.back().set_sensitive (single_track_selected);
 547         }
 548
 549         /* Add any route automation */
 550
 551         if (gain_track) {
 552                 items.push_back (CheckMenuElem (_("Fader"), sigc::mem_fun (*this, &RouteTimeAxisView::update_gain_track_visibility)));
 553                 gain_automation_item = dynamic_cast<Gtk::CheckMenuItem*> (&items.back ());
 554                 gain_automation_item->set_active (single_track_selected &&
 555                                                   string_to<bool>(gain_track->gui_property ("visible")));
 556
 557                 _main_automation_menu_map[Evoral::Parameter(GainAutomation)] = gain_automation_item;
 558         }
 559
 560         if (trim_track) {
 561                 items.push_back (CheckMenuElem (_("Trim"), sigc::mem_fun (*this, &RouteTimeAxisView::update_trim_track_visibility)));
 562                 trim_automation_item = dynamic_cast<Gtk::CheckMenuItem*> (&items.back ());
 563                 trim_automation_item->set_active (single_track_selected &&
 564                                                   string_to<bool>(trim_track->gui_property ("visible")));
 565
 566                 _main_automation_menu_map[Evoral::Parameter(TrimAutomation)] = trim_automation_item;
 567         }
 568
 569         if (mute_track) {
 570                 items.push_back (CheckMenuElem (_("Mute"), sigc::mem_fun (*this, &RouteTimeAxisView::update_mute_track_visibility)));
 571                 mute_automation_item = dynamic_cast<Gtk::CheckMenuItem*> (&items.back ());
 572                 mute_automation_item->set_active (single_track_selected &&
 573                                                   string_to<bool>(mute_track->gui_property ("visible")));
 574
 575                 _main_automation_menu_map[Evoral::Parameter(MuteAutomation)] = mute_automation_item;
 576         }
 577
 578         if (!pan_tracks.empty() && !ARDOUR::Profile->get_mixbus()) {
 579                 items.push_back (CheckMenuElem (_("Pan"), sigc::mem_fun (*this, &RouteTimeAxisView::update_pan_track_visibility)));
 580                 pan_automation_item = dynamic_cast<Gtk::CheckMenuItem*> (&items.back ());
 581                 pan_automation_item->set_active (single_track_selected &&
 582                                                  string_to<bool>(pan_tracks.front()->gui_property ("visible")));
 583
 584                 set<Evoral::Parameter> const & params = _route->pannable()->what_can_be_automated ();
 585                 for (set<Evoral::Parameter>::const_iterator p = params.begin(); p != params.end(); ++p) {
 586                         _main_automation_menu_map[*p] = pan_automation_item;
 587                 }
 588         }
 589 }
 590
 591 void
 592 RouteTimeAxisView::build_display_menu ()
 593 {
 594         using namespace Menu_Helpers;
 595
 596         /* prepare it */
 597
 598         TimeAxisView::build_display_menu ();
 599
 600         /* now fill it with our stuff */
 601
 602         MenuList& items = display_menu->items();
 603         display_menu->set_name ("ArdourContextMenu");
 604
 605         items.push_back (MenuElem (_("Color..."), sigc::mem_fun (*this, &RouteUI::choose_color)));
 606
 607         items.push_back (MenuElem (_("Comments..."), sigc::mem_fun (*this, &RouteUI::open_comment_editor)));
 608
 609         items.push_back (MenuElem (_("Inputs..."), sigc::mem_fun (*this, &RouteUI::edit_input_configuration)));
 610
 611         items.push_back (MenuElem (_("Outputs..."), sigc::mem_fun (*this, &RouteUI::edit_output_configuration)));
 612
 613         items.push_back (SeparatorElem());
 614
 615         if (_size_menu) {
 616                 detach_menu (*_size_menu);
 617         }
 618         build_size_menu ();
 619         items.push_back (MenuElem (_("Height"), *_size_menu));
 620         items.push_back (SeparatorElem());
 621
 622         // Hook for derived classes to add type specific stuff
 623         append_extra_display_menu_items ();
 624
 625         if (is_track()) {
 626
 627                 Menu* layers_menu = manage (new Menu);
 628                 MenuList &layers_items = layers_menu->items();
 629                 layers_menu->set_name("ArdourContextMenu");
 630
 631                 RadioMenuItem::Group layers_group;
 632
 633                 /* Find out how many overlaid/stacked tracks we have in the selection */
 634
 635                 int overlaid = 0;
 636                 int stacked = 0;
 637                 int unchangeable = 0;
 638                 TrackSelection const & s = _editor.get_selection().tracks;
 639
 640                 for (TrackSelection::const_iterator i = s.begin(); i != s.end(); ++i) {
 641                         StreamView* v = (*i)->view ();
 642                         if (!v) {
 643                                 continue;
 644                         }
 645
 646                         if (v->can_change_layer_display()) {
 647                                 switch (v->layer_display ()) {
 648                                 case Overlaid:
 649                                         ++overlaid;
 650                                         break;
 651                                 case Stacked:
 652                                 case Expanded:
 653                                         ++stacked;
 654                                         break;
 655                                 }
 656                         } else {
 657                                 unchangeable++;
 658                         }
 659                 }
 660
 661                 /* We're not connecting to signal_toggled() here; in the case where these two items are
 662                    set to be in the `inconsistent' state, it seems that one or other will end up active
 663                    as well as inconsistent (presumably due to the RadioMenuItem::Group).  Then when you
 664                    select the active one, no toggled signal is emitted so nothing happens.
 665                 */
 666
 667                 _ignore_set_layer_display = true;
 668
 669                 layers_items.push_back (RadioMenuElem (layers_group, _("Overlaid")));
 670                 RadioMenuItem* i = dynamic_cast<RadioMenuItem*> (&layers_items.back ());
 671                 i->set_active (overlaid != 0 && stacked == 0);
 672                 i->set_inconsistent (overlaid != 0 && stacked != 0);
 673                 i->signal_activate().connect (sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::set_layer_display), Overlaid, true));
 674
 675                 if (unchangeable) {
 676                         i->set_sensitive (false);
 677                 }
 678
 679                 layers_items.push_back (RadioMenuElem (layers_group, _("Stacked")));
 680                 i = dynamic_cast<RadioMenuItem*> (&layers_items.back ());
 681                 i->set_active (overlaid == 0 && stacked != 0);
 682                 i->set_inconsistent (overlaid != 0 && stacked != 0);
 683                 i->signal_activate().connect (sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::set_layer_display), Stacked, true));
 684
 685                 if (unchangeable) {
 686                         i->set_sensitive (false);
 687                 }
 688
 689                 _ignore_set_layer_display = false;
 690
 691                 items.push_back (MenuElem (_("Layers"), *layers_menu));
 692
 693                 Menu* alignment_menu = manage (new Menu);
 694                 MenuList& alignment_items = alignment_menu->items();
 695                 alignment_menu->set_name ("ArdourContextMenu");
 696
 697                 RadioMenuItem::Group align_group;
 698
 699                 /* Same verbose hacks as for the layering options above */
 700
 701                 int existing = 0;
 702                 int capture = 0;
 703                 int automatic = 0;
 704                 int styles = 0;
 705                 boost::shared_ptr<Track> first_track;
 706
 707                 for (TrackSelection::const_iterator t = s.begin(); t != s.end(); ++t) {
 708                         RouteTimeAxisView* r = dynamic_cast<RouteTimeAxisView*> (*t);
 709                         if (!r || !r->is_track ()) {
 710                                 continue;
 711                         }
 712
 713                         if (!first_track) {
 714                                 first_track = r->track();
 715                         }
 716
 717                         switch (r->track()->alignment_choice()) {
 718                         case Automatic:
 719                                 ++automatic;
 720                                 styles |= 0x1;
 721                                 switch (r->track()->alignment_style()) {
 722                                 case ExistingMaterial:
 723                                         ++existing;
 724                                         break;
 725                                 case CaptureTime:
 726                                         ++capture;
 727                                         break;
 728                                 }
 729                                 break;
 730                         case UseExistingMaterial:
 731                                 ++existing;
 732                                 styles |= 0x2;
 733                                 break;
 734                         case UseCaptureTime:
 735                                 ++capture;
 736                                 styles |= 0x4;
 737                                 break;
 738                         }
 739                 }
 740
 741                 bool inconsistent;
 742                 switch (styles) {
 743                 case 1:
 744                 case 2:
 745                 case 4:
 746                         inconsistent = false;
 747                         break;
 748                 default:
 749                         inconsistent = true;
 750                         break;
 751                 }
 752
 753                 if (!inconsistent && first_track) {
 754
 755                         alignment_items.push_back (RadioMenuElem (align_group, _("Automatic (based on I/O connections)")));
 756                         i = dynamic_cast<RadioMenuItem*> (&alignment_items.back());
 757                         i->set_active (automatic != 0 && existing == 0 && capture == 0);
 758                         i->signal_activate().connect (sigc::bind (sigc::mem_fun(*this, &RouteTimeAxisView::set_align_choice), i, Automatic, true));
 759
 760                         switch (first_track->alignment_choice()) {
 761                         case Automatic:
 762                                 switch (first_track->alignment_style()) {
 763                                 case ExistingMaterial:
 764                                         alignment_items.push_back (MenuElem (_("(Currently: Existing Material)")));
 765                                         break;
 766                                 case CaptureTime:
 767                                         alignment_items.push_back (MenuElem (_("(Currently: Capture Time)")));
 768                                         break;
 769                                 }
 770                                 break;
 771                         default:
 772                                 break;
 773                         }
 774
 775                         alignment_items.push_back (RadioMenuElem (align_group, _("Align With Existing Material")));
 776                         i = dynamic_cast<RadioMenuItem*> (&alignment_items.back());
 777                         i->set_active (existing != 0 && capture == 0 && automatic == 0);
 778                         i->signal_activate().connect (sigc::bind (sigc::mem_fun(*this, &RouteTimeAxisView::set_align_choice), i, UseExistingMaterial, true));
 779
 780                         alignment_items.push_back (RadioMenuElem (align_group, _("Align With Capture Time")));
 781                         i = dynamic_cast<RadioMenuItem*> (&alignment_items.back());
 782                         i->set_active (existing == 0 && capture != 0 && automatic == 0);
 783                         i->signal_activate().connect (sigc::bind (sigc::mem_fun(*this, &RouteTimeAxisView::set_align_choice), i, UseCaptureTime, true));
 784
 785                         items.push_back (MenuElem (_("Alignment"), *alignment_menu));
 786
 787                 } else {
 788                         /* show nothing */
 789                 }
 790
 791 #ifdef XXX_OLD_DESTRUCTIVE_API_XXX
 792                 Menu* mode_menu = manage (new Menu);
 793                 MenuList& mode_items = mode_menu->items ();
 794                 mode_menu->set_name ("ArdourContextMenu");
 795
 796                 RadioMenuItem::Group mode_group;
 797
 798                 int normal = 0;
 799                 int tape = 0;
 800                 int non_layered = 0;
 801
 802                 for (TrackSelection::const_iterator t = s.begin(); t != s.end(); ++t) {
 803                         RouteTimeAxisView* r = dynamic_cast<RouteTimeAxisView*> (*t);
 804                         if (!r || !r->is_track ()) {
 805                                 continue;
 806                         }
 807
 808                         switch (r->track()->mode()) {
 809                         case Normal:
 810                                 ++normal;
 811                                 break;
 812                         case Destructive:
 813                                 ++tape;
 814                                 break;
 815                         case NonLayered:
 816                                 ++non_layered;
 817                                 break;
 818                         }
 819                 }
 820
 821                 mode_items.push_back (RadioMenuElem (mode_group, _("Normal Mode")));
 822                 i = dynamic_cast<RadioMenuItem*> (&mode_items.back ());
 823                 i->signal_activate().connect (sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::set_track_mode), ARDOUR::Normal, true));
 824                 i->set_active (normal != 0 && tape == 0 && non_layered == 0);
 825                 i->set_inconsistent (normal != 0 && (tape != 0 || non_layered != 0));
 826
 827                 mode_items.push_back (RadioMenuElem (mode_group, _("Tape Mode")));
 828                 i = dynamic_cast<RadioMenuItem*> (&mode_items.back ());
 829                 i->signal_activate().connect (sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::set_track_mode), ARDOUR::Destructive, true));
 830                 i->set_active (normal == 0 && tape != 0 && non_layered == 0);
 831                 i->set_inconsistent (tape != 0 && (normal != 0 || non_layered != 0));
 832
 833                 mode_items.push_back (RadioMenuElem (mode_group, _("Non-Layered Mode")));
 834                 i = dynamic_cast<RadioMenuItem*> (&mode_items.back ());
 835                 i->signal_activate().connect (sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::set_track_mode), ARDOUR::NonLayered, true));
 836                 i->set_active (normal == 0 && tape == 0 && non_layered != 0);
 837                 i->set_inconsistent (non_layered != 0 && (normal != 0 || tape != 0));
 838
 839                 items.push_back (MenuElem (_("Record Mode"), *mode_menu));
 840 #endif
 841
 842                 items.push_back (SeparatorElem());
 843
 844                 build_playlist_menu ();
 845                 items.push_back (MenuElem (_("Playlist"), *playlist_action_menu));
 846                 items.back().set_sensitive (_editor.get_selection().tracks.size() <= 1);
 847         }
 848
 849         route_group_menu->detach ();
 850
 851         WeakRouteList r;
 852         for (TrackSelection::iterator i = _editor.get_selection().tracks.begin(); i != _editor.get_selection().tracks.end(); ++i) {
 853                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*i);
 854                 if (rtv) {
 855                         r.push_back (rtv->route ());
 856                 }
 857         }
 858
 859         if (r.empty ()) {
 860                 r.push_back (route ());
 861         }
 862
 863         if (!_route->is_master()) {
 864                 route_group_menu->build (r);
 865                 items.push_back (MenuElem (_("Group"), *route_group_menu->menu ()));
 866         }
 867
 868         build_automation_action_menu (true);
 869         items.push_back (MenuElem (_("Automation"), *automation_action_menu));
 870
 871         items.push_back (SeparatorElem());
 872
 873         int active = 0;
 874         int inactive = 0;
 875         TrackSelection const & s = _editor.get_selection().tracks;
 876         for (TrackSelection::const_iterator i = s.begin(); i != s.end(); ++i) {
 877                 RouteTimeAxisView* r = dynamic_cast<RouteTimeAxisView*> (*i);
 878                 if (!r) {
 879                         continue;
 880                 }
 881
 882                 if (r->route()->active()) {
 883                         ++active;
 884                 } else {
 885                         ++inactive;
 886                 }
 887         }
 888
 889         items.push_back (CheckMenuElem (_("Active")));
 890         Gtk::CheckMenuItem* i = dynamic_cast<Gtk::CheckMenuItem *> (&items.back());
 891         bool click_sets_active = true;
 892         if (active > 0 && inactive == 0) {
 893                 i->set_active (true);
 894                 click_sets_active = false;
 895         } else if (active > 0 && inactive > 0) {
 896                 i->set_inconsistent (true);
 897         }
 898         i->set_sensitive(! _session->transport_rolling());
 899         i->signal_activate().connect (sigc::bind (sigc::mem_fun (*this, &RouteUI::set_route_active), click_sets_active, true));
 900
 901         items.push_back (SeparatorElem());
 902         items.push_back (MenuElem (_("Hide"), sigc::bind (sigc::mem_fun(_editor, &PublicEditor::hide_track_in_display), this, true)));
 903         if (_route && !_route->is_master()) {
 904                 items.push_back (SeparatorElem());
 905                 items.push_back (MenuElem (_("Duplicate..."), boost::bind (&ARDOUR_UI::start_duplicate_routes, ARDOUR_UI::instance())));
 906         }
 907         items.push_back (SeparatorElem());
 908         items.push_back (MenuElem (_("Remove"), sigc::mem_fun(_editor, &PublicEditor::remove_tracks)));
 909 }
 910
 911 #ifdef XXX_OLD_DESTRUCTIVE_API_XXX
 912 void
 913 RouteTimeAxisView::set_track_mode (TrackMode mode, bool apply_to_selection)
 914 {
 915         if (apply_to_selection) {
 916                 _editor.get_selection().tracks.foreach_route_time_axis (boost::bind (&RouteTimeAxisView::set_track_mode, _1, mode, false));
 917         } else {
 918
 919                 bool needs_bounce = false;
 920
 921                 if (!track()->can_use_mode (mode, needs_bounce)) {
 922
 923                         if (!needs_bounce) {
 924                                 /* cannot be done */
 925                                 return;
 926                         } else {
 927                                 cerr << "would bounce this one\n";
 928                                 return;
 929                         }
 930                 }
 931
 932                 track()->set_mode (mode);
 933         }
 934 }
 935 #endif
 936
 937 void
 938 RouteTimeAxisView::show_timestretch (framepos_t start, framepos_t end, int layers, int layer)
 939 {
 940         TimeAxisView::show_timestretch (start, end, layers, layer);
 941
 942         hide_timestretch ();
 943
 944 #if 0
 945         if (ts.empty()) {
 946                 return;
 947         }
 948
 949
 950         /* check that the time selection was made in our route, or our route group.
 951            remember that route_group() == 0 implies the route is *not* in a edit group.
 952         */
 953
 954         if (!(ts.track == this || (ts.group != 0 && ts.group == _route->route_group()))) {
 955                 /* this doesn't apply to us */
 956                 return;
 957         }
 958
 959         /* ignore it if our edit group is not active */
 960
 961         if ((ts.track != this) && _route->route_group() && !_route->route_group()->is_active()) {
 962                 return;
 963         }
 964 #endif
 965
 966         if (timestretch_rect == 0) {
 967                 timestretch_rect = new ArdourCanvas::Rectangle (canvas_display ());
 968                 timestretch_rect->set_fill_color (ArdourCanvas::HSV (UIConfiguration::instance().color ("time stretch fill")).mod (UIConfiguration::instance().modifier ("time stretch fill")).color());
 969                 timestretch_rect->set_outline_color (UIConfiguration::instance().color ("time stretch outline"));
 970         }
 971
 972         timestretch_rect->show ();
 973         timestretch_rect->raise_to_top ();
 974
 975         double const x1 = start / _editor.get_current_zoom();
 976         double const x2 = (end - 1) / _editor.get_current_zoom();
 977
 978         timestretch_rect->set (ArdourCanvas::Rect (x1, current_height() * (layers - layer - 1) / layers,
 979                                                    x2, current_height() * (layers - layer) / layers));
 980 }
 981
 982 void
 983 RouteTimeAxisView::hide_timestretch ()
 984 {
 985         TimeAxisView::hide_timestretch ();
 986
 987         if (timestretch_rect) {
 988                 timestretch_rect->hide ();
 989         }
 990 }
 991
 992 void
 993 RouteTimeAxisView::show_selection (TimeSelection& ts)
 994 {
 995
 996 #if 0
 997         /* ignore it if our edit group is not active or if the selection was started
 998            in some other track or route group (remember that route_group() == 0 means
 999            that the track is not in an route group).
1000         */
1001
1002         if (((ts.track != this && !is_child (ts.track)) && _route->route_group() && !_route->route_group()->is_active()) ||
1003             (!(ts.track == this || is_child (ts.track) || (ts.group != 0 && ts.group == _route->route_group())))) {
1004                 hide_selection ();
1005                 return;
1006         }
1007 #endif
1008
1009         TimeAxisView::show_selection (ts);
1010 }
1011
1012 void
1013 RouteTimeAxisView::set_height (uint32_t h, TrackHeightMode m)
1014 {
1015         int gmlen = h - 9;
1016         bool height_changed = (height == 0) || (h != height);
1017
1018         int meter_width = 3;
1019         if (_route && _route->shared_peak_meter()->input_streams().n_total() == 1) {
1020                 meter_width = 6;
1021         }
1022         gm.get_level_meter().setup_meters (gmlen, meter_width);
1023
1024         TimeAxisView::set_height (h, m);
1025
1026         if (_view) {
1027                 _view->set_height ((double) current_height());
1028         }
1029
1030         if (height >= preset_height (HeightNormal)) {
1031
1032                 reset_meter();
1033
1034                 gm.get_gain_slider().show();
1035                 mute_button->show();
1036                 if (!_route || _route->is_monitor()) {
1037                         solo_button->hide();
1038                 } else {
1039                         solo_button->show();
1040                 }
1041                 if (rec_enable_button)
1042                         rec_enable_button->show();
1043
1044                 route_group_button.show();
1045                 automation_button.show();
1046
1047                 if (is_track() && track()->mode() == ARDOUR::Normal) {
1048                         playlist_button.show();
1049                 }
1050
1051         } else {
1052
1053                 reset_meter();
1054
1055                 gm.get_gain_slider().hide();
1056                 mute_button->show();
1057                 if (!_route || _route->is_monitor()) {
1058                         solo_button->hide();
1059                 } else {
1060                         solo_button->show();
1061                 }
1062                 if (rec_enable_button)
1063                         rec_enable_button->show();
1064
1065                 route_group_button.hide ();
1066                 automation_button.hide ();
1067
1068                 if (is_track() && track()->mode() == ARDOUR::Normal) {
1069                         playlist_button.hide ();
1070                 }
1071
1072         }
1073
1074         if (height_changed && !no_redraw) {
1075                 /* only emit the signal if the height really changed */
1076                 request_redraw ();
1077         }
1078 }
1079
1080 void
1081 RouteTimeAxisView::route_color_changed ()
1082 {
1083         if (_view) {
1084                 _view->apply_color (color(), StreamView::RegionColor);
1085         }
1086
1087         number_label.set_fixed_colors (gdk_color_to_rgba (color()), gdk_color_to_rgba (color()));
1088 }
1089
1090 void
1091 RouteTimeAxisView::set_samples_per_pixel (double fpp)
1092 {
1093         double speed = 1.0;
1094
1095         if (track()) {
1096                 speed = track()->speed();
1097         }
1098
1099         if (_view) {
1100                 _view->set_samples_per_pixel (fpp * speed);
1101         }
1102
1103         StripableTimeAxisView::set_samples_per_pixel (fpp * speed);
1104 }
1105
1106 void
1107 RouteTimeAxisView::set_align_choice (RadioMenuItem* mitem, AlignChoice choice, bool apply_to_selection)
1108 {
1109         if (!mitem->get_active()) {
1110                 /* this is one of the two calls made when these radio menu items change status. this one
1111                    is for the item that became inactive, and we want to ignore it.
1112                 */
1113                 return;
1114         }
1115
1116         if (apply_to_selection) {
1117                 _editor.get_selection().tracks.foreach_route_time_axis (boost::bind (&RouteTimeAxisView::set_align_choice, _1, mitem, choice, false));
1118         } else {
1119                 if (track ()) {
1120                         track()->set_align_choice (choice);
1121                 }
1122         }
1123 }
1124
1125 void
1126 RouteTimeAxisView::rename_current_playlist ()
1127 {
1128         ArdourPrompter prompter (true);
1129         string name;
1130
1131         boost::shared_ptr<Track> tr = track();
1132         if (!tr || tr->destructive()) {
1133                 return;
1134         }
1135
1136         boost::shared_ptr<Playlist> pl = tr->playlist();
1137         if (!pl) {
1138                 return;
1139         }
1140
1141         prompter.set_title (_("Rename Playlist"));
1142         prompter.set_prompt (_("New name for playlist:"));
1143         prompter.add_button (_("Rename"), Gtk::RESPONSE_ACCEPT);
1144         prompter.set_initial_text (pl->name());
1145         prompter.set_response_sensitive (Gtk::RESPONSE_ACCEPT, false);
1146
1147         while (true) {
1148                 if (prompter.run () != Gtk::RESPONSE_ACCEPT) {
1149                         break;
1150                 }
1151                 prompter.get_result (name);
1152                 if (name.length()) {
1153                         if (_session->playlists->by_name (name)) {
1154                                 MessageDialog msg (_("Given playlist name is not unique."));
1155                                 msg.run ();
1156                                 prompter.set_initial_text (Playlist::bump_name (name, *_session));
1157                         } else {
1158                                 pl->set_name (name);
1159                                 break;
1160                         }
1161                 }
1162         }
1163 }
1164
1165 std::string
1166 RouteTimeAxisView::resolve_new_group_playlist_name(std::string &basename, vector<boost::shared_ptr<Playlist> > const & playlists)
1167 {
1168         std::string ret (basename);
1169
1170         std::string const group_string = "." + route_group()->name() + ".";
1171
1172         // iterate through all playlists
1173         int maxnumber = 0;
1174         for (vector<boost::shared_ptr<Playlist> >::const_iterator i = playlists.begin(); i != playlists.end(); ++i) {
1175                 std::string tmp = (*i)->name();
1176
1177                 std::string::size_type idx = tmp.find(group_string);
1178                 // find those which belong to this group
1179                 if (idx != string::npos) {
1180                         tmp = tmp.substr(idx + group_string.length());
1181
1182                         // and find the largest current number
1183                         int x = atoi(tmp);
1184                         if (x > maxnumber) {
1185                                 maxnumber = x;
1186                         }
1187                 }
1188         }
1189
1190         maxnumber++;
1191
1192         char buf[32];
1193         snprintf (buf, sizeof(buf), "%d", maxnumber);
1194
1195         ret = this->name() + "." + route_group()->name () + "." + buf;
1196
1197         return ret;
1198 }
1199
1200 void
1201 RouteTimeAxisView::use_new_playlist (bool prompt, vector<boost::shared_ptr<Playlist> > const & playlists_before_op, bool copy)
1202 {
1203         string name;
1204
1205         boost::shared_ptr<Track> tr = track ();
1206         if (!tr || tr->destructive()) {
1207                 return;
1208         }
1209
1210         boost::shared_ptr<const Playlist> pl = tr->playlist();
1211         if (!pl) {
1212                 return;
1213         }
1214
1215         name = pl->name();
1216
1217         if (route_group() && route_group()->is_active() && route_group()->enabled_property (ARDOUR::Properties::group_select.property_id)) {
1218                 name = resolve_new_group_playlist_name(name,playlists_before_op);
1219         }
1220
1221         while (_session->playlists->by_name(name)) {
1222                 name = Playlist::bump_name (name, *_session);
1223         }
1224
1225         if (prompt) {
1226                 // TODO: The prompter "new" button should be de-activated if the user
1227                 // specifies a playlist name which already exists in the session.
1228
1229                 ArdourPrompter prompter (true);
1230
1231                 if (copy) {
1232                         prompter.set_title (_("New Copy Playlist"));
1233                         prompter.set_prompt (_("Name for playlist copy:"));
1234                 } else {
1235                         prompter.set_title (_("New Playlist"));
1236                         prompter.set_prompt (_("Name for new playlist:"));
1237                 }
1238                 prompter.set_initial_text (name);
1239                 prompter.add_button (Gtk::Stock::NEW, Gtk::RESPONSE_ACCEPT);
1240                 prompter.set_response_sensitive (Gtk::RESPONSE_ACCEPT, true);
1241                 prompter.show_all ();
1242
1243                 while (true) {
1244                         if (prompter.run () != Gtk::RESPONSE_ACCEPT) {
1245                                 return;
1246                         }
1247                         prompter.get_result (name);
1248                         if (name.length()) {
1249                                 if (_session->playlists->by_name (name)) {
1250                                         MessageDialog msg (_("Given playlist name is not unique."));
1251                                         msg.run ();
1252                                         prompter.set_initial_text (Playlist::bump_name (name, *_session));
1253                                 } else {
1254                                         break;
1255                                 }
1256                         }
1257                 }
1258         }
1259
1260         if (name.length()) {
1261                 if (copy) {
1262                         tr->use_copy_playlist ();
1263                 } else {
1264                         tr->use_new_playlist ();
1265                 }
1266                 tr->playlist()->set_name (name);
1267         }
1268 }
1269
1270 void
1271 RouteTimeAxisView::clear_playlist ()
1272 {
1273         boost::shared_ptr<Track> tr = track ();
1274         if (!tr || tr->destructive()) {
1275                 return;
1276         }
1277
1278         boost::shared_ptr<Playlist> pl = tr->playlist();
1279         if (!pl) {
1280                 return;
1281         }
1282
1283         _editor.clear_playlist (pl);
1284 }
1285
1286 void
1287 RouteTimeAxisView::speed_changed ()
1288 {
1289         Gtkmm2ext::UI::instance()->call_slot (invalidator (*this), boost::bind (&RouteTimeAxisView::reset_samples_per_pixel, this));
1290 }
1291
1292 void
1293 RouteTimeAxisView::update_diskstream_display ()
1294 {
1295         if (!track()) {
1296                 return;
1297         }
1298
1299         map_frozen ();
1300 }
1301
1302 void
1303 RouteTimeAxisView::selection_click (GdkEventButton* ev)
1304 {
1305         if (Keyboard::modifier_state_equals (ev->state, (Keyboard::TertiaryModifier|Keyboard::PrimaryModifier))) {
1306
1307                 /* special case: select/deselect all tracks */
1308
1309                 _editor.begin_reversible_selection_op (X_("Selection Click"));
1310
1311                 if (_editor.get_selection().selected (this)) {
1312                         _editor.get_selection().clear_tracks ();
1313                 } else {
1314                         _editor.select_all_tracks ();
1315                 }
1316
1317                 _editor.commit_reversible_selection_op ();
1318
1319                 return;
1320         }
1321
1322         _editor.begin_reversible_selection_op (X_("Selection Click"));
1323
1324         switch (ArdourKeyboard::selection_type (ev->state)) {
1325         case Selection::Toggle:
1326                 _editor.get_selection().toggle (this);
1327                 break;
1328
1329         case Selection::Set:
1330                 _editor.get_selection().set (this);
1331                 break;
1332
1333         case Selection::Extend:
1334                 _editor.extend_selection_to_track (*this);
1335                 break;
1336
1337         case Selection::Add:
1338                 _editor.get_selection().add (this);
1339                 break;
1340         }
1341
1342         _editor.commit_reversible_selection_op ();
1343 }
1344
1345 void
1346 RouteTimeAxisView::set_selected_points (PointSelection& points)
1347 {
1348         for (Children::iterator i = children.begin(); i != children.end(); ++i) {
1349                 (*i)->set_selected_points (points);
1350         }
1351         AudioStreamView* asv = dynamic_cast<AudioStreamView*>(_view);
1352         if (asv) {
1353                 asv->set_selected_points (points);
1354         }
1355 }
1356
1357 void
1358 RouteTimeAxisView::set_selected_regionviews (RegionSelection& regions)
1359 {
1360         if (_view) {
1361                 _view->set_selected_regionviews (regions);
1362         }
1363 }
1364
1365 /** Add the selectable things that we have to a list.
1366  * @param results List to add things to.
1367  */
1368 void
1369 RouteTimeAxisView::get_selectables (framepos_t start, framepos_t end, double top, double bot, list<Selectable*>& results, bool within)
1370 {
1371         double speed = 1.0;
1372
1373         if (track() != 0) {
1374                 speed = track()->speed();
1375         }
1376
1377         framepos_t const start_adjusted = session_frame_to_track_frame(start, speed);
1378         framepos_t const end_adjusted   = session_frame_to_track_frame(end, speed);
1379
1380         if ((_view && ((top < 0.0 && bot < 0.0))) || touched (top, bot)) {
1381                 _view->get_selectables (start_adjusted, end_adjusted, top, bot, results, within);
1382         }
1383
1384         /* pick up visible automation tracks */
1385
1386         for (Children::iterator i = children.begin(); i != children.end(); ++i) {
1387                 if (!(*i)->hidden()) {
1388                         (*i)->get_selectables (start_adjusted, end_adjusted, top, bot, results, within);
1389                 }
1390         }
1391 }
1392
1393 void
1394 RouteTimeAxisView::get_inverted_selectables (Selection& sel, list<Selectable*>& results)
1395 {
1396         if (_view) {
1397                 _view->get_inverted_selectables (sel, results);
1398         }
1399
1400         for (Children::iterator i = children.begin(); i != children.end(); ++i) {
1401                 if (!(*i)->hidden()) {
1402                         (*i)->get_inverted_selectables (sel, results);
1403                 }
1404         }
1405
1406         return;
1407 }
1408
1409 RouteGroup*
1410 RouteTimeAxisView::route_group () const
1411 {
1412         return _route->route_group();
1413 }
1414
1415 boost::shared_ptr<Playlist>
1416 RouteTimeAxisView::playlist () const
1417 {
1418         boost::shared_ptr<Track> tr;
1419
1420         if ((tr = track()) != 0) {
1421                 return tr->playlist();
1422         } else {
1423                 return boost::shared_ptr<Playlist> ();
1424         }
1425 }
1426
1427 bool
1428 RouteTimeAxisView::name_entry_changed (string const& str)
1429 {
1430         if (str == _route->name()) {
1431                 return true;
1432         }
1433
1434         string x = str;
1435
1436         strip_whitespace_edges (x);
1437
1438         if (x.empty()) {
1439                 return false;
1440         }
1441
1442         if (_session->route_name_internal (x)) {
1443                 ARDOUR_UI::instance()->popup_error (string_compose (_("The name \"%1\" is reserved for %2"), x, PROGRAM_NAME));
1444                 return false;
1445         } else if (RouteUI::verify_new_route_name (x)) {
1446                 _route->set_name (x);
1447                 return true;
1448         }
1449
1450         return false;
1451 }
1452
1453 boost::shared_ptr<Region>
1454 RouteTimeAxisView::find_next_region (framepos_t pos, RegionPoint point, int32_t dir)
1455 {
1456         boost::shared_ptr<Playlist> pl = playlist ();
1457
1458         if (pl) {
1459                 return pl->find_next_region (pos, point, dir);
1460         }
1461
1462         return boost::shared_ptr<Region> ();
1463 }
1464
1465 framepos_t
1466 RouteTimeAxisView::find_next_region_boundary (framepos_t pos, int32_t dir)
1467 {
1468         boost::shared_ptr<Playlist> pl = playlist ();
1469
1470         if (pl) {
1471                 return pl->find_next_region_boundary (pos, dir);
1472         }
1473
1474         return -1;
1475 }
1476
1477 void
1478 RouteTimeAxisView::fade_range (TimeSelection& selection)
1479 {
1480         boost::shared_ptr<Playlist> what_we_got;
1481         boost::shared_ptr<Track> tr = track ();
1482         boost::shared_ptr<Playlist> playlist;
1483
1484         if (tr == 0) {
1485                 /* route is a bus, not a track */
1486                 return;
1487         }
1488
1489         playlist = tr->playlist();
1490
1491         TimeSelection time (selection);
1492         float const speed = tr->speed();
1493         if (speed != 1.0f) {
1494                 for (TimeSelection::iterator i = time.begin(); i != time.end(); ++i) {
1495                         (*i).start = session_frame_to_track_frame((*i).start, speed);
1496                         (*i).end   = session_frame_to_track_frame((*i).end,   speed);
1497                 }
1498         }
1499
1500         playlist->clear_changes ();
1501         playlist->clear_owned_changes ();
1502
1503         playlist->fade_range (time);
1504
1505         vector<Command*> cmds;
1506         playlist->rdiff (cmds);
1507         _session->add_commands (cmds);
1508         _session->add_command (new StatefulDiffCommand (playlist));
1509
1510 }
1511
1512 void
1513 RouteTimeAxisView::cut_copy_clear (Selection& selection, CutCopyOp op)
1514 {
1515         boost::shared_ptr<Playlist> what_we_got;
1516         boost::shared_ptr<Track> tr = track ();
1517         boost::shared_ptr<Playlist> playlist;
1518
1519         if (tr == 0) {
1520                 /* route is a bus, not a track */
1521                 return;
1522         }
1523
1524         playlist = tr->playlist();
1525
1526         TimeSelection time (selection.time);
1527         float const speed = tr->speed();
1528         if (speed != 1.0f) {
1529                 for (TimeSelection::iterator i = time.begin(); i != time.end(); ++i) {
1530                         (*i).start = session_frame_to_track_frame((*i).start, speed);
1531                         (*i).end   = session_frame_to_track_frame((*i).end,   speed);
1532                 }
1533         }
1534
1535         playlist->clear_changes ();
1536         playlist->clear_owned_changes ();
1537
1538         switch (op) {
1539         case Delete:
1540                 if (playlist->cut (time) != 0) {
1541                         if (Config->get_edit_mode() == Ripple)
1542                                 playlist->ripple(time.start(), -time.length(), NULL);
1543                                 // no need to exclude any regions from rippling here
1544
1545                         vector<Command*> cmds;
1546                         playlist->rdiff (cmds);
1547                         _session->add_commands (cmds);
1548
1549                         _session->add_command (new StatefulDiffCommand (playlist));
1550                 }
1551                 break;
1552
1553         case Cut:
1554                 if ((what_we_got = playlist->cut (time)) != 0) {
1555                         _editor.get_cut_buffer().add (what_we_got);
1556                         if (Config->get_edit_mode() == Ripple)
1557                                 playlist->ripple(time.start(), -time.length(), NULL);
1558                                 // no need to exclude any regions from rippling here
1559
1560                         vector<Command*> cmds;
1561                         playlist->rdiff (cmds);
1562                         _session->add_commands (cmds);
1563
1564                         _session->add_command (new StatefulDiffCommand (playlist));
1565                 }
1566                 break;
1567         case Copy:
1568                 if ((what_we_got = playlist->copy (time)) != 0) {
1569                         _editor.get_cut_buffer().add (what_we_got);
1570                 }
1571                 break;
1572
1573         case Clear:
1574                 if ((what_we_got = playlist->cut (time)) != 0) {
1575                         if (Config->get_edit_mode() == Ripple)
1576                                 playlist->ripple(time.start(), -time.length(), NULL);
1577                                 // no need to exclude any regions from rippling here
1578
1579                         vector<Command*> cmds;
1580                         playlist->rdiff (cmds);
1581                         _session->add_commands (cmds);
1582                         _session->add_command (new StatefulDiffCommand (playlist));
1583                         what_we_got->release ();
1584                 }
1585                 break;
1586         }
1587 }
1588
1589 bool
1590 RouteTimeAxisView::paste (framepos_t pos, const Selection& selection, PasteContext& ctx, const int32_t sub_num)
1591 {
1592         if (!is_track()) {
1593                 return false;
1594         }
1595
1596         boost::shared_ptr<Playlist>       pl   = playlist ();
1597         const ARDOUR::DataType            type = pl->data_type();
1598         PlaylistSelection::const_iterator p    = selection.playlists.get_nth(type, ctx.counts.n_playlists(type));
1599
1600         if (p == selection.playlists.end()) {
1601                 return false;
1602         }
1603         ctx.counts.increase_n_playlists(type);
1604
1605         DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("paste to %1\n", pos));
1606
1607         if (track()->speed() != 1.0f) {
1608                 pos = session_frame_to_track_frame (pos, track()->speed());
1609                 DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("modified paste to %1\n", pos));
1610         }
1611
1612         /* add multi-paste offset if applicable */
1613         std::pair<framepos_t, framepos_t> extent   = (*p)->get_extent();
1614         const framecnt_t                  duration = extent.second - extent.first;
1615         pos += _editor.get_paste_offset(pos, ctx.count, duration);
1616
1617         pl->clear_changes ();
1618         pl->clear_owned_changes ();
1619         if (Config->get_edit_mode() == Ripple) {
1620                 std::pair<framepos_t, framepos_t> extent = (*p)->get_extent_with_endspace();
1621                 framecnt_t amount = extent.second - extent.first;
1622                 pl->ripple(pos, amount * ctx.times, boost::shared_ptr<Region>());
1623         }
1624         pl->paste (*p, pos, ctx.times, sub_num);
1625
1626         vector<Command*> cmds;
1627         pl->rdiff (cmds);
1628         _session->add_commands (cmds);
1629
1630         _session->add_command (new StatefulDiffCommand (pl));
1631
1632         return true;
1633 }
1634
1635
1636 struct PlaylistSorter {
1637     bool operator() (boost::shared_ptr<Playlist> a, boost::shared_ptr<Playlist> b) const {
1638             return a->sort_id() < b->sort_id();
1639     }
1640 };
1641
1642 void
1643 RouteTimeAxisView::build_playlist_menu ()
1644 {
1645         using namespace Menu_Helpers;
1646
1647         if (!is_track()) {
1648                 return;
1649         }
1650
1651         delete playlist_action_menu;
1652         playlist_action_menu = new Menu;
1653         playlist_action_menu->set_name ("ArdourContextMenu");
1654
1655         MenuList& playlist_items = playlist_action_menu->items();
1656         playlist_action_menu->set_name ("ArdourContextMenu");
1657         playlist_items.clear();
1658
1659         RadioMenuItem::Group playlist_group;
1660         boost::shared_ptr<Track> tr = track ();
1661
1662         vector<boost::shared_ptr<Playlist> > playlists_tr = _session->playlists->playlists_for_track (tr);
1663
1664         /* sort the playlists */
1665         PlaylistSorter cmp;
1666         sort (playlists_tr.begin(), playlists_tr.end(), cmp);
1667
1668         /* add the playlists to the menu */
1669         for (vector<boost::shared_ptr<Playlist> >::iterator i = playlists_tr.begin(); i != playlists_tr.end(); ++i) {
1670                 playlist_items.push_back (RadioMenuElem (playlist_group, (*i)->name()));
1671                 RadioMenuItem *item = static_cast<RadioMenuItem*>(&playlist_items.back());
1672                 item->signal_toggled().connect(sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::use_playlist), item, boost::weak_ptr<Playlist> (*i)));
1673
1674                 if (tr->playlist()->id() == (*i)->id()) {
1675                         item->set_active();
1676
1677                 }
1678         }
1679
1680         playlist_items.push_back (SeparatorElem());
1681         playlist_items.push_back (MenuElem (_("Rename..."), sigc::mem_fun(*this, &RouteTimeAxisView::rename_current_playlist)));
1682         playlist_items.push_back (SeparatorElem());
1683
1684         if (!route_group() || !route_group()->is_active() || !route_group()->enabled_property (ARDOUR::Properties::group_select.property_id)) {
1685                 playlist_items.push_back (MenuElem (_("New..."), sigc::bind(sigc::mem_fun(_editor, &PublicEditor::new_playlists), this)));
1686                 playlist_items.push_back (MenuElem (_("New Copy..."), sigc::bind(sigc::mem_fun(_editor, &PublicEditor::copy_playlists), this)));
1687
1688         } else {
1689                 // Use a label which tells the user what is happening
1690                 playlist_items.push_back (MenuElem (_("New Take"), sigc::bind(sigc::mem_fun(_editor, &PublicEditor::new_playlists), this)));
1691                 playlist_items.push_back (MenuElem (_("Copy Take"), sigc::bind(sigc::mem_fun(_editor, &PublicEditor::copy_playlists), this)));
1692
1693         }
1694
1695         playlist_items.push_back (SeparatorElem());
1696         playlist_items.push_back (MenuElem (_("Clear Current"), sigc::bind(sigc::mem_fun(_editor, &PublicEditor::clear_playlists), this)));
1697         playlist_items.push_back (SeparatorElem());
1698
1699         playlist_items.push_back (MenuElem(_("Select from All..."), sigc::mem_fun(*this, &RouteTimeAxisView::show_playlist_selector)));
1700 }
1701
1702 void
1703 RouteTimeAxisView::use_playlist (RadioMenuItem *item, boost::weak_ptr<Playlist> wpl)
1704 {
1705         assert (is_track());
1706
1707         // exit if we were triggered by deactivating the old playlist
1708         if (!item->get_active()) {
1709                 return;
1710         }
1711
1712         boost::shared_ptr<Playlist> pl (wpl.lock());
1713
1714         if (!pl) {
1715                 return;
1716         }
1717
1718         if (track()->playlist() == pl) {
1719                 // exit when use_playlist is called by the creation of the playlist menu
1720                 // or the playlist choice is unchanged
1721                 return;
1722         }
1723
1724         track()->use_playlist (pl);
1725
1726         RouteGroup* rg = route_group();
1727
1728         if (rg && rg->is_active() && rg->enabled_property (ARDOUR::Properties::group_select.property_id)) {
1729                 std::string group_string = "." + rg->name() + ".";
1730
1731                 std::string take_name = pl->name();
1732                 std::string::size_type idx = take_name.find(group_string);
1733
1734                 if (idx == std::string::npos)
1735                         return;
1736
1737                 take_name = take_name.substr(idx + group_string.length()); // find the bit containing the take number / name
1738
1739                 boost::shared_ptr<RouteList> rl (rg->route_list());
1740
1741                 for (RouteList::const_iterator i = rl->begin(); i != rl->end(); ++i) {
1742                         if ((*i) == this->route()) {
1743                                 continue;
1744                         }
1745
1746                         std::string playlist_name = (*i)->name()+group_string+take_name;
1747
1748                         boost::shared_ptr<Track> track = boost::dynamic_pointer_cast<Track>(*i);
1749                         if (!track) {
1750                                 continue;
1751                         }
1752
1753                         if (track->freeze_state() == Track::Frozen) {
1754                                 /* Don't change playlists of frozen tracks */
1755                                 continue;
1756                         }
1757
1758                         boost::shared_ptr<Playlist> ipl = session()->playlists->by_name(playlist_name);
1759                         if (!ipl) {
1760                                 // No playlist for this track for this take yet, make it
1761                                 track->use_new_playlist();
1762                                 track->playlist()->set_name(playlist_name);
1763                         } else {
1764                                 track->use_playlist(ipl);
1765                         }
1766                 }
1767         }
1768 }
1769
1770 void
1771 RouteTimeAxisView::update_playlist_tip ()
1772 {
1773         RouteGroup* rg = route_group ();
1774         if (rg && rg->is_active() && rg->enabled_property (ARDOUR::Properties::group_select.property_id)) {
1775                 string group_string = "." + rg->name() + ".";
1776
1777                 string take_name = track()->playlist()->name();
1778                 string::size_type idx = take_name.find(group_string);
1779
1780                 if (idx != string::npos) {
1781                         /* find the bit containing the take number / name */
1782                         take_name = take_name.substr (idx + group_string.length());
1783
1784                         /* set the playlist button tooltip to the take name */
1785                         set_tooltip (
1786                                 playlist_button,
1787                                 string_compose(_("Take: %1.%2"),
1788                                         Gtkmm2ext::markup_escape_text (rg->name()),
1789                                         Gtkmm2ext::markup_escape_text (take_name))
1790                                 );
1791
1792                         return;
1793                 }
1794         }
1795
1796         /* set the playlist button tooltip to the playlist name */
1797         set_tooltip (playlist_button, _("Playlist") + std::string(": ") + Gtkmm2ext::markup_escape_text (track()->playlist()->name()));
1798 }
1799
1800
1801 void
1802 RouteTimeAxisView::show_playlist_selector ()
1803 {
1804         _editor.playlist_selector().show_for (this);
1805 }
1806
1807 void
1808 RouteTimeAxisView::map_frozen ()
1809 {
1810         if (!is_track()) {
1811                 return;
1812         }
1813
1814         ENSURE_GUI_THREAD (*this, &RouteTimeAxisView::map_frozen)
1815
1816         switch (track()->freeze_state()) {
1817         case Track::Frozen:
1818                 playlist_button.set_sensitive (false);
1819                 break;
1820         default:
1821                 playlist_button.set_sensitive (true);
1822                 break;
1823         }
1824         RouteUI::map_frozen ();
1825 }
1826
1827 void
1828 RouteTimeAxisView::color_handler ()
1829 {
1830         //case cTimeStretchOutline:
1831         if (timestretch_rect) {
1832                 timestretch_rect->set_outline_color (UIConfiguration::instance().color ("time stretch outline"));
1833         }
1834         //case cTimeStretchFill:
1835         if (timestretch_rect) {
1836                 timestretch_rect->set_fill_color (UIConfiguration::instance().color ("time stretch fill"));
1837         }
1838
1839         reset_meter();
1840 }
1841
1842 /** Toggle an automation track for a fully-specified Parameter (type,channel,id)
1843  *  Will add track if necessary.
1844  */
1845 void
1846 RouteTimeAxisView::toggle_automation_track (const Evoral::Parameter& param)
1847 {
1848         boost::shared_ptr<AutomationTimeAxisView> track = automation_child (param);
1849         Gtk::CheckMenuItem* menu = automation_child_menu_item (param);
1850
1851         if (!track) {
1852                 /* it doesn't exist yet, so we don't care about the button state: just add it */
1853                 create_automation_child (param, true);
1854         } else {
1855                 assert (menu);
1856                 bool yn = menu->get_active();
1857                 bool changed = false;
1858
1859                 if ((changed = track->set_marked_for_display (menu->get_active())) && yn) {
1860
1861                         /* we made it visible, now trigger a redisplay. if it was hidden, then automation_track_hidden()
1862                            will have done that for us.
1863                         */
1864
1865                         if (changed && !no_redraw) {
1866                                 request_redraw ();
1867                         }
1868                 }
1869         }
1870 }
1871
1872 void
1873 RouteTimeAxisView::update_pan_track_visibility ()
1874 {
1875         bool const showit = pan_automation_item->get_active();
1876         bool changed = false;
1877
1878         for (list<boost::shared_ptr<AutomationTimeAxisView> >::iterator i = pan_tracks.begin(); i != pan_tracks.end(); ++i) {
1879                 if ((*i)->set_marked_for_display (showit)) {
1880                         changed = true;
1881                 }
1882         }
1883
1884         if (changed) {
1885                 _route->gui_changed (X_("visible_tracks"), (void *) 0); /* EMIT_SIGNAL */
1886         }
1887 }
1888
1889 void
1890 RouteTimeAxisView::ensure_pan_views (bool show)
1891 {
1892         bool changed = false;
1893         for (list<boost::shared_ptr<AutomationTimeAxisView> >::iterator i = pan_tracks.begin(); i != pan_tracks.end(); ++i) {
1894                 changed = true;
1895                 (*i)->set_marked_for_display (false);
1896         }
1897         if (changed) {
1898                 _route->gui_changed (X_("visible_tracks"), (void *) 0); /* EMIT_SIGNAL */
1899         }
1900         pan_tracks.clear();
1901
1902         if (!_route->panner()) {
1903                 return;
1904         }
1905
1906         set<Evoral::Parameter> params = _route->panner()->what_can_be_automated();
1907         set<Evoral::Parameter>::iterator p;
1908
1909         for (p = params.begin(); p != params.end(); ++p) {
1910                 boost::shared_ptr<ARDOUR::AutomationControl> pan_control = _route->pannable()->automation_control(*p);
1911
1912                 if (pan_control->parameter().type() == NullAutomation) {
1913                         error << "Pan control has NULL automation type!" << endmsg;
1914                         continue;
1915                 }
1916
1917                 if (automation_child (pan_control->parameter ()).get () == 0) {
1918
1919                         /* we don't already have an AutomationTimeAxisView for this parameter */
1920
1921                         std::string const name = _route->panner()->describe_parameter (pan_control->parameter ());
1922
1923                         boost::shared_ptr<AutomationTimeAxisView> t (
1924                                         new AutomationTimeAxisView (_session,
1925                                                 _route,
1926                                                 _route->pannable(),
1927                                                 pan_control,
1928                                                 pan_control->parameter (),
1929                                                 _editor,
1930                                                 *this,
1931                                                 false,
1932                                                 parent_canvas,
1933                                                 name)
1934                                         );
1935
1936                         pan_tracks.push_back (t);
1937                         add_automation_child (*p, t, show);
1938                 } else {
1939                         pan_tracks.push_back (automation_child (pan_control->parameter ()));
1940                 }
1941         }
1942 }
1943
1944
1945 void
1946 RouteTimeAxisView::show_all_automation (bool apply_to_selection)
1947 {
1948         if (apply_to_selection) {
1949                 _editor.get_selection().tracks.foreach_route_time_axis (boost::bind (&RouteTimeAxisView::show_all_automation, _1, false));
1950         } else {
1951                 no_redraw = true;
1952
1953                 StripableTimeAxisView::show_all_automation ();
1954
1955                 /* Show processor automation */
1956
1957                 for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
1958                         for (vector<ProcessorAutomationNode*>::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) {
1959                                 if ((*ii)->view == 0) {
1960                                         add_processor_automation_curve ((*i)->processor, (*ii)->what);
1961                                 }
1962
1963                                 (*ii)->menu_item->set_active (true);
1964                         }
1965                 }
1966
1967                 no_redraw = false;
1968
1969                 /* Redraw */
1970
1971                 request_redraw ();
1972         }
1973 }
1974
1975 void
1976 RouteTimeAxisView::show_existing_automation (bool apply_to_selection)
1977 {
1978         if (apply_to_selection) {
1979                 _editor.get_selection().tracks.foreach_route_time_axis (boost::bind (&RouteTimeAxisView::show_existing_automation, _1, false));
1980         } else {
1981                 no_redraw = true;
1982
1983                 StripableTimeAxisView::show_existing_automation ();
1984
1985                 /* Show processor automation */
1986                 for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
1987                         for (vector<ProcessorAutomationNode*>::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) {
1988                                 if ((*i)->processor->control((*ii)->what)->list()->size() > 0) {
1989                                         (*ii)->menu_item->set_active (true);
1990                                 }
1991                         }
1992                 }
1993
1994                 no_redraw = false;
1995                 request_redraw ();
1996         }
1997 }
1998
1999 void
2000 RouteTimeAxisView::hide_all_automation (bool apply_to_selection)
2001 {
2002         if (apply_to_selection) {
2003                 _editor.get_selection().tracks.foreach_route_time_axis (boost::bind (&RouteTimeAxisView::hide_all_automation, _1, false));
2004         } else {
2005                 no_redraw = true;
2006                 StripableTimeAxisView::hide_all_automation ();
2007
2008                 /* Hide processor automation */
2009                 for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
2010                         for (vector<ProcessorAutomationNode*>::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) {
2011                                 (*ii)->menu_item->set_active (false);
2012                         }
2013                 }
2014
2015                 no_redraw = false;
2016                 request_redraw ();
2017         }
2018 }
2019
2020 void
2021 RouteTimeAxisView::region_view_added (RegionView* rv)
2022 {
2023         /* XXX need to find out if automation children have automationstreamviews. If yes, no ghosts */
2024         for (Children::iterator i = children.begin(); i != children.end(); ++i) {
2025                 boost::shared_ptr<AutomationTimeAxisView> atv;
2026
2027                 if ((atv = boost::dynamic_pointer_cast<AutomationTimeAxisView> (*i)) != 0) {
2028                         atv->add_ghost(rv);
2029                 }
2030         }
2031
2032         for (UnderlayMirrorList::iterator i = _underlay_mirrors.begin(); i != _underlay_mirrors.end(); ++i) {
2033                 (*i)->add_ghost(rv);
2034         }
2035 }
2036
2037 RouteTimeAxisView::ProcessorAutomationInfo::~ProcessorAutomationInfo ()
2038 {
2039         for (vector<ProcessorAutomationNode*>::iterator i = lines.begin(); i != lines.end(); ++i) {
2040                 delete *i;
2041         }
2042 }
2043
2044
2045 RouteTimeAxisView::ProcessorAutomationNode::~ProcessorAutomationNode ()
2046 {
2047         parent.remove_processor_automation_node (this);
2048 }
2049
2050 void
2051 RouteTimeAxisView::remove_processor_automation_node (ProcessorAutomationNode* pan)
2052 {
2053         if (pan->view) {
2054                 remove_child (pan->view);
2055         }
2056 }
2057
2058 RouteTimeAxisView::ProcessorAutomationNode*
2059 RouteTimeAxisView::find_processor_automation_node (boost::shared_ptr<Processor> processor, Evoral::Parameter what)
2060 {
2061         for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
2062
2063                 if ((*i)->processor == processor) {
2064
2065                         for (vector<ProcessorAutomationNode*>::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) {
2066                                 if ((*ii)->what == what) {
2067                                         return *ii;
2068                                 }
2069                         }
2070                 }
2071         }
2072
2073         return 0;
2074 }
2075
2076 /** Add an AutomationTimeAxisView to display automation for a processor's parameter */
2077 void
2078 RouteTimeAxisView::add_processor_automation_curve (boost::shared_ptr<Processor> processor, Evoral::Parameter what)
2079 {
2080         string name;
2081         ProcessorAutomationNode* pan;
2082
2083         if ((pan = find_processor_automation_node (processor, what)) == 0) {
2084                 /* session state may never have been saved with new plugin */
2085                 error << _("programming error: ")
2086                       << string_compose (X_("processor automation curve for %1:%2/%3/%4 not registered with track!"),
2087                                          processor->name(), what.type(), (int) what.channel(), what.id() )
2088                       << endmsg;
2089                 abort(); /*NOTREACHED*/
2090                 return;
2091         }
2092
2093         if (pan->view) {
2094                 return;
2095         }
2096
2097         boost::shared_ptr<AutomationControl> control
2098                 = boost::dynamic_pointer_cast<AutomationControl>(processor->control(what, true));
2099
2100         pan->view = boost::shared_ptr<AutomationTimeAxisView>(
2101                 new AutomationTimeAxisView (_session, _route, processor, control, control->parameter (),
2102                                             _editor, *this, false, parent_canvas,
2103                                             processor->describe_parameter (what), processor->name()));
2104
2105         pan->view->Hiding.connect (sigc::bind (sigc::mem_fun(*this, &RouteTimeAxisView::processor_automation_track_hidden), pan, processor));
2106
2107         add_automation_child (control->parameter(), pan->view, pan->view->marked_for_display ());
2108
2109         if (_view) {
2110                 _view->foreach_regionview (sigc::mem_fun(*pan->view.get(), &TimeAxisView::add_ghost));
2111         }
2112 }
2113
2114 void
2115 RouteTimeAxisView::processor_automation_track_hidden (RouteTimeAxisView::ProcessorAutomationNode* pan, boost::shared_ptr<Processor>)
2116 {
2117         if (!_hidden) {
2118                 pan->menu_item->set_active (false);
2119         }
2120
2121         if (!no_redraw) {
2122                 request_redraw ();
2123         }
2124 }
2125
2126 void
2127 RouteTimeAxisView::add_existing_processor_automation_curves (boost::weak_ptr<Processor> p)
2128 {
2129         boost::shared_ptr<Processor> processor (p.lock ());
2130
2131         if (!processor || boost::dynamic_pointer_cast<Amp> (processor)) {
2132                 /* The Amp processor is a special case and is dealt with separately */
2133                 return;
2134         }
2135
2136         set<Evoral::Parameter> existing;
2137
2138         processor->what_has_data (existing);
2139
2140         for (set<Evoral::Parameter>::iterator i = existing.begin(); i != existing.end(); ++i) {
2141
2142                 Evoral::Parameter param (*i);
2143                 boost::shared_ptr<AutomationLine> al;
2144
2145                 if ((al = find_processor_automation_curve (processor, param)) != 0) {
2146                         al->queue_reset ();
2147                 } else {
2148                         add_processor_automation_curve (processor, param);
2149                 }
2150         }
2151 }
2152
2153 void
2154 RouteTimeAxisView::add_processor_to_subplugin_menu (boost::weak_ptr<Processor> p)
2155 {
2156         boost::shared_ptr<Processor> processor (p.lock ());
2157
2158         if (!processor || !processor->display_to_user ()) {
2159                 return;
2160         }
2161
2162         /* we use this override to veto the Amp processor from the plugin menu,
2163            as its automation lane can be accessed using the special "Fader" menu
2164            option
2165         */
2166
2167         if (boost::dynamic_pointer_cast<Amp> (processor) != 0) {
2168                 return;
2169         }
2170
2171         using namespace Menu_Helpers;
2172         ProcessorAutomationInfo *rai;
2173         list<ProcessorAutomationInfo*>::iterator x;
2174
2175         const std::set<Evoral::Parameter>& automatable = processor->what_can_be_automated ();
2176
2177         if (automatable.empty()) {
2178                 return;
2179         }
2180
2181         for (x = processor_automation.begin(); x != processor_automation.end(); ++x) {
2182                 if ((*x)->processor == processor) {
2183                         break;
2184                 }
2185         }
2186
2187         if (x == processor_automation.end()) {
2188                 rai = new ProcessorAutomationInfo (processor);
2189                 processor_automation.push_back (rai);
2190         } else {
2191                 rai = *x;
2192         }
2193
2194         /* any older menu was deleted at the top of processors_changed()
2195            when we cleared the subplugin menu.
2196         */
2197
2198         rai->menu = manage (new Menu);
2199         MenuList& items = rai->menu->items();
2200         rai->menu->set_name ("ArdourContextMenu");
2201
2202         items.clear ();
2203
2204         std::set<Evoral::Parameter> has_visible_automation;
2205         AutomationTimeAxisView::what_has_visible_automation (processor, has_visible_automation);
2206
2207         for (std::set<Evoral::Parameter>::const_iterator i = automatable.begin(); i != automatable.end(); ++i) {
2208
2209                 ProcessorAutomationNode* pan;
2210                 Gtk::CheckMenuItem* mitem;
2211
2212                 string name = processor->describe_parameter (*i);
2213
2214                 if (name == X_("hidden")) {
2215                         continue;
2216                 }
2217
2218                 items.push_back (CheckMenuElem (name));
2219                 mitem = dynamic_cast<Gtk::CheckMenuItem*> (&items.back());
2220
2221                 _subplugin_menu_map[*i] = mitem;
2222
2223                 if (has_visible_automation.find((*i)) != has_visible_automation.end()) {
2224                         mitem->set_active(true);
2225                 }
2226
2227                 if ((pan = find_processor_automation_node (processor, *i)) == 0) {
2228
2229                         /* new item */
2230
2231                         pan = new ProcessorAutomationNode (*i, mitem, *this);
2232
2233                         rai->lines.push_back (pan);
2234
2235                 } else {
2236
2237                         pan->menu_item = mitem;
2238
2239                 }
2240
2241                 mitem->signal_toggled().connect (sigc::bind (sigc::mem_fun(*this, &RouteTimeAxisView::processor_menu_item_toggled), rai, pan));
2242         }
2243
2244         if (items.size() == 0) {
2245                 return;
2246         }
2247
2248         /* add the menu for this processor, because the subplugin
2249            menu is always cleared at the top of processors_changed().
2250            this is the result of some poor design in gtkmm and/or
2251            GTK+.
2252         */
2253
2254         subplugin_menu.items().push_back (MenuElem (processor->name(), *rai->menu));
2255         rai->valid = true;
2256 }
2257
2258 void
2259 RouteTimeAxisView::processor_menu_item_toggled (RouteTimeAxisView::ProcessorAutomationInfo* rai,
2260                                                RouteTimeAxisView::ProcessorAutomationNode* pan)
2261 {
2262         bool showit = pan->menu_item->get_active();
2263         bool redraw = false;
2264
2265         if (pan->view == 0 && showit) {
2266                 add_processor_automation_curve (rai->processor, pan->what);
2267                 redraw = true;
2268         }
2269
2270         if (pan->view && pan->view->set_marked_for_display (showit)) {
2271                 redraw = true;
2272         }
2273
2274         if (redraw && !no_redraw) {
2275                 request_redraw ();
2276         }
2277 }
2278
2279 void
2280 RouteTimeAxisView::processors_changed (RouteProcessorChange c)
2281 {
2282         if (c.type == RouteProcessorChange::MeterPointChange) {
2283                 /* nothing to do if only the meter point has changed */
2284                 return;
2285         }
2286
2287         using namespace Menu_Helpers;
2288
2289         for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
2290                 (*i)->valid = false;
2291         }
2292
2293         setup_processor_menu_and_curves ();
2294
2295         bool deleted_processor_automation = false;
2296
2297         for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ) {
2298
2299                 list<ProcessorAutomationInfo*>::iterator tmp;
2300
2301                 tmp = i;
2302                 ++tmp;
2303
2304                 if (!(*i)->valid) {
2305
2306                         delete *i;
2307                         processor_automation.erase (i);
2308                         deleted_processor_automation = true;
2309
2310                 }
2311
2312                 i = tmp;
2313         }
2314
2315         if (deleted_processor_automation && !no_redraw) {
2316                 request_redraw ();
2317         }
2318 }
2319
2320 boost::shared_ptr<AutomationLine>
2321 RouteTimeAxisView::find_processor_automation_curve (boost::shared_ptr<Processor> processor, Evoral::Parameter what)
2322 {
2323         ProcessorAutomationNode* pan;
2324
2325         if ((pan = find_processor_automation_node (processor, what)) != 0) {
2326                 if (pan->view) {
2327                         pan->view->line();
2328                 }
2329         }
2330
2331         return boost::shared_ptr<AutomationLine>();
2332 }
2333
2334 void
2335 RouteTimeAxisView::reset_processor_automation_curves ()
2336 {
2337         for (ProcessorAutomationCurves::iterator i = processor_automation_curves.begin(); i != processor_automation_curves.end(); ++i) {
2338                 (*i)->reset();
2339         }
2340 }
2341
2342 bool
2343 RouteTimeAxisView::can_edit_name () const
2344 {
2345         /* we do not allow track name changes if it is record enabled
2346          */
2347         boost::shared_ptr<Track> trk (boost::dynamic_pointer_cast<Track> (_route));
2348         if (!trk) {
2349                 return true;
2350         }
2351         return !trk->rec_enable_control()->get_value();
2352 }
2353
2354 void
2355 RouteTimeAxisView::blink_rec_display (bool onoff)
2356 {
2357         RouteUI::blink_rec_display (onoff);
2358 }
2359
2360 void
2361 RouteTimeAxisView::set_layer_display (LayerDisplay d, bool apply_to_selection)
2362 {
2363         if (_ignore_set_layer_display) {
2364                 return;
2365         }
2366
2367         if (apply_to_selection) {
2368                 _editor.get_selection().tracks.foreach_route_time_axis (boost::bind (&RouteTimeAxisView::set_layer_display, _1, d, false));
2369         } else {
2370
2371                 if (_view) {
2372                         _view->set_layer_display (d);
2373                 }
2374
2375                 set_gui_property (X_("layer-display"), d);
2376         }
2377 }
2378
2379 LayerDisplay
2380 RouteTimeAxisView::layer_display () const
2381 {
2382         if (_view) {
2383                 return _view->layer_display ();
2384         }
2385
2386         /* we don't know, since we don't have a _view, so just return something */
2387         return Overlaid;
2388 }
2389
2390 void
2391 RouteTimeAxisView::fast_update ()
2392 {
2393         gm.get_level_meter().update_meters ();
2394 }
2395
2396 void
2397 RouteTimeAxisView::hide_meter ()
2398 {
2399         clear_meter ();
2400         gm.get_level_meter().hide_meters ();
2401 }
2402
2403 void
2404 RouteTimeAxisView::show_meter ()
2405 {
2406         reset_meter ();
2407 }
2408
2409 void
2410 RouteTimeAxisView::reset_meter ()
2411 {
2412         if (UIConfiguration::instance().get_show_track_meters()) {
2413                 int meter_width = 3;
2414                 if (_route && _route->shared_peak_meter()->input_streams().n_total() == 1) {
2415                         meter_width = 6;
2416                 }
2417                 gm.get_level_meter().setup_meters (height - 9, meter_width);
2418         } else {
2419                 hide_meter ();
2420         }
2421 }
2422
2423 void
2424 RouteTimeAxisView::clear_meter ()
2425 {
2426         gm.get_level_meter().clear_meters ();
2427 }
2428
2429 void
2430 RouteTimeAxisView::meter_changed ()
2431 {
2432         ENSURE_GUI_THREAD (*this, &RouteTimeAxisView::meter_changed)
2433         reset_meter();
2434         if (_route && !no_redraw && UIConfiguration::instance().get_show_track_meters()) {
2435                 request_redraw ();
2436         }
2437         // reset peak when meter point changes
2438         gm.reset_peak_display();
2439 }
2440
2441 void
2442 RouteTimeAxisView::io_changed (IOChange /*change*/, void */*src*/)
2443 {
2444         reset_meter ();
2445         if (_route && !no_redraw) {
2446                 request_redraw ();
2447         }
2448 }
2449
2450 void
2451 RouteTimeAxisView::build_underlay_menu(Gtk::Menu* parent_menu)
2452 {
2453         using namespace Menu_Helpers;
2454
2455         if (!_underlay_streams.empty()) {
2456                 MenuList& parent_items = parent_menu->items();
2457                 Menu* gs_menu = manage (new Menu);
2458                 gs_menu->set_name ("ArdourContextMenu");
2459                 MenuList& gs_items = gs_menu->items();
2460
2461                 parent_items.push_back (MenuElem (_("Underlays"), *gs_menu));
2462
2463                 for(UnderlayList::iterator it = _underlay_streams.begin(); it != _underlay_streams.end(); ++it) {
2464                         gs_items.push_back(MenuElem(string_compose(_("Remove \"%1\""), (*it)->trackview().name()),
2465                                                     sigc::bind(sigc::mem_fun(*this, &RouteTimeAxisView::remove_underlay), *it)));
2466                 }
2467         }
2468 }
2469
2470 bool
2471 RouteTimeAxisView::set_underlay_state()
2472 {
2473         if (!underlay_xml_node) {
2474                 return false;
2475         }
2476
2477         XMLNodeList nlist = underlay_xml_node->children();
2478         XMLNodeConstIterator niter;
2479         XMLNode *child_node;
2480
2481         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2482                 child_node = *niter;
2483
2484                 if (child_node->name() != "Underlay") {
2485                         continue;
2486                 }
2487
2488                 XMLProperty const * prop = child_node->property ("id");
2489                 if (prop) {
2490                         PBD::ID id (prop->value());
2491
2492                         RouteTimeAxisView* v = _editor.get_route_view_by_route_id (id);
2493
2494                         if (v) {
2495                                 add_underlay(v->view(), false);
2496                         }
2497                 }
2498         }
2499
2500         return false;
2501 }
2502
2503 void
2504 RouteTimeAxisView::add_underlay (StreamView* v, bool /*update_xml*/)
2505 {
2506         if (!v) {
2507                 return;
2508         }
2509
2510         RouteTimeAxisView& other = v->trackview();
2511
2512         if (find(_underlay_streams.begin(), _underlay_streams.end(), v) == _underlay_streams.end()) {
2513                 if (find(other._underlay_mirrors.begin(), other._underlay_mirrors.end(), this) != other._underlay_mirrors.end()) {
2514                         fatal << _("programming error: underlay reference pointer pairs are inconsistent!") << endmsg;
2515                         abort(); /*NOTREACHED*/
2516                 }
2517
2518                 _underlay_streams.push_back(v);
2519                 other._underlay_mirrors.push_back(this);
2520
2521                 v->foreach_regionview(sigc::mem_fun(*this, &RouteTimeAxisView::add_ghost));
2522
2523 #ifdef GUI_OBJECT_STATE_FIX_REQUIRED
2524                 if (update_xml) {
2525                         if (!underlay_xml_node) {
2526                                 underlay_xml_node = xml_node->add_child("Underlays");
2527                         }
2528
2529                         XMLNode* node = underlay_xml_node->add_child("Underlay");
2530                         XMLProperty const * prop = node->add_property("id");
2531                         prop->set_value(v->trackview().route()->id().to_s());
2532                 }
2533 #endif
2534         }
2535 }
2536
2537 void
2538 RouteTimeAxisView::remove_underlay (StreamView* v)
2539 {
2540         if (!v) {
2541                 return;
2542         }
2543
2544         UnderlayList::iterator it = find(_underlay_streams.begin(), _underlay_streams.end(), v);
2545         RouteTimeAxisView& other = v->trackview();
2546
2547         if (it != _underlay_streams.end()) {
2548                 UnderlayMirrorList::iterator gm = find(other._underlay_mirrors.begin(), other._underlay_mirrors.end(), this);
2549
2550                 if (gm == other._underlay_mirrors.end()) {
2551                         fatal << _("programming error: underlay reference pointer pairs are inconsistent!") << endmsg;
2552                         abort(); /*NOTREACHED*/
2553                 }
2554
2555                 v->foreach_regionview(sigc::mem_fun(*this, &RouteTimeAxisView::remove_ghost));
2556
2557                 _underlay_streams.erase(it);
2558                 other._underlay_mirrors.erase(gm);
2559
2560                 if (underlay_xml_node) {
2561                         underlay_xml_node->remove_nodes_and_delete("id", v->trackview().route()->id().to_s());
2562                 }
2563         }
2564 }
2565
2566 void
2567 RouteTimeAxisView::set_button_names ()
2568 {
2569         if (_route && _route->solo_safe_control()->solo_safe()) {
2570                 solo_button->set_visual_state (Gtkmm2ext::VisualState (solo_button->visual_state() | Gtkmm2ext::Insensitive));
2571         } else {
2572                 solo_button->set_visual_state (Gtkmm2ext::VisualState (solo_button->visual_state() & ~Gtkmm2ext::Insensitive));
2573         }
2574         if (Config->get_solo_control_is_listen_control()) {
2575                 switch (Config->get_listen_position()) {
2576                         case AfterFaderListen:
2577                                 solo_button->set_text (S_("AfterFader|A"));
2578                                 set_tooltip (*solo_button, _("After-fade listen (AFL)"));
2579                                 break;
2580                         case PreFaderListen:
2581                                 solo_button->set_text (S_("PreFader|P"));
2582                                 set_tooltip (*solo_button, _("Pre-fade listen (PFL)"));
2583                         break;
2584                 }
2585         } else {
2586                 solo_button->set_text (S_("Solo|S"));
2587                 set_tooltip (*solo_button, _("Solo"));
2588         }
2589         mute_button->set_text (S_("Mute|M"));
2590 }
2591
2592 Gtk::CheckMenuItem*
2593 RouteTimeAxisView::automation_child_menu_item (Evoral::Parameter param)
2594 {
2595         Gtk::CheckMenuItem* rv = StripableTimeAxisView::automation_child_menu_item (param);
2596         if (rv) {
2597                 return rv;
2598         }
2599
2600         ParameterMenuMap::iterator i = _subplugin_menu_map.find (param);
2601         if (i != _subplugin_menu_map.end()) {
2602                 return i->second;
2603         }
2604
2605         return 0;
2606 }
2607
2608 void
2609 RouteTimeAxisView::create_gain_automation_child (const Evoral::Parameter& param, bool show)
2610 {
2611         boost::shared_ptr<AutomationControl> c = _route->gain_control();
2612         if (!c) {
2613                 error << "Route has no gain automation, unable to add automation track view." << endmsg;
2614                 return;
2615         }
2616
2617         gain_track.reset (new AutomationTimeAxisView (_session,
2618                                                       _route, _route->amp(), c, param,
2619                                                       _editor,
2620                                                       *this,
2621                                                       false,
2622                                                       parent_canvas,
2623                                                       _route->amp()->describe_parameter(param)));
2624
2625         if (_view) {
2626                 _view->foreach_regionview (sigc::mem_fun (*gain_track.get(), &TimeAxisView::add_ghost));
2627         }
2628
2629         add_automation_child (Evoral::Parameter(GainAutomation), gain_track, show);
2630 }
2631
2632 void
2633 RouteTimeAxisView::create_trim_automation_child (const Evoral::Parameter& param, bool show)
2634 {
2635         boost::shared_ptr<AutomationControl> c = _route->trim()->gain_control();
2636         if (!c || ! _route->trim()->active()) {
2637                 return;
2638         }
2639
2640         trim_track.reset (new AutomationTimeAxisView (_session,
2641                                                       _route, _route->trim(), c, param,
2642                                                       _editor,
2643                                                       *this,
2644                                                       false,
2645                                                       parent_canvas,
2646                                                       _route->trim()->describe_parameter(param)));
2647
2648         if (_view) {
2649                 _view->foreach_regionview (sigc::mem_fun (*trim_track.get(), &TimeAxisView::add_ghost));
2650         }
2651
2652         add_automation_child (Evoral::Parameter(TrimAutomation), trim_track, show);
2653 }
2654
2655 void
2656 RouteTimeAxisView::create_mute_automation_child (const Evoral::Parameter& param, bool show)
2657 {
2658         boost::shared_ptr<AutomationControl> c = _route->mute_control();
2659         if (!c) {
2660                 error << "Route has no mute automation, unable to add automation track view." << endmsg;
2661                 return;
2662         }
2663
2664         mute_track.reset (new AutomationTimeAxisView (_session,
2665                                                       _route, _route, c, param,
2666                                                       _editor,
2667                                                       *this,
2668                                                       false,
2669                                                       parent_canvas,
2670                                                       _route->describe_parameter(param)));
2671
2672         if (_view) {
2673                 _view->foreach_regionview (sigc::mem_fun (*mute_track.get(), &TimeAxisView::add_ghost));
2674         }
2675
2676         add_automation_child (Evoral::Parameter(MuteAutomation), mute_track, show);
2677 }
2678
2679 static
2680 void add_region_to_list (RegionView* rv, RegionList* l)
2681 {
2682         l->push_back (rv->region());
2683 }
2684
2685 RegionView*
2686 RouteTimeAxisView::combine_regions ()
2687 {
2688         /* as of may 2011, we do not offer uncombine for MIDI tracks
2689          */
2690
2691         if (!is_audio_track()) {
2692                 return 0;
2693         }
2694
2695         if (!_view) {
2696                 return 0;
2697         }
2698
2699         RegionList selected_regions;
2700         boost::shared_ptr<Playlist> playlist = track()->playlist();
2701
2702         _view->foreach_selected_regionview (sigc::bind (sigc::ptr_fun (add_region_to_list), &selected_regions));
2703
2704         if (selected_regions.size() < 2) {
2705                 return 0;
2706         }
2707
2708         playlist->clear_changes ();
2709         boost::shared_ptr<Region> compound_region = playlist->combine (selected_regions);
2710
2711         _session->add_command (new StatefulDiffCommand (playlist));
2712         /* make the new region be selected */
2713
2714         return _view->find_view (compound_region);
2715 }
2716
2717 void
2718 RouteTimeAxisView::uncombine_regions ()
2719 {
2720         /* as of may 2011, we do not offer uncombine for MIDI tracks
2721          */
2722         if (!is_audio_track()) {
2723                 return;
2724         }
2725
2726         if (!_view) {
2727                 return;
2728         }
2729
2730         RegionList selected_regions;
2731         boost::shared_ptr<Playlist> playlist = track()->playlist();
2732
2733         /* have to grab selected regions first because the uncombine is going
2734          * to change that in the middle of the list traverse
2735          */
2736
2737         _view->foreach_selected_regionview (sigc::bind (sigc::ptr_fun (add_region_to_list), &selected_regions));
2738
2739         playlist->clear_changes ();
2740
2741         for (RegionList::iterator i = selected_regions.begin(); i != selected_regions.end(); ++i) {
2742                 playlist->uncombine (*i);
2743         }
2744
2745         _session->add_command (new StatefulDiffCommand (playlist));
2746 }
2747
2748 string
2749 RouteTimeAxisView::state_id() const
2750 {
2751         return string_compose ("rtav %1", _route->id().to_s());
2752 }
2753
2754
2755 void
2756 RouteTimeAxisView::remove_child (boost::shared_ptr<TimeAxisView> c)
2757 {
2758         TimeAxisView::remove_child (c);
2759
2760         boost::shared_ptr<AutomationTimeAxisView> a = boost::dynamic_pointer_cast<AutomationTimeAxisView> (c);
2761         if (a) {
2762                 for (AutomationTracks::iterator i = _automation_tracks.begin(); i != _automation_tracks.end(); ++i) {
2763                         if (i->second == a) {
2764                                 _automation_tracks.erase (i);
2765                                 return;
2766                         }
2767                 }
2768         }
2769 }
2770
2771 Gdk::Color
2772 RouteTimeAxisView::color () const
2773 {
2774         return route_color ();
2775 }
2776
2777 bool
2778 RouteTimeAxisView::marked_for_display () const
2779 {
2780         return !_route->presentation_info().hidden();
2781 }
2782
2783 bool
2784 RouteTimeAxisView::set_marked_for_display (bool yn)
2785 {
2786         return RouteUI::mark_hidden (!yn);
2787 }