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 <gtkmm/menu.h>
  32 #include <gtkmm/menuitem.h>
  33 #include <gtkmm/stock.h>
  34
  35 #include "pbd/error.h"
  36 #include "pbd/stl_delete.h"
  37 #include "pbd/whitespace.h"
  38 #include "pbd/memento_command.h"
  39 #include "pbd/enumwriter.h"
  40 #include "pbd/stateful_diff_command.h"
  41
  42 #include "evoral/Parameter.hpp"
  43
  44 #include "ardour/amp.h"
  45 #include "ardour/meter.h"
  46 #include "ardour/event_type_map.h"
  47 #include "ardour/pannable.h"
  48 #include "ardour/panner.h"
  49 #include "ardour/processor.h"
  50 #include "ardour/profile.h"
  51 #include "ardour/route_group.h"
  52 #include "ardour/session.h"
  53 #include "ardour/session_playlists.h"
  54 #include "ardour/track.h"
  55
  56 #include "canvas/debug.h"
  57
  58 #include "gtkmm2ext/gtk_ui.h"
  59 #include "gtkmm2ext/utils.h"
  60
  61 #include "widgets/ardour_button.h"
  62 #include "widgets/prompter.h"
  63 #include "widgets/tooltips.h"
  64
  65 #include "ardour_ui.h"
  66 #include "audio_streamview.h"
  67 #include "debug.h"
  68 #include "enums_convert.h"
  69 #include "route_time_axis.h"
  70 #include "automation_time_axis.h"
  71 #include "enums.h"
  72 #include "gui_thread.h"
  73 #include "item_counts.h"
  74 #include "keyboard.h"
  75 #include "paste_context.h"
  76 #include "playlist_selector.h"
  77 #include "point_selection.h"
  78 #include "public_editor.h"
  79 #include "region_view.h"
  80 #include "rgb_macros.h"
  81 #include "selection.h"
  82 #include "streamview.h"
  83 #include "ui_config.h"
  84 #include "utils.h"
  85 #include "route_group_menu.h"
  86
  87 #include "pbd/i18n.h"
  88
  89 using namespace ARDOUR;
  90 using namespace ArdourWidgets;
  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 (Gtkmm2ext::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         using namespace ARDOUR_UI_UTILS;
1084         if (_view) {
1085                 _view->apply_color (color(), StreamView::RegionColor);
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         Prompter 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                 Prompter 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         _editor.set_selected_mixer_strip (*this);
1345 }
1346
1347 void
1348 RouteTimeAxisView::set_selected_points (PointSelection& points)
1349 {
1350         StripableTimeAxisView::set_selected_points (points);
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         StripableTimeAxisView::get_selectables (start_adjusted, end_adjusted, top, bot, results, within);
1386 }
1387
1388 void
1389 RouteTimeAxisView::get_inverted_selectables (Selection& sel, list<Selectable*>& results)
1390 {
1391         if (_view) {
1392                 _view->get_inverted_selectables (sel, results);
1393         }
1394         StripableTimeAxisView::get_inverted_selectables (sel, results);
1395 }
1396
1397 RouteGroup*
1398 RouteTimeAxisView::route_group () const
1399 {
1400         return _route->route_group();
1401 }
1402
1403 boost::shared_ptr<Playlist>
1404 RouteTimeAxisView::playlist () const
1405 {
1406         boost::shared_ptr<Track> tr;
1407
1408         if ((tr = track()) != 0) {
1409                 return tr->playlist();
1410         } else {
1411                 return boost::shared_ptr<Playlist> ();
1412         }
1413 }
1414
1415 bool
1416 RouteTimeAxisView::name_entry_changed (string const& str)
1417 {
1418         if (str == _route->name()) {
1419                 return true;
1420         }
1421
1422         string x = str;
1423
1424         strip_whitespace_edges (x);
1425
1426         if (x.empty()) {
1427                 return false;
1428         }
1429
1430         if (_session->route_name_internal (x)) {
1431                 ARDOUR_UI::instance()->popup_error (string_compose (_("The name \"%1\" is reserved for %2"), x, PROGRAM_NAME));
1432                 return false;
1433         } else if (RouteUI::verify_new_route_name (x)) {
1434                 _route->set_name (x);
1435                 return true;
1436         }
1437
1438         return false;
1439 }
1440
1441 boost::shared_ptr<Region>
1442 RouteTimeAxisView::find_next_region (framepos_t pos, RegionPoint point, int32_t dir)
1443 {
1444         boost::shared_ptr<Playlist> pl = playlist ();
1445
1446         if (pl) {
1447                 return pl->find_next_region (pos, point, dir);
1448         }
1449
1450         return boost::shared_ptr<Region> ();
1451 }
1452
1453 framepos_t
1454 RouteTimeAxisView::find_next_region_boundary (framepos_t pos, int32_t dir)
1455 {
1456         boost::shared_ptr<Playlist> pl = playlist ();
1457
1458         if (pl) {
1459                 return pl->find_next_region_boundary (pos, dir);
1460         }
1461
1462         return -1;
1463 }
1464
1465 void
1466 RouteTimeAxisView::fade_range (TimeSelection& selection)
1467 {
1468         boost::shared_ptr<Playlist> what_we_got;
1469         boost::shared_ptr<Track> tr = track ();
1470         boost::shared_ptr<Playlist> playlist;
1471
1472         if (tr == 0) {
1473                 /* route is a bus, not a track */
1474                 return;
1475         }
1476
1477         playlist = tr->playlist();
1478
1479         TimeSelection time (selection);
1480         float const speed = tr->speed();
1481         if (speed != 1.0f) {
1482                 for (TimeSelection::iterator i = time.begin(); i != time.end(); ++i) {
1483                         (*i).start = session_frame_to_track_frame((*i).start, speed);
1484                         (*i).end   = session_frame_to_track_frame((*i).end,   speed);
1485                 }
1486         }
1487
1488         playlist->clear_changes ();
1489         playlist->clear_owned_changes ();
1490
1491         playlist->fade_range (time);
1492
1493         vector<Command*> cmds;
1494         playlist->rdiff (cmds);
1495         _session->add_commands (cmds);
1496         _session->add_command (new StatefulDiffCommand (playlist));
1497
1498 }
1499
1500 void
1501 RouteTimeAxisView::cut_copy_clear (Selection& selection, CutCopyOp op)
1502 {
1503         boost::shared_ptr<Playlist> what_we_got;
1504         boost::shared_ptr<Track> tr = track ();
1505         boost::shared_ptr<Playlist> playlist;
1506
1507         if (tr == 0) {
1508                 /* route is a bus, not a track */
1509                 return;
1510         }
1511
1512         playlist = tr->playlist();
1513
1514         TimeSelection time (selection.time);
1515         float const speed = tr->speed();
1516         if (speed != 1.0f) {
1517                 for (TimeSelection::iterator i = time.begin(); i != time.end(); ++i) {
1518                         (*i).start = session_frame_to_track_frame((*i).start, speed);
1519                         (*i).end   = session_frame_to_track_frame((*i).end,   speed);
1520                 }
1521         }
1522
1523         playlist->clear_changes ();
1524         playlist->clear_owned_changes ();
1525
1526         switch (op) {
1527         case Delete:
1528                 if (playlist->cut (time) != 0) {
1529                         if (Config->get_edit_mode() == Ripple) {
1530                                 playlist->ripple(time.start(), -time.length(), NULL);
1531                         }
1532                         // no need to exclude any regions from rippling here
1533
1534                         vector<Command*> cmds;
1535                         playlist->rdiff (cmds);
1536                         _session->add_commands (cmds);
1537
1538                         _session->add_command (new StatefulDiffCommand (playlist));
1539                 }
1540                 break;
1541
1542         case Cut:
1543                 if ((what_we_got = playlist->cut (time)) != 0) {
1544                         _editor.get_cut_buffer().add (what_we_got);
1545                         if (Config->get_edit_mode() == Ripple) {
1546                                 playlist->ripple(time.start(), -time.length(), NULL);
1547                         }
1548                         // no need to exclude any regions from rippling here
1549
1550                         vector<Command*> cmds;
1551                         playlist->rdiff (cmds);
1552                         _session->add_commands (cmds);
1553
1554                         _session->add_command (new StatefulDiffCommand (playlist));
1555                 }
1556                 break;
1557         case Copy:
1558                 if ((what_we_got = playlist->copy (time)) != 0) {
1559                         _editor.get_cut_buffer().add (what_we_got);
1560                 }
1561                 break;
1562
1563         case Clear:
1564                 if ((what_we_got = playlist->cut (time)) != 0) {
1565                         if (Config->get_edit_mode() == Ripple) {
1566                                 playlist->ripple(time.start(), -time.length(), NULL);
1567                         }
1568                         // no need to exclude any regions from rippling here
1569
1570                         vector<Command*> cmds;
1571                         playlist->rdiff (cmds);
1572                         _session->add_commands (cmds);
1573                         _session->add_command (new StatefulDiffCommand (playlist));
1574                         what_we_got->release ();
1575                 }
1576                 break;
1577         }
1578 }
1579
1580 bool
1581 RouteTimeAxisView::paste (framepos_t pos, const Selection& selection, PasteContext& ctx, const int32_t sub_num)
1582 {
1583         if (!is_track()) {
1584                 return false;
1585         }
1586
1587         boost::shared_ptr<Playlist>       pl   = playlist ();
1588         const ARDOUR::DataType            type = pl->data_type();
1589         PlaylistSelection::const_iterator p    = selection.playlists.get_nth(type, ctx.counts.n_playlists(type));
1590
1591         if (p == selection.playlists.end()) {
1592                 return false;
1593         }
1594         ctx.counts.increase_n_playlists(type);
1595
1596         DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("paste to %1\n", pos));
1597
1598         if (track()->speed() != 1.0f) {
1599                 pos = session_frame_to_track_frame (pos, track()->speed());
1600                 DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("modified paste to %1\n", pos));
1601         }
1602
1603         /* add multi-paste offset if applicable */
1604         std::pair<framepos_t, framepos_t> extent   = (*p)->get_extent();
1605         const framecnt_t                  duration = extent.second - extent.first;
1606         pos += _editor.get_paste_offset(pos, ctx.count, duration);
1607
1608         pl->clear_changes ();
1609         pl->clear_owned_changes ();
1610         if (Config->get_edit_mode() == Ripple) {
1611                 std::pair<framepos_t, framepos_t> extent = (*p)->get_extent_with_endspace();
1612                 framecnt_t amount = extent.second - extent.first;
1613                 pl->ripple(pos, amount * ctx.times, boost::shared_ptr<Region>());
1614         }
1615         pl->paste (*p, pos, ctx.times, sub_num);
1616
1617         vector<Command*> cmds;
1618         pl->rdiff (cmds);
1619         _session->add_commands (cmds);
1620
1621         _session->add_command (new StatefulDiffCommand (pl));
1622
1623         return true;
1624 }
1625
1626
1627 struct PlaylistSorter {
1628         bool operator() (boost::shared_ptr<Playlist> a, boost::shared_ptr<Playlist> b) const {
1629                 return a->sort_id() < b->sort_id();
1630         }
1631 };
1632
1633 void
1634 RouteTimeAxisView::build_playlist_menu ()
1635 {
1636         using namespace Menu_Helpers;
1637
1638         if (!is_track()) {
1639                 return;
1640         }
1641
1642         delete playlist_action_menu;
1643         playlist_action_menu = new Menu;
1644         playlist_action_menu->set_name ("ArdourContextMenu");
1645
1646         MenuList& playlist_items = playlist_action_menu->items();
1647         playlist_action_menu->set_name ("ArdourContextMenu");
1648         playlist_items.clear();
1649
1650         RadioMenuItem::Group playlist_group;
1651         boost::shared_ptr<Track> tr = track ();
1652
1653         vector<boost::shared_ptr<Playlist> > playlists_tr = _session->playlists->playlists_for_track (tr);
1654
1655         /* sort the playlists */
1656         PlaylistSorter cmp;
1657         sort (playlists_tr.begin(), playlists_tr.end(), cmp);
1658
1659         /* add the playlists to the menu */
1660         for (vector<boost::shared_ptr<Playlist> >::iterator i = playlists_tr.begin(); i != playlists_tr.end(); ++i) {
1661                 playlist_items.push_back (RadioMenuElem (playlist_group, (*i)->name()));
1662                 RadioMenuItem *item = static_cast<RadioMenuItem*>(&playlist_items.back());
1663                 item->signal_toggled().connect(sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::use_playlist), item, boost::weak_ptr<Playlist> (*i)));
1664
1665                 if (tr->playlist()->id() == (*i)->id()) {
1666                         item->set_active();
1667                 }
1668         }
1669
1670         playlist_items.push_back (SeparatorElem());
1671         playlist_items.push_back (MenuElem (_("Rename..."), sigc::mem_fun(*this, &RouteTimeAxisView::rename_current_playlist)));
1672         playlist_items.push_back (SeparatorElem());
1673
1674         if (!route_group() || !route_group()->is_active() || !route_group()->enabled_property (ARDOUR::Properties::group_select.property_id)) {
1675                 playlist_items.push_back (MenuElem (_("New..."), sigc::bind(sigc::mem_fun(_editor, &PublicEditor::new_playlists), this)));
1676                 playlist_items.push_back (MenuElem (_("New Copy..."), sigc::bind(sigc::mem_fun(_editor, &PublicEditor::copy_playlists), this)));
1677
1678         } else {
1679                 // Use a label which tells the user what is happening
1680                 playlist_items.push_back (MenuElem (_("New Take"), sigc::bind(sigc::mem_fun(_editor, &PublicEditor::new_playlists), this)));
1681                 playlist_items.push_back (MenuElem (_("Copy Take"), sigc::bind(sigc::mem_fun(_editor, &PublicEditor::copy_playlists), this)));
1682
1683         }
1684
1685         playlist_items.push_back (SeparatorElem());
1686         playlist_items.push_back (MenuElem (_("Clear Current"), sigc::bind(sigc::mem_fun(_editor, &PublicEditor::clear_playlists), this)));
1687         playlist_items.push_back (SeparatorElem());
1688
1689         playlist_items.push_back (MenuElem(_("Select from All..."), sigc::mem_fun(*this, &RouteTimeAxisView::show_playlist_selector)));
1690 }
1691
1692 void
1693 RouteTimeAxisView::use_playlist (RadioMenuItem *item, boost::weak_ptr<Playlist> wpl)
1694 {
1695         assert (is_track());
1696
1697         // exit if we were triggered by deactivating the old playlist
1698         if (!item->get_active()) {
1699                 return;
1700         }
1701
1702         boost::shared_ptr<Playlist> pl (wpl.lock());
1703
1704         if (!pl) {
1705                 return;
1706         }
1707
1708         if (track()->playlist() == pl) {
1709                 // exit when use_playlist is called by the creation of the playlist menu
1710                 // or the playlist choice is unchanged
1711                 return;
1712         }
1713
1714         track()->use_playlist (pl);
1715
1716         RouteGroup* rg = route_group();
1717
1718         if (rg && rg->is_active() && rg->enabled_property (ARDOUR::Properties::group_select.property_id)) {
1719                 std::string group_string = "." + rg->name() + ".";
1720
1721                 std::string take_name = pl->name();
1722                 std::string::size_type idx = take_name.find(group_string);
1723
1724                 if (idx == std::string::npos)
1725                         return;
1726
1727                 take_name = take_name.substr(idx + group_string.length()); // find the bit containing the take number / name
1728
1729                 boost::shared_ptr<RouteList> rl (rg->route_list());
1730
1731                 for (RouteList::const_iterator i = rl->begin(); i != rl->end(); ++i) {
1732                         if ((*i) == this->route()) {
1733                                 continue;
1734                         }
1735
1736                         std::string playlist_name = (*i)->name()+group_string+take_name;
1737
1738                         boost::shared_ptr<Track> track = boost::dynamic_pointer_cast<Track>(*i);
1739                         if (!track) {
1740                                 continue;
1741                         }
1742
1743                         if (track->freeze_state() == Track::Frozen) {
1744                                 /* Don't change playlists of frozen tracks */
1745                                 continue;
1746                         }
1747
1748                         boost::shared_ptr<Playlist> ipl = session()->playlists->by_name(playlist_name);
1749                         if (!ipl) {
1750                                 // No playlist for this track for this take yet, make it
1751                                 track->use_new_playlist();
1752                                 track->playlist()->set_name(playlist_name);
1753                         } else {
1754                                 track->use_playlist(ipl);
1755                         }
1756                 }
1757         }
1758 }
1759
1760 void
1761 RouteTimeAxisView::update_playlist_tip ()
1762 {
1763         RouteGroup* rg = route_group ();
1764         if (rg && rg->is_active() && rg->enabled_property (ARDOUR::Properties::group_select.property_id)) {
1765                 string group_string = "." + rg->name() + ".";
1766
1767                 string take_name = track()->playlist()->name();
1768                 string::size_type idx = take_name.find(group_string);
1769
1770                 if (idx != string::npos) {
1771                         /* find the bit containing the take number / name */
1772                         take_name = take_name.substr (idx + group_string.length());
1773
1774                         /* set the playlist button tooltip to the take name */
1775                         set_tooltip (
1776                                 playlist_button,
1777                                 string_compose(_("Take: %1.%2"),
1778                                         Gtkmm2ext::markup_escape_text (rg->name()),
1779                                         Gtkmm2ext::markup_escape_text (take_name))
1780                                 );
1781
1782                         return;
1783                 }
1784         }
1785
1786         /* set the playlist button tooltip to the playlist name */
1787         set_tooltip (playlist_button, _("Playlist") + std::string(": ") + Gtkmm2ext::markup_escape_text (track()->playlist()->name()));
1788 }
1789
1790
1791 void
1792 RouteTimeAxisView::show_playlist_selector ()
1793 {
1794         _editor.playlist_selector().show_for (this);
1795 }
1796
1797 void
1798 RouteTimeAxisView::map_frozen ()
1799 {
1800         if (!is_track()) {
1801                 return;
1802         }
1803
1804         ENSURE_GUI_THREAD (*this, &RouteTimeAxisView::map_frozen)
1805
1806         switch (track()->freeze_state()) {
1807         case Track::Frozen:
1808                 playlist_button.set_sensitive (false);
1809                 break;
1810         default:
1811                 playlist_button.set_sensitive (true);
1812                 break;
1813         }
1814         RouteUI::map_frozen ();
1815 }
1816
1817 void
1818 RouteTimeAxisView::color_handler ()
1819 {
1820         //case cTimeStretchOutline:
1821         if (timestretch_rect) {
1822                 timestretch_rect->set_outline_color (UIConfiguration::instance().color ("time stretch outline"));
1823         }
1824         //case cTimeStretchFill:
1825         if (timestretch_rect) {
1826                 timestretch_rect->set_fill_color (UIConfiguration::instance().color ("time stretch fill"));
1827         }
1828
1829         reset_meter();
1830 }
1831
1832 /** Toggle an automation track for a fully-specified Parameter (type,channel,id)
1833  *  Will add track if necessary.
1834  */
1835 void
1836 RouteTimeAxisView::toggle_automation_track (const Evoral::Parameter& param)
1837 {
1838         boost::shared_ptr<AutomationTimeAxisView> track = automation_child (param);
1839         Gtk::CheckMenuItem* menu = automation_child_menu_item (param);
1840
1841         if (!track) {
1842                 /* it doesn't exist yet, so we don't care about the button state: just add it */
1843                 create_automation_child (param, true);
1844         } else {
1845                 assert (menu);
1846                 bool yn = menu->get_active();
1847                 bool changed = false;
1848
1849                 if ((changed = track->set_marked_for_display (menu->get_active())) && yn) {
1850
1851                         /* we made it visible, now trigger a redisplay. if it was hidden, then automation_track_hidden()
1852                            will have done that for us.
1853                         */
1854
1855                         if (changed && !no_redraw) {
1856                                 request_redraw ();
1857                         }
1858                 }
1859         }
1860 }
1861
1862 void
1863 RouteTimeAxisView::update_pan_track_visibility ()
1864 {
1865         bool const showit = pan_automation_item->get_active();
1866         bool changed = false;
1867
1868         for (list<boost::shared_ptr<AutomationTimeAxisView> >::iterator i = pan_tracks.begin(); i != pan_tracks.end(); ++i) {
1869                 if ((*i)->set_marked_for_display (showit)) {
1870                         changed = true;
1871                 }
1872         }
1873
1874         if (changed) {
1875                 _route->gui_changed (X_("visible_tracks"), (void *) 0); /* EMIT_SIGNAL */
1876         }
1877 }
1878
1879 void
1880 RouteTimeAxisView::ensure_pan_views (bool show)
1881 {
1882         bool changed = false;
1883         for (list<boost::shared_ptr<AutomationTimeAxisView> >::iterator i = pan_tracks.begin(); i != pan_tracks.end(); ++i) {
1884                 changed = true;
1885                 (*i)->set_marked_for_display (false);
1886         }
1887         if (changed) {
1888                 _route->gui_changed (X_("visible_tracks"), (void *) 0); /* EMIT_SIGNAL */
1889         }
1890         pan_tracks.clear();
1891
1892         if (!_route->panner()) {
1893                 return;
1894         }
1895
1896         set<Evoral::Parameter> params = _route->panner()->what_can_be_automated();
1897         set<Evoral::Parameter>::iterator p;
1898
1899         for (p = params.begin(); p != params.end(); ++p) {
1900                 boost::shared_ptr<ARDOUR::AutomationControl> pan_control = _route->pannable()->automation_control(*p);
1901
1902                 if (pan_control->parameter().type() == NullAutomation) {
1903                         error << "Pan control has NULL automation type!" << endmsg;
1904                         continue;
1905                 }
1906
1907                 if (automation_child (pan_control->parameter ()).get () == 0) {
1908
1909                         /* we don't already have an AutomationTimeAxisView for this parameter */
1910
1911                         std::string const name = _route->panner()->describe_parameter (pan_control->parameter ());
1912
1913                         boost::shared_ptr<AutomationTimeAxisView> t (
1914                                         new AutomationTimeAxisView (_session,
1915                                                 _route,
1916                                                 _route->pannable(),
1917                                                 pan_control,
1918                                                 pan_control->parameter (),
1919                                                 _editor,
1920                                                 *this,
1921                                                 false,
1922                                                 parent_canvas,
1923                                                 name)
1924                                         );
1925
1926                         pan_tracks.push_back (t);
1927                         add_automation_child (*p, t, show);
1928                 } else {
1929                         pan_tracks.push_back (automation_child (pan_control->parameter ()));
1930                 }
1931         }
1932 }
1933
1934
1935 void
1936 RouteTimeAxisView::show_all_automation (bool apply_to_selection)
1937 {
1938         if (apply_to_selection) {
1939                 _editor.get_selection().tracks.foreach_route_time_axis (boost::bind (&RouteTimeAxisView::show_all_automation, _1, false));
1940         } else {
1941                 no_redraw = true;
1942
1943                 StripableTimeAxisView::show_all_automation ();
1944
1945                 /* Show processor automation */
1946
1947                 for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
1948                         for (vector<ProcessorAutomationNode*>::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) {
1949                                 if ((*ii)->view == 0) {
1950                                         add_processor_automation_curve ((*i)->processor, (*ii)->what);
1951                                 }
1952
1953                                 (*ii)->menu_item->set_active (true);
1954                         }
1955                 }
1956
1957                 no_redraw = false;
1958
1959                 /* Redraw */
1960
1961                 request_redraw ();
1962         }
1963 }
1964
1965 void
1966 RouteTimeAxisView::show_existing_automation (bool apply_to_selection)
1967 {
1968         if (apply_to_selection) {
1969                 _editor.get_selection().tracks.foreach_route_time_axis (boost::bind (&RouteTimeAxisView::show_existing_automation, _1, false));
1970         } else {
1971                 no_redraw = true;
1972
1973                 StripableTimeAxisView::show_existing_automation ();
1974
1975                 /* Show processor automation */
1976                 for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
1977                         for (vector<ProcessorAutomationNode*>::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) {
1978                                 if ((*i)->processor->control((*ii)->what)->list()->size() > 0) {
1979                                         (*ii)->menu_item->set_active (true);
1980                                 }
1981                         }
1982                 }
1983
1984                 no_redraw = false;
1985                 request_redraw ();
1986         }
1987 }
1988
1989 void
1990 RouteTimeAxisView::hide_all_automation (bool apply_to_selection)
1991 {
1992         if (apply_to_selection) {
1993                 _editor.get_selection().tracks.foreach_route_time_axis (boost::bind (&RouteTimeAxisView::hide_all_automation, _1, false));
1994         } else {
1995                 no_redraw = true;
1996                 StripableTimeAxisView::hide_all_automation ();
1997
1998                 /* Hide processor automation */
1999                 for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
2000                         for (vector<ProcessorAutomationNode*>::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) {
2001                                 (*ii)->menu_item->set_active (false);
2002                         }
2003                 }
2004
2005                 no_redraw = false;
2006                 request_redraw ();
2007         }
2008 }
2009
2010 void
2011 RouteTimeAxisView::region_view_added (RegionView* rv)
2012 {
2013         /* XXX need to find out if automation children have automationstreamviews. If yes, no ghosts */
2014         for (Children::iterator i = children.begin(); i != children.end(); ++i) {
2015                 boost::shared_ptr<AutomationTimeAxisView> atv;
2016
2017                 if ((atv = boost::dynamic_pointer_cast<AutomationTimeAxisView> (*i)) != 0) {
2018                         atv->add_ghost(rv);
2019                 }
2020         }
2021
2022         for (UnderlayMirrorList::iterator i = _underlay_mirrors.begin(); i != _underlay_mirrors.end(); ++i) {
2023                 (*i)->add_ghost(rv);
2024         }
2025 }
2026
2027 RouteTimeAxisView::ProcessorAutomationInfo::~ProcessorAutomationInfo ()
2028 {
2029         for (vector<ProcessorAutomationNode*>::iterator i = lines.begin(); i != lines.end(); ++i) {
2030                 delete *i;
2031         }
2032 }
2033
2034
2035 RouteTimeAxisView::ProcessorAutomationNode::~ProcessorAutomationNode ()
2036 {
2037         parent.remove_processor_automation_node (this);
2038 }
2039
2040 void
2041 RouteTimeAxisView::remove_processor_automation_node (ProcessorAutomationNode* pan)
2042 {
2043         if (pan->view) {
2044                 remove_child (pan->view);
2045         }
2046 }
2047
2048 RouteTimeAxisView::ProcessorAutomationNode*
2049 RouteTimeAxisView::find_processor_automation_node (boost::shared_ptr<Processor> processor, Evoral::Parameter what)
2050 {
2051         for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
2052
2053                 if ((*i)->processor == processor) {
2054
2055                         for (vector<ProcessorAutomationNode*>::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) {
2056                                 if ((*ii)->what == what) {
2057                                         return *ii;
2058                                 }
2059                         }
2060                 }
2061         }
2062
2063         return 0;
2064 }
2065
2066 /** Add an AutomationTimeAxisView to display automation for a processor's parameter */
2067 void
2068 RouteTimeAxisView::add_processor_automation_curve (boost::shared_ptr<Processor> processor, Evoral::Parameter what)
2069 {
2070         string name;
2071         ProcessorAutomationNode* pan;
2072
2073         if ((pan = find_processor_automation_node (processor, what)) == 0) {
2074                 /* session state may never have been saved with new plugin */
2075                 error << _("programming error: ")
2076                       << string_compose (X_("processor automation curve for %1:%2/%3/%4 not registered with track!"),
2077                                          processor->name(), what.type(), (int) what.channel(), what.id() )
2078                       << endmsg;
2079                 abort(); /*NOTREACHED*/
2080                 return;
2081         }
2082
2083         if (pan->view) {
2084                 return;
2085         }
2086
2087         boost::shared_ptr<AutomationControl> control
2088                 = boost::dynamic_pointer_cast<AutomationControl>(processor->control(what, true));
2089
2090         pan->view = boost::shared_ptr<AutomationTimeAxisView>(
2091                 new AutomationTimeAxisView (_session, _route, processor, control, control->parameter (),
2092                                             _editor, *this, false, parent_canvas,
2093                                             processor->describe_parameter (what), processor->name()));
2094
2095         pan->view->Hiding.connect (sigc::bind (sigc::mem_fun(*this, &RouteTimeAxisView::processor_automation_track_hidden), pan, processor));
2096
2097         add_automation_child (control->parameter(), pan->view, pan->view->marked_for_display ());
2098
2099         if (_view) {
2100                 _view->foreach_regionview (sigc::mem_fun(*pan->view.get(), &TimeAxisView::add_ghost));
2101         }
2102 }
2103
2104 void
2105 RouteTimeAxisView::processor_automation_track_hidden (RouteTimeAxisView::ProcessorAutomationNode* pan, boost::shared_ptr<Processor>)
2106 {
2107         if (!_hidden) {
2108                 pan->menu_item->set_active (false);
2109         }
2110
2111         if (!no_redraw) {
2112                 request_redraw ();
2113         }
2114 }
2115
2116 void
2117 RouteTimeAxisView::add_existing_processor_automation_curves (boost::weak_ptr<Processor> p)
2118 {
2119         boost::shared_ptr<Processor> processor (p.lock ());
2120
2121         if (!processor || boost::dynamic_pointer_cast<Amp> (processor)) {
2122                 /* The Amp processor is a special case and is dealt with separately */
2123                 return;
2124         }
2125
2126         set<Evoral::Parameter> existing;
2127
2128         processor->what_has_data (existing);
2129
2130         for (set<Evoral::Parameter>::iterator i = existing.begin(); i != existing.end(); ++i) {
2131
2132                 Evoral::Parameter param (*i);
2133                 boost::shared_ptr<AutomationLine> al;
2134
2135                 if ((al = find_processor_automation_curve (processor, param)) != 0) {
2136                         al->queue_reset ();
2137                 } else {
2138                         add_processor_automation_curve (processor, param);
2139                 }
2140         }
2141 }
2142
2143 void
2144 RouteTimeAxisView::add_processor_to_subplugin_menu (boost::weak_ptr<Processor> p)
2145 {
2146         boost::shared_ptr<Processor> processor (p.lock ());
2147
2148         if (!processor || !processor->display_to_user ()) {
2149                 return;
2150         }
2151
2152         /* we use this override to veto the Amp processor from the plugin menu,
2153            as its automation lane can be accessed using the special "Fader" menu
2154            option
2155         */
2156
2157         if (boost::dynamic_pointer_cast<Amp> (processor) != 0) {
2158                 return;
2159         }
2160
2161         using namespace Menu_Helpers;
2162         ProcessorAutomationInfo *rai;
2163         list<ProcessorAutomationInfo*>::iterator x;
2164
2165         const std::set<Evoral::Parameter>& automatable = processor->what_can_be_automated ();
2166
2167         if (automatable.empty()) {
2168                 return;
2169         }
2170
2171         for (x = processor_automation.begin(); x != processor_automation.end(); ++x) {
2172                 if ((*x)->processor == processor) {
2173                         break;
2174                 }
2175         }
2176
2177         if (x == processor_automation.end()) {
2178                 rai = new ProcessorAutomationInfo (processor);
2179                 processor_automation.push_back (rai);
2180         } else {
2181                 rai = *x;
2182         }
2183
2184         /* any older menu was deleted at the top of processors_changed()
2185            when we cleared the subplugin menu.
2186         */
2187
2188         rai->menu = manage (new Menu);
2189         MenuList& items = rai->menu->items();
2190         rai->menu->set_name ("ArdourContextMenu");
2191
2192         items.clear ();
2193
2194         std::set<Evoral::Parameter> has_visible_automation;
2195         AutomationTimeAxisView::what_has_visible_automation (processor, has_visible_automation);
2196
2197         for (std::set<Evoral::Parameter>::const_iterator i = automatable.begin(); i != automatable.end(); ++i) {
2198
2199                 ProcessorAutomationNode* pan;
2200                 Gtk::CheckMenuItem* mitem;
2201
2202                 string name = processor->describe_parameter (*i);
2203
2204                 if (name == X_("hidden")) {
2205                         continue;
2206                 }
2207
2208                 items.push_back (CheckMenuElem (name));
2209                 mitem = dynamic_cast<Gtk::CheckMenuItem*> (&items.back());
2210
2211                 _subplugin_menu_map[*i] = mitem;
2212
2213                 if (has_visible_automation.find((*i)) != has_visible_automation.end()) {
2214                         mitem->set_active(true);
2215                 }
2216
2217                 if ((pan = find_processor_automation_node (processor, *i)) == 0) {
2218
2219                         /* new item */
2220
2221                         pan = new ProcessorAutomationNode (*i, mitem, *this);
2222
2223                         rai->lines.push_back (pan);
2224
2225                 } else {
2226
2227                         pan->menu_item = mitem;
2228
2229                 }
2230
2231                 mitem->signal_toggled().connect (sigc::bind (sigc::mem_fun(*this, &RouteTimeAxisView::processor_menu_item_toggled), rai, pan));
2232         }
2233
2234         if (items.size() == 0) {
2235                 return;
2236         }
2237
2238         /* add the menu for this processor, because the subplugin
2239            menu is always cleared at the top of processors_changed().
2240            this is the result of some poor design in gtkmm and/or
2241            GTK+.
2242         */
2243
2244         subplugin_menu.items().push_back (MenuElem (processor->name(), *rai->menu));
2245         rai->valid = true;
2246 }
2247
2248 void
2249 RouteTimeAxisView::processor_menu_item_toggled (RouteTimeAxisView::ProcessorAutomationInfo* rai,
2250                                                RouteTimeAxisView::ProcessorAutomationNode* pan)
2251 {
2252         bool showit = pan->menu_item->get_active();
2253         bool redraw = false;
2254
2255         if (pan->view == 0 && showit) {
2256                 add_processor_automation_curve (rai->processor, pan->what);
2257                 redraw = true;
2258         }
2259
2260         if (pan->view && pan->view->set_marked_for_display (showit)) {
2261                 redraw = true;
2262         }
2263
2264         if (redraw && !no_redraw) {
2265                 request_redraw ();
2266         }
2267 }
2268
2269 void
2270 RouteTimeAxisView::processors_changed (RouteProcessorChange c)
2271 {
2272         if (c.type == RouteProcessorChange::MeterPointChange) {
2273                 /* nothing to do if only the meter point has changed */
2274                 return;
2275         }
2276
2277         using namespace Menu_Helpers;
2278
2279         for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) {
2280                 (*i)->valid = false;
2281         }
2282
2283         setup_processor_menu_and_curves ();
2284
2285         bool deleted_processor_automation = false;
2286
2287         for (list<ProcessorAutomationInfo*>::iterator i = processor_automation.begin(); i != processor_automation.end(); ) {
2288
2289                 list<ProcessorAutomationInfo*>::iterator tmp;
2290
2291                 tmp = i;
2292                 ++tmp;
2293
2294                 if (!(*i)->valid) {
2295
2296                         delete *i;
2297                         processor_automation.erase (i);
2298                         deleted_processor_automation = true;
2299
2300                 }
2301
2302                 i = tmp;
2303         }
2304
2305         if (deleted_processor_automation && !no_redraw) {
2306                 request_redraw ();
2307         }
2308 }
2309
2310 boost::shared_ptr<AutomationLine>
2311 RouteTimeAxisView::find_processor_automation_curve (boost::shared_ptr<Processor> processor, Evoral::Parameter what)
2312 {
2313         ProcessorAutomationNode* pan;
2314
2315         if ((pan = find_processor_automation_node (processor, what)) != 0) {
2316                 if (pan->view) {
2317                         pan->view->line();
2318                 }
2319         }
2320
2321         return boost::shared_ptr<AutomationLine>();
2322 }
2323
2324 void
2325 RouteTimeAxisView::reset_processor_automation_curves ()
2326 {
2327         for (ProcessorAutomationCurves::iterator i = processor_automation_curves.begin(); i != processor_automation_curves.end(); ++i) {
2328                 (*i)->reset();
2329         }
2330 }
2331
2332 bool
2333 RouteTimeAxisView::can_edit_name () const
2334 {
2335         /* we do not allow track name changes if it is record enabled
2336          */
2337         boost::shared_ptr<Track> trk (boost::dynamic_pointer_cast<Track> (_route));
2338         if (!trk) {
2339                 return true;
2340         }
2341         return !trk->rec_enable_control()->get_value();
2342 }
2343
2344 void
2345 RouteTimeAxisView::blink_rec_display (bool onoff)
2346 {
2347         RouteUI::blink_rec_display (onoff);
2348 }
2349
2350 void
2351 RouteTimeAxisView::set_layer_display (LayerDisplay d, bool apply_to_selection)
2352 {
2353         if (_ignore_set_layer_display) {
2354                 return;
2355         }
2356
2357         if (apply_to_selection) {
2358                 _editor.get_selection().tracks.foreach_route_time_axis (boost::bind (&RouteTimeAxisView::set_layer_display, _1, d, false));
2359         } else {
2360
2361                 if (_view) {
2362                         _view->set_layer_display (d);
2363                 }
2364
2365                 set_gui_property (X_("layer-display"), d);
2366         }
2367 }
2368
2369 LayerDisplay
2370 RouteTimeAxisView::layer_display () const
2371 {
2372         if (_view) {
2373                 return _view->layer_display ();
2374         }
2375
2376         /* we don't know, since we don't have a _view, so just return something */
2377         return Overlaid;
2378 }
2379
2380 void
2381 RouteTimeAxisView::fast_update ()
2382 {
2383         gm.get_level_meter().update_meters ();
2384 }
2385
2386 void
2387 RouteTimeAxisView::hide_meter ()
2388 {
2389         clear_meter ();
2390         gm.get_level_meter().hide_meters ();
2391 }
2392
2393 void
2394 RouteTimeAxisView::show_meter ()
2395 {
2396         reset_meter ();
2397 }
2398
2399 void
2400 RouteTimeAxisView::reset_meter ()
2401 {
2402         if (UIConfiguration::instance().get_show_track_meters()) {
2403                 int meter_width = 3;
2404                 if (_route && _route->shared_peak_meter()->input_streams().n_total() == 1) {
2405                         meter_width = 6;
2406                 }
2407                 gm.get_level_meter().setup_meters (height - 9, meter_width);
2408         } else {
2409                 hide_meter ();
2410         }
2411 }
2412
2413 void
2414 RouteTimeAxisView::clear_meter ()
2415 {
2416         gm.get_level_meter().clear_meters ();
2417 }
2418
2419 void
2420 RouteTimeAxisView::meter_changed ()
2421 {
2422         ENSURE_GUI_THREAD (*this, &RouteTimeAxisView::meter_changed)
2423         reset_meter();
2424         if (_route && !no_redraw && UIConfiguration::instance().get_show_track_meters()) {
2425                 request_redraw ();
2426         }
2427         // reset peak when meter point changes
2428         gm.reset_peak_display();
2429 }
2430
2431 void
2432 RouteTimeAxisView::io_changed (IOChange /*change*/, void */*src*/)
2433 {
2434         reset_meter ();
2435         if (_route && !no_redraw) {
2436                 request_redraw ();
2437         }
2438 }
2439
2440 void
2441 RouteTimeAxisView::build_underlay_menu(Gtk::Menu* parent_menu)
2442 {
2443         using namespace Menu_Helpers;
2444
2445         if (!_underlay_streams.empty()) {
2446                 MenuList& parent_items = parent_menu->items();
2447                 Menu* gs_menu = manage (new Menu);
2448                 gs_menu->set_name ("ArdourContextMenu");
2449                 MenuList& gs_items = gs_menu->items();
2450
2451                 parent_items.push_back (MenuElem (_("Underlays"), *gs_menu));
2452
2453                 for(UnderlayList::iterator it = _underlay_streams.begin(); it != _underlay_streams.end(); ++it) {
2454                         gs_items.push_back(MenuElem(string_compose(_("Remove \"%1\""), (*it)->trackview().name()),
2455                                                     sigc::bind(sigc::mem_fun(*this, &RouteTimeAxisView::remove_underlay), *it)));
2456                 }
2457         }
2458 }
2459
2460 bool
2461 RouteTimeAxisView::set_underlay_state()
2462 {
2463         if (!underlay_xml_node) {
2464                 return false;
2465         }
2466
2467         XMLNodeList nlist = underlay_xml_node->children();
2468         XMLNodeConstIterator niter;
2469         XMLNode *child_node;
2470
2471         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2472                 child_node = *niter;
2473
2474                 if (child_node->name() != "Underlay") {
2475                         continue;
2476                 }
2477
2478                 XMLProperty const * prop = child_node->property ("id");
2479                 if (prop) {
2480                         PBD::ID id (prop->value());
2481
2482                         StripableTimeAxisView* v = _editor.get_stripable_time_axis_by_id (id);
2483
2484                         if (v) {
2485                                 add_underlay(v->view(), false);
2486                         }
2487                 }
2488         }
2489
2490         return false;
2491 }
2492
2493 void
2494 RouteTimeAxisView::add_underlay (StreamView* v, bool /*update_xml*/)
2495 {
2496         if (!v) {
2497                 return;
2498         }
2499
2500         RouteTimeAxisView& other = v->trackview();
2501
2502         if (find(_underlay_streams.begin(), _underlay_streams.end(), v) == _underlay_streams.end()) {
2503                 if (find(other._underlay_mirrors.begin(), other._underlay_mirrors.end(), this) != other._underlay_mirrors.end()) {
2504                         fatal << _("programming error: underlay reference pointer pairs are inconsistent!") << endmsg;
2505                         abort(); /*NOTREACHED*/
2506                 }
2507
2508                 _underlay_streams.push_back(v);
2509                 other._underlay_mirrors.push_back(this);
2510
2511                 v->foreach_regionview(sigc::mem_fun(*this, &RouteTimeAxisView::add_ghost));
2512
2513 #ifdef GUI_OBJECT_STATE_FIX_REQUIRED
2514                 if (update_xml) {
2515                         if (!underlay_xml_node) {
2516                                 underlay_xml_node = xml_node->add_child("Underlays");
2517                         }
2518
2519                         XMLNode* node = underlay_xml_node->add_child("Underlay");
2520                         XMLProperty const * prop = node->add_property("id");
2521                         prop->set_value(v->trackview().route()->id().to_s());
2522                 }
2523 #endif
2524         }
2525 }
2526
2527 void
2528 RouteTimeAxisView::remove_underlay (StreamView* v)
2529 {
2530         if (!v) {
2531                 return;
2532         }
2533
2534         UnderlayList::iterator it = find(_underlay_streams.begin(), _underlay_streams.end(), v);
2535         RouteTimeAxisView& other = v->trackview();
2536
2537         if (it != _underlay_streams.end()) {
2538                 UnderlayMirrorList::iterator gm = find(other._underlay_mirrors.begin(), other._underlay_mirrors.end(), this);
2539
2540                 if (gm == other._underlay_mirrors.end()) {
2541                         fatal << _("programming error: underlay reference pointer pairs are inconsistent!") << endmsg;
2542                         abort(); /*NOTREACHED*/
2543                 }
2544
2545                 v->foreach_regionview(sigc::mem_fun(*this, &RouteTimeAxisView::remove_ghost));
2546
2547                 _underlay_streams.erase(it);
2548                 other._underlay_mirrors.erase(gm);
2549
2550                 if (underlay_xml_node) {
2551                         underlay_xml_node->remove_nodes_and_delete("id", v->trackview().route()->id().to_s());
2552                 }
2553         }
2554 }
2555
2556 void
2557 RouteTimeAxisView::set_button_names ()
2558 {
2559         if (_route && _route->solo_safe_control()->solo_safe()) {
2560                 solo_button->set_visual_state (Gtkmm2ext::VisualState (solo_button->visual_state() | Gtkmm2ext::Insensitive));
2561         } else {
2562                 solo_button->set_visual_state (Gtkmm2ext::VisualState (solo_button->visual_state() & ~Gtkmm2ext::Insensitive));
2563         }
2564         if (Config->get_solo_control_is_listen_control()) {
2565                 switch (Config->get_listen_position()) {
2566                         case AfterFaderListen:
2567                                 solo_button->set_text (S_("AfterFader|A"));
2568                                 set_tooltip (*solo_button, _("After-fade listen (AFL)"));
2569                                 break;
2570                         case PreFaderListen:
2571                                 solo_button->set_text (S_("PreFader|P"));
2572                                 set_tooltip (*solo_button, _("Pre-fade listen (PFL)"));
2573                         break;
2574                 }
2575         } else {
2576                 solo_button->set_text (S_("Solo|S"));
2577                 set_tooltip (*solo_button, _("Solo"));
2578         }
2579         mute_button->set_text (S_("Mute|M"));
2580 }
2581
2582 Gtk::CheckMenuItem*
2583 RouteTimeAxisView::automation_child_menu_item (Evoral::Parameter param)
2584 {
2585         Gtk::CheckMenuItem* rv = StripableTimeAxisView::automation_child_menu_item (param);
2586         if (rv) {
2587                 return rv;
2588         }
2589
2590         ParameterMenuMap::iterator i = _subplugin_menu_map.find (param);
2591         if (i != _subplugin_menu_map.end()) {
2592                 return i->second;
2593         }
2594
2595         return 0;
2596 }
2597
2598 void
2599 RouteTimeAxisView::create_gain_automation_child (const Evoral::Parameter& param, bool show)
2600 {
2601         boost::shared_ptr<AutomationControl> c = _route->gain_control();
2602         if (!c) {
2603                 error << "Route has no gain automation, unable to add automation track view." << endmsg;
2604                 return;
2605         }
2606
2607         gain_track.reset (new AutomationTimeAxisView (_session,
2608                                                       _route, _route->amp(), c, param,
2609                                                       _editor,
2610                                                       *this,
2611                                                       false,
2612                                                       parent_canvas,
2613                                                       _route->amp()->describe_parameter(param)));
2614
2615         if (_view) {
2616                 _view->foreach_regionview (sigc::mem_fun (*gain_track.get(), &TimeAxisView::add_ghost));
2617         }
2618
2619         add_automation_child (Evoral::Parameter(GainAutomation), gain_track, show);
2620 }
2621
2622 void
2623 RouteTimeAxisView::create_trim_automation_child (const Evoral::Parameter& param, bool show)
2624 {
2625         boost::shared_ptr<AutomationControl> c = _route->trim()->gain_control();
2626         if (!c || ! _route->trim()->active()) {
2627                 return;
2628         }
2629
2630         trim_track.reset (new AutomationTimeAxisView (_session,
2631                                                       _route, _route->trim(), c, param,
2632                                                       _editor,
2633                                                       *this,
2634                                                       false,
2635                                                       parent_canvas,
2636                                                       _route->trim()->describe_parameter(param)));
2637
2638         if (_view) {
2639                 _view->foreach_regionview (sigc::mem_fun (*trim_track.get(), &TimeAxisView::add_ghost));
2640         }
2641
2642         add_automation_child (Evoral::Parameter(TrimAutomation), trim_track, show);
2643 }
2644
2645 void
2646 RouteTimeAxisView::create_mute_automation_child (const Evoral::Parameter& param, bool show)
2647 {
2648         boost::shared_ptr<AutomationControl> c = _route->mute_control();
2649         if (!c) {
2650                 error << "Route has no mute automation, unable to add automation track view." << endmsg;
2651                 return;
2652         }
2653
2654         mute_track.reset (new AutomationTimeAxisView (_session,
2655                                                       _route, _route, c, param,
2656                                                       _editor,
2657                                                       *this,
2658                                                       false,
2659                                                       parent_canvas,
2660                                                       _route->describe_parameter(param)));
2661
2662         if (_view) {
2663                 _view->foreach_regionview (sigc::mem_fun (*mute_track.get(), &TimeAxisView::add_ghost));
2664         }
2665
2666         add_automation_child (Evoral::Parameter(MuteAutomation), mute_track, show);
2667 }
2668
2669 static
2670 void add_region_to_list (RegionView* rv, RegionList* l)
2671 {
2672         l->push_back (rv->region());
2673 }
2674
2675 RegionView*
2676 RouteTimeAxisView::combine_regions ()
2677 {
2678         /* as of may 2011, we do not offer uncombine for MIDI tracks
2679          */
2680
2681         if (!is_audio_track()) {
2682                 return 0;
2683         }
2684
2685         if (!_view) {
2686                 return 0;
2687         }
2688
2689         RegionList selected_regions;
2690         boost::shared_ptr<Playlist> playlist = track()->playlist();
2691
2692         _view->foreach_selected_regionview (sigc::bind (sigc::ptr_fun (add_region_to_list), &selected_regions));
2693
2694         if (selected_regions.size() < 2) {
2695                 return 0;
2696         }
2697
2698         playlist->clear_changes ();
2699         boost::shared_ptr<Region> compound_region = playlist->combine (selected_regions);
2700
2701         _session->add_command (new StatefulDiffCommand (playlist));
2702         /* make the new region be selected */
2703
2704         return _view->find_view (compound_region);
2705 }
2706
2707 void
2708 RouteTimeAxisView::uncombine_regions ()
2709 {
2710         /* as of may 2011, we do not offer uncombine for MIDI tracks
2711          */
2712         if (!is_audio_track()) {
2713                 return;
2714         }
2715
2716         if (!_view) {
2717                 return;
2718         }
2719
2720         RegionList selected_regions;
2721         boost::shared_ptr<Playlist> playlist = track()->playlist();
2722
2723         /* have to grab selected regions first because the uncombine is going
2724          * to change that in the middle of the list traverse
2725          */
2726
2727         _view->foreach_selected_regionview (sigc::bind (sigc::ptr_fun (add_region_to_list), &selected_regions));
2728
2729         playlist->clear_changes ();
2730
2731         for (RegionList::iterator i = selected_regions.begin(); i != selected_regions.end(); ++i) {
2732                 playlist->uncombine (*i);
2733         }
2734
2735         _session->add_command (new StatefulDiffCommand (playlist));
2736 }
2737
2738 string
2739 RouteTimeAxisView::state_id() const
2740 {
2741         return string_compose ("rtav %1", _route->id().to_s());
2742 }
2743
2744
2745 void
2746 RouteTimeAxisView::remove_child (boost::shared_ptr<TimeAxisView> c)
2747 {
2748         TimeAxisView::remove_child (c);
2749
2750         boost::shared_ptr<AutomationTimeAxisView> a = boost::dynamic_pointer_cast<AutomationTimeAxisView> (c);
2751         if (a) {
2752                 for (AutomationTracks::iterator i = _automation_tracks.begin(); i != _automation_tracks.end(); ++i) {
2753                         if (i->second == a) {
2754                                 _automation_tracks.erase (i);
2755                                 return;
2756                         }
2757                 }
2758         }
2759 }
2760
2761 Gdk::Color
2762 RouteTimeAxisView::color () const
2763 {
2764         return route_color ();
2765 }
2766
2767 bool
2768 RouteTimeAxisView::marked_for_display () const
2769 {
2770         return !_route->presentation_info().hidden();
2771 }
2772
2773 bool
2774 RouteTimeAxisView::set_marked_for_display (bool yn)
2775 {
2776         return RouteUI::mark_hidden (!yn);
2777 }