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
  27 #include <sigc++/bind.h>
  28
  29 #include <pbd/error.h>
  30 #include <pbd/stl_delete.h>
  31 #include <pbd/whitespace.h>
  32 #include <pbd/memento_command.h>
  33
  34 #include <gtkmm/menu.h>
  35 #include <gtkmm/menuitem.h>
  36 #include <gtkmm2ext/gtk_ui.h>
  37 #include <gtkmm2ext/selector.h>
  38 #include <gtkmm2ext/stop_signal.h>
  39 #include <gtkmm2ext/bindable_button.h>
  40 #include <gtkmm2ext/utils.h>
  41
  42 #include <ardour/playlist.h>
  43 #include <ardour/audioplaylist.h>
  44 #include <ardour/diskstream.h>
  45 #include <ardour/insert.h>
  46 #include <ardour/ladspa_plugin.h>
  47 #include <ardour/location.h>
  48 #include <ardour/panner.h>
  49 #include <ardour/playlist.h>
  50 #include <ardour/session.h>
  51 #include <ardour/session_playlist.h>
  52 #include <ardour/utils.h>
  53 #include <ardour/profile.h>
  54
  55 #include "ardour_ui.h"
  56 #include "route_time_axis.h"
  57 #include "automation_time_axis.h"
  58 #include "redirect_automation_time_axis.h"
  59 #include "redirect_automation_line.h"
  60 #include "canvas_impl.h"
  61 #include "crossfade_view.h"
  62 #include "enums.h"
  63 #include "gui_thread.h"
  64 #include "keyboard.h"
  65 #include "playlist_selector.h"
  66 #include "point_selection.h"
  67 #include "prompter.h"
  68 #include "public_editor.h"
  69 #include "region_view.h"
  70 #include "rgb_macros.h"
  71 #include "selection.h"
  72 #include "simplerect.h"
  73 #include "streamview.h"
  74 #include "utils.h"
  75
  76 #include <ardour/track.h>
  77
  78 #include "i18n.h"
  79
  80 using namespace ARDOUR;
  81 using namespace PBD;
  82 using namespace Gtkmm2ext;
  83 using namespace Gtk;
  84 using namespace Editing;
  85 using namespace std;
  86
  87 Glib::RefPtr<Gdk::Pixbuf> RouteTimeAxisView::slider;
  88
  89 void
  90 RouteTimeAxisView::setup_slider_pix ()
  91 {
  92         if ((slider = ::get_icon ("fader_belt_h")) == 0) {
  93                 throw failed_constructor ();
  94         }
  95 }
  96
  97 RouteTimeAxisView::RouteTimeAxisView (PublicEditor& ed, Session& sess, boost::shared_ptr<Route> rt, Canvas& canvas)
  98         : AxisView(sess),
  99           RouteUI(rt, sess, _("m"), _("s"), _("r")), // mute, solo, and record
 100           TimeAxisView(sess,ed,(TimeAxisView*) 0, canvas),
 101           parent_canvas (canvas),
 102           button_table (3, 3),
 103           edit_group_button (_("g")), // group
 104           playlist_button (_("p")),
 105           size_button (_("h")), // height
 106           automation_button (_("a")),
 107           visual_button (_("v")),
 108           gm (sess, slider, true)
 109 {
 110         gm.set_io (rt);
 111         gm.get_level_meter().set_no_show_all();
 112         gm.get_level_meter().setup_meters(50);
 113
 114         _has_state = true;
 115         playlist_menu = 0;
 116         playlist_action_menu = 0;
 117         automation_action_menu = 0;
 118         _view = 0;
 119         timestretch_rect = 0;
 120         no_redraw = false;
 121         destructive_track_mode_item = 0;
 122         normal_track_mode_item = 0;
 123
 124         ignore_toggle = false;
 125
 126         edit_group_button.set_name ("TrackGroupButton");
 127         playlist_button.set_name ("TrackPlaylistButton");
 128         automation_button.set_name ("TrackAutomationButton");
 129         size_button.set_name ("TrackSizeButton");
 130         visual_button.set_name ("TrackVisualButton");
 131         hide_button.set_name ("TrackRemoveButton");
 132
 133         edit_group_button.unset_flags (Gtk::CAN_FOCUS);
 134         playlist_button.unset_flags (Gtk::CAN_FOCUS);
 135         automation_button.unset_flags (Gtk::CAN_FOCUS);
 136         size_button.unset_flags (Gtk::CAN_FOCUS);
 137         visual_button.unset_flags (Gtk::CAN_FOCUS);
 138         hide_button.unset_flags (Gtk::CAN_FOCUS);
 139
 140         hide_button.add (*(manage (new Image (::get_icon("hide")))));
 141         hide_button.show_all ();
 142
 143         edit_group_button.signal_button_release_event().connect (mem_fun(*this, &RouteTimeAxisView::edit_click), false);
 144         playlist_button.signal_clicked().connect (mem_fun(*this, &RouteTimeAxisView::playlist_click));
 145         automation_button.signal_clicked().connect (mem_fun(*this, &RouteTimeAxisView::automation_click));
 146         size_button.signal_button_release_event().connect (mem_fun(*this, &RouteTimeAxisView::size_click), false);
 147         visual_button.signal_clicked().connect (mem_fun(*this, &RouteTimeAxisView::visual_click));
 148         hide_button.signal_clicked().connect (mem_fun(*this, &RouteTimeAxisView::hide_click));
 149
 150         solo_button->signal_button_press_event().connect (mem_fun(*this, &RouteUI::solo_press), false);
 151         solo_button->signal_button_release_event().connect (mem_fun(*this, &RouteUI::solo_release), false);
 152         mute_button->signal_button_press_event().connect (mem_fun(*this, &RouteUI::mute_press), false);
 153         mute_button->signal_button_release_event().connect (mem_fun(*this, &RouteUI::mute_release), false);
 154
 155         if (is_track()) {
 156
 157                 /* use icon */
 158
 159                 rec_enable_button->remove ();
 160                 switch (track()->mode()) {
 161                 case ARDOUR::Normal:
 162                         rec_enable_button->add (*(manage (new Image (::get_icon (X_("record_normal_red"))))));
 163                         break;
 164                 case ARDOUR::Destructive:
 165                         rec_enable_button->add (*(manage (new Image (::get_icon (X_("record_tape_red"))))));
 166                         break;
 167                 }
 168                 rec_enable_button->show_all ();
 169
 170                 rec_enable_button->signal_button_press_event().connect (mem_fun(*this, &RouteUI::rec_enable_press), false);
 171                 rec_enable_button->signal_button_release_event().connect (mem_fun(*this, &RouteUI::rec_enable_release));
 172                 controls_table.attach (*rec_enable_button, 5, 6, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
 173                 ARDOUR_UI::instance()->tooltips().set_tip(*rec_enable_button, _("Record"));
 174
 175         }
 176
 177         controls_hbox.pack_start(gm.get_level_meter(), false, false);
 178         _route->meter_change.connect (mem_fun(*this, &RouteTimeAxisView::meter_changed));
 179         _route->input_changed.connect (mem_fun(*this, &RouteTimeAxisView::io_changed));
 180         _route->output_changed.connect (mem_fun(*this, &RouteTimeAxisView::io_changed));
 181
 182         controls_table.attach (*mute_button, 6, 7, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
 183         controls_table.attach (*solo_button, 7, 8, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
 184
 185         controls_table.attach (edit_group_button, 7, 8, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
 186         controls_table.attach (gm.get_gain_slider(), 0, 5, 1, 2, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
 187
 188         ARDOUR_UI::instance()->tooltips().set_tip(*solo_button,_("Solo"));
 189         ARDOUR_UI::instance()->tooltips().set_tip(*mute_button,_("Mute"));
 190         ARDOUR_UI::instance()->tooltips().set_tip(edit_group_button,_("Edit Group"));
 191         ARDOUR_UI::instance()->tooltips().set_tip(size_button,_("Display Height"));
 192         ARDOUR_UI::instance()->tooltips().set_tip(playlist_button,_("Playlist"));
 193         ARDOUR_UI::instance()->tooltips().set_tip(automation_button, _("Automation"));
 194         ARDOUR_UI::instance()->tooltips().set_tip(visual_button, _("Visual options"));
 195         ARDOUR_UI::instance()->tooltips().set_tip(hide_button, _("Hide this track"));
 196
 197         label_view ();
 198
 199         if (0) {
 200
 201                 /* old school - when we used to put an extra row of buttons in place */
 202
 203                 controls_table.attach (hide_button, 0, 1, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
 204                 controls_table.attach (visual_button, 1, 2, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
 205                 controls_table.attach (size_button, 2, 3, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
 206                 controls_table.attach (automation_button, 3, 4, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
 207
 208         } else {
 209
 210                 controls_table.attach (automation_button, 6, 7, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
 211         }
 212
 213         if (is_track() && track()->mode() == ARDOUR::Normal) {
 214                 controls_table.attach (playlist_button, 5, 6, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
 215         }
 216
 217         y_position = -1;
 218
 219         _route->redirects_changed.connect (mem_fun(*this, &RouteTimeAxisView::redirects_changed));
 220         _route->name_changed.connect (mem_fun(*this, &RouteTimeAxisView::route_name_changed));
 221
 222         if (is_track()) {
 223
 224                 track()->TrackModeChanged.connect (mem_fun(*this, &RouteTimeAxisView::track_mode_changed));
 225                 track()->FreezeChange.connect (mem_fun(*this, &RouteTimeAxisView::map_frozen));
 226                 track()->DiskstreamChanged.connect (mem_fun(*this, &RouteTimeAxisView::diskstream_changed));
 227                 get_diskstream()->SpeedChanged.connect (mem_fun(*this, &RouteTimeAxisView::speed_changed));
 228
 229                 /* pick up the correct freeze state */
 230                 map_frozen ();
 231
 232         }
 233
 234         editor.ZoomChanged.connect (mem_fun(*this, &RouteTimeAxisView::reset_samples_per_unit));
 235         ColorsChanged.connect (mem_fun (*this, &RouteTimeAxisView::color_handler));
 236
 237         gm.get_gain_slider().signal_scroll_event().connect(mem_fun(*this, &RouteTimeAxisView::controls_ebox_scroll), false);
 238         gm.get_gain_slider().set_name ("TrackGainFader");
 239 }
 240
 241 RouteTimeAxisView::~RouteTimeAxisView ()
 242 {
 243         GoingAway (); /* EMIT_SIGNAL */
 244
 245         vector_delete (&redirect_automation_curves);
 246
 247         for (list<RedirectAutomationInfo*>::iterator i = redirect_automation.begin(); i != redirect_automation.end(); ++i) {
 248                 delete *i;
 249         }
 250
 251         if (playlist_menu) {
 252                 delete playlist_menu;
 253                 playlist_menu = 0;
 254         }
 255
 256         if (playlist_action_menu) {
 257                 delete playlist_action_menu;
 258                 playlist_action_menu = 0;
 259         }
 260
 261         if (_view) {
 262                 delete _view;
 263                 _view = 0;
 264         }
 265 }
 266
 267 void
 268 RouteTimeAxisView::post_construct ()
 269 {
 270         /* map current state of the route */
 271
 272         update_diskstream_display ();
 273         subplugin_menu.items().clear ();
 274         _route->foreach_redirect (this, &RouteTimeAxisView::add_redirect_to_subplugin_menu);
 275         _route->foreach_redirect (this, &RouteTimeAxisView::add_existing_redirect_automation_curves);
 276         reset_redirect_automation_curves ();
 277 }
 278
 279 void
 280 RouteTimeAxisView::set_playlist (boost::shared_ptr<Playlist> newplaylist)
 281 {
 282         boost::shared_ptr<Playlist> pl = playlist();
 283         assert(pl);
 284
 285         modified_connection.disconnect ();
 286         modified_connection = pl->Modified.connect (mem_fun(*this, &RouteTimeAxisView::playlist_modified));
 287 }
 288
 289 void
 290 RouteTimeAxisView::playlist_modified ()
 291 {
 292 }
 293
 294 gint
 295 RouteTimeAxisView::edit_click (GdkEventButton *ev)
 296 {
 297         if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
 298                 _route->set_edit_group (0, this);
 299                 return FALSE;
 300         }
 301
 302         using namespace Menu_Helpers;
 303
 304         MenuList& items = edit_group_menu.items ();
 305         RadioMenuItem::Group group;
 306
 307         items.clear ();
 308         items.push_back (RadioMenuElem (group, _("No group"),
 309                                         bind (mem_fun(*this, &RouteTimeAxisView::set_edit_group_from_menu), (RouteGroup *) 0)));
 310
 311         if (_route->edit_group() == 0) {
 312                 static_cast<RadioMenuItem*>(&items.back())->set_active ();
 313         }
 314
 315         _session.foreach_edit_group (bind (mem_fun (*this, &RouteTimeAxisView::add_edit_group_menu_item), &group));
 316         edit_group_menu.popup (ev->button, ev->time);
 317
 318         return FALSE;
 319 }
 320
 321 void
 322 RouteTimeAxisView::add_edit_group_menu_item (RouteGroup *eg, RadioMenuItem::Group* group)
 323 {
 324         using namespace Menu_Helpers;
 325
 326         MenuList &items = edit_group_menu.items();
 327
 328         items.push_back (RadioMenuElem (*group, eg->name(), bind (mem_fun(*this, &RouteTimeAxisView::set_edit_group_from_menu), eg)));
 329         if (_route->edit_group() == eg) {
 330                 static_cast<RadioMenuItem*>(&items.back())->set_active ();
 331         }
 332 }
 333
 334 void
 335 RouteTimeAxisView::set_edit_group_from_menu (RouteGroup *eg)
 336 {
 337         _route->set_edit_group (eg, this);
 338 }
 339
 340 void
 341 RouteTimeAxisView::playlist_changed ()
 342 {
 343         label_view ();
 344
 345         if (is_track()) {
 346                 set_playlist (get_diskstream()->playlist());
 347         }
 348 }
 349
 350 void
 351 RouteTimeAxisView::label_view ()
 352 {
 353         string x = _route->name();
 354
 355         if (x != name_entry.get_text()) {
 356                 name_entry.set_text (x);
 357         }
 358
 359         ARDOUR_UI::instance()->tooltips().set_tip (name_entry, x);
 360 }
 361
 362 void
 363 RouteTimeAxisView::route_name_changed (void *src)
 364 {
 365         editor.route_name_changed (this);
 366         label_view ();
 367 }
 368
 369 void
 370 RouteTimeAxisView::take_name_changed (void *src)
 371
 372 {
 373         if (src != this) {
 374                 label_view ();
 375         }
 376 }
 377
 378 void
 379 RouteTimeAxisView::playlist_click ()
 380 {
 381         // always build a new action menu
 382
 383         if (playlist_action_menu != 0) {
 384                 delete playlist_action_menu;
 385         }
 386
 387         playlist_action_menu = new Menu;
 388         playlist_action_menu->set_name ("ArdourContextMenu");
 389
 390         build_playlist_menu (playlist_action_menu);
 391
 392         conditionally_add_to_selection ();
 393         playlist_action_menu->popup (1, gtk_get_current_event_time());
 394 }
 395
 396 void
 397 RouteTimeAxisView::automation_click ()
 398 {
 399         conditionally_add_to_selection ();
 400         build_automation_action_menu ();
 401         automation_action_menu->popup (1, gtk_get_current_event_time());
 402 }
 403
 404 void
 405 RouteTimeAxisView::build_automation_action_menu ()
 406 {
 407         using namespace Menu_Helpers;
 408
 409         automation_action_menu = manage (new Menu);
 410         MenuList& automation_items = automation_action_menu->items();
 411         automation_action_menu->set_name ("ArdourContextMenu");
 412
 413         automation_items.push_back (MenuElem (_("Show all automation"),
 414                                               mem_fun(*this, &RouteTimeAxisView::show_all_automation)));
 415
 416         automation_items.push_back (MenuElem (_("Show existing automation"),
 417                                               mem_fun(*this, &RouteTimeAxisView::show_existing_automation)));
 418
 419         automation_items.push_back (MenuElem (_("Hide all automation"),
 420                                               mem_fun(*this, &RouteTimeAxisView::hide_all_automation)));
 421
 422         automation_items.push_back (MenuElem (_("Plugins"), subplugin_menu));
 423 }
 424
 425 void
 426 RouteTimeAxisView::build_display_menu ()
 427 {
 428         using namespace Menu_Helpers;
 429
 430         /* get the size menu ready */
 431
 432         build_size_menu ();
 433
 434         /* prepare it */
 435
 436         TimeAxisView::build_display_menu ();
 437
 438         /* now fill it with our stuff */
 439
 440         MenuList& items = display_menu->items();
 441         display_menu->set_name ("ArdourContextMenu");
 442
 443         items.push_back (MenuElem (_("Height"), *size_menu));
 444         items.push_back (MenuElem (_("Color"), mem_fun(*this, &RouteTimeAxisView::select_track_color)));
 445
 446         items.push_back (SeparatorElem());
 447
 448         if (!Profile->get_sae()) {
 449                 build_remote_control_menu ();
 450                 items.push_back (MenuElem (_("Remote Control ID"), *remote_control_menu));
 451                 /* rebuild this every time */
 452                 build_automation_action_menu ();
 453                 items.push_back (MenuElem (_("Automation"), *automation_action_menu));
 454                 items.push_back (SeparatorElem());
 455         }
 456
 457         // Hook for derived classes to add type specific stuff
 458         append_extra_display_menu_items ();
 459         items.push_back (SeparatorElem());
 460
 461         if (is_track()) {
 462
 463                 Menu* alignment_menu = manage (new Menu);
 464                 MenuList& alignment_items = alignment_menu->items();
 465                 alignment_menu->set_name ("ArdourContextMenu");
 466
 467                 RadioMenuItem::Group align_group;
 468
 469                 alignment_items.push_back (RadioMenuElem (align_group, _("Align with existing material"),
 470                         bind (mem_fun(*this, &RouteTimeAxisView::set_align_style), ExistingMaterial)));
 471                 align_existing_item = dynamic_cast<RadioMenuItem*>(&alignment_items.back());
 472                 if (get_diskstream()->alignment_style() == ExistingMaterial)
 473                         align_existing_item->set_active();
 474
 475                 alignment_items.push_back (RadioMenuElem (align_group, _("Align with capture time"),
 476                         bind (mem_fun(*this, &RouteTimeAxisView::set_align_style), CaptureTime)));
 477                 align_capture_item = dynamic_cast<RadioMenuItem*>(&alignment_items.back());
 478                 if (get_diskstream()->alignment_style() == CaptureTime)
 479                         align_capture_item->set_active();
 480
 481                 if (!Profile->get_sae()) {
 482                         items.push_back (MenuElem (_("Alignment"), *alignment_menu));
 483                         get_diskstream()->AlignmentStyleChanged.connect (mem_fun(*this, &RouteTimeAxisView::align_style_changed));
 484
 485                         RadioMenuItem::Group mode_group;
 486                         items.push_back (RadioMenuElem (mode_group, _("Normal mode"),
 487                                                         bind (mem_fun (*this, &RouteTimeAxisView::set_track_mode), ARDOUR::Normal)));
 488                         normal_track_mode_item = dynamic_cast<RadioMenuItem*>(&items.back());
 489                         items.push_back (RadioMenuElem (mode_group, _("Tape mode"),
 490                                                         bind (mem_fun (*this, &RouteTimeAxisView::set_track_mode), ARDOUR::Destructive)));
 491                         destructive_track_mode_item = dynamic_cast<RadioMenuItem*>(&items.back());
 492
 493                         switch (track()->mode()) {
 494                         case ARDOUR::Destructive:
 495                                 destructive_track_mode_item->set_active ();
 496                                 break;
 497                         case ARDOUR::Normal:
 498                                 normal_track_mode_item->set_active ();
 499                                 break;
 500                         }
 501
 502                         items.push_back (SeparatorElem());
 503                 }
 504         }
 505
 506         items.push_back (CheckMenuElem (_("Active"), mem_fun(*this, &RouteUI::toggle_route_active)));
 507         route_active_menu_item = dynamic_cast<CheckMenuItem *> (&items.back());
 508         route_active_menu_item->set_active (_route->active());
 509
 510         items.push_back (SeparatorElem());
 511         items.push_back (MenuElem (_("Hide"), mem_fun(*this, &RouteTimeAxisView::hide_click)));
 512         if (!Profile->get_sae()) {
 513                 items.push_back (MenuElem (_("Remove"), mem_fun(*this, &RouteUI::remove_this_route)));
 514         } else {
 515                 items.push_front (SeparatorElem());
 516                 items.push_front (MenuElem (_("Delete"), mem_fun(*this, &RouteUI::remove_this_route)));
 517         }
 518 }
 519
 520 static bool __reset_item (RadioMenuItem* item)
 521 {
 522         item->set_active ();
 523         return false;
 524 }
 525
 526 void
 527 RouteTimeAxisView::set_track_mode (TrackMode mode)
 528 {
 529         RadioMenuItem* item;
 530         RadioMenuItem* other_item;
 531
 532         switch (mode) {
 533         case ARDOUR::Normal:
 534                 item = normal_track_mode_item;
 535                 other_item = destructive_track_mode_item;
 536                 break;
 537         case ARDOUR::Destructive:
 538                 item = destructive_track_mode_item;
 539                 other_item = normal_track_mode_item;
 540                 break;
 541         default:
 542                 fatal << string_compose (_("programming error: %1 %2"), "illegal track mode in RouteTimeAxisView::set_track_mode", mode) << endmsg;
 543                 /*NOTREACHED*/
 544                 return;
 545         }
 546
 547         if (item && other_item && item->get_active () && track()->mode() != mode) {
 548                 _set_track_mode (track(), mode, other_item);
 549         }
 550 }
 551
 552 void
 553 RouteTimeAxisView::_set_track_mode (boost::shared_ptr<Track> track, TrackMode mode, RadioMenuItem* reset_item)
 554 {
 555         bool needs_bounce;
 556
 557         if (!track->can_use_mode (mode, needs_bounce)) {
 558
 559                 if (!needs_bounce) {
 560                         /* cannot be done */
 561                         Glib::signal_idle().connect (bind (sigc::ptr_fun (__reset_item), reset_item));
 562                         return;
 563                 } else {
 564                         cerr << "would bounce this one\n";
 565                         return;
 566                 }
 567         }
 568
 569         track->set_mode (mode);
 570
 571         rec_enable_button->remove ();
 572         switch (mode) {
 573         case ARDOUR::Normal:
 574                 rec_enable_button->add (*(manage (new Image (::get_icon (X_("record_normal_red"))))));
 575                 break;
 576         case ARDOUR::Destructive:
 577                 rec_enable_button->add (*(manage (new Image (::get_icon (X_("record_tape_red"))))));
 578                 break;
 579         }
 580         rec_enable_button->show_all ();
 581
 582 }
 583
 584 void
 585 RouteTimeAxisView::track_mode_changed ()
 586 {
 587         RadioMenuItem* item;
 588
 589         switch (track()->mode()) {
 590         case ARDOUR::Normal:
 591                 item = normal_track_mode_item;
 592                 break;
 593         case ARDOUR::Destructive:
 594                 item = destructive_track_mode_item;
 595                 break;
 596         default:
 597                 fatal << string_compose (_("programming error: %1 %2"), "illegal track mode in RouteTimeAxisView::set_track_mode", track()->mode()) << endmsg;
 598                 /*NOTREACHED*/
 599                 return;
 600         }
 601
 602         item->set_active ();
 603 }
 604
 605 void
 606 RouteTimeAxisView::show_timestretch (nframes_t start, nframes_t end)
 607 {
 608         double x1;
 609         double x2;
 610         double y2;
 611
 612         TimeAxisView::show_timestretch (start, end);
 613
 614         hide_timestretch ();
 615
 616 #if 0
 617         if (ts.empty()) {
 618                 return;
 619         }
 620
 621
 622         /* check that the time selection was made in our route, or our edit group.
 623            remember that edit_group() == 0 implies the route is *not* in a edit group.
 624         */
 625
 626         if (!(ts.track == this || (ts.group != 0 && ts.group == _route->edit_group()))) {
 627                 /* this doesn't apply to us */
 628                 return;
 629         }
 630
 631         /* ignore it if our edit group is not active */
 632
 633         if ((ts.track != this) && _route->edit_group() && !_route->edit_group()->is_active()) {
 634                 return;
 635         }
 636 #endif
 637
 638         if (timestretch_rect == 0) {
 639                 timestretch_rect = new SimpleRect (*canvas_display);
 640                 timestretch_rect->property_x1() =  0.0;
 641                 timestretch_rect->property_y1() =  0.0;
 642                 timestretch_rect->property_x2() =  0.0;
 643                 timestretch_rect->property_y2() =  0.0;
 644                 timestretch_rect->property_fill_color_rgba() =  ARDOUR_UI::config()->canvasvar_TimeStretchFill.get();
 645                 timestretch_rect->property_outline_color_rgba() = ARDOUR_UI::config()->canvasvar_TimeStretchOutline.get();
 646         }
 647
 648         timestretch_rect->show ();
 649         timestretch_rect->raise_to_top ();
 650
 651         x1 = start / editor.get_current_zoom();
 652         x2 = (end - 1) / editor.get_current_zoom();
 653         y2 = current_height() - 2;
 654
 655         timestretch_rect->property_x1() = x1;
 656         timestretch_rect->property_y1() = 1.0;
 657         timestretch_rect->property_x2() = x2;
 658         timestretch_rect->property_y2() = y2;
 659 }
 660
 661 void
 662 RouteTimeAxisView::hide_timestretch ()
 663 {
 664         TimeAxisView::hide_timestretch ();
 665
 666         if (timestretch_rect) {
 667                 timestretch_rect->hide ();
 668         }
 669 }
 670
 671 void
 672 RouteTimeAxisView::show_selection (TimeSelection& ts)
 673 {
 674
 675 #if 0
 676         /* ignore it if our edit group is not active or if the selection was started
 677            in some other track or edit group (remember that edit_group() == 0 means
 678            that the track is not in an edit group).
 679         */
 680
 681         if (((ts.track != this && !is_child (ts.track)) && _route->edit_group() && !_route->edit_group()->is_active()) ||
 682             (!(ts.track == this || is_child (ts.track) || (ts.group != 0 && ts.group == _route->edit_group())))) {
 683                 hide_selection ();
 684                 return;
 685         }
 686 #endif
 687
 688         TimeAxisView::show_selection (ts);
 689 }
 690
 691 void
 692 RouteTimeAxisView::set_height (uint32_t h)
 693 {
 694         int gmlen = h - 5;
 695         bool height_changed = (height == 0) || (h != height);
 696         gm.get_level_meter().setup_meters (gmlen);
 697
 698         TimeAxisView::set_height (h);
 699
 700         ensure_xml_node ();
 701
 702         if (_view) {
 703                 _view->set_height ((double) current_height());
 704         }
 705
 706         char buf[32];
 707         snprintf (buf, sizeof (buf), "%u", height);
 708         xml_node->add_property ("height", buf);
 709
 710         if (height >= hNormal) {
 711                 reset_meter();
 712                 show_name_entry ();
 713                 hide_name_label ();
 714
 715                 gm.get_gain_slider().show();
 716                 mute_button->show();
 717                 solo_button->show();
 718                 if (rec_enable_button)
 719                         rec_enable_button->show();
 720
 721                 edit_group_button.show();
 722                 hide_button.show();
 723                 visual_button.show();
 724                 size_button.show();
 725                 automation_button.show();
 726
 727                 if (is_track() && track()->mode() == ARDOUR::Normal) {
 728                         playlist_button.show();
 729                 }
 730
 731         } else if (height >= hSmaller) {
 732
 733                 reset_meter();
 734                 show_name_entry ();
 735                 hide_name_label ();
 736
 737                 gm.get_gain_slider().hide();
 738                 mute_button->show();
 739                 solo_button->show();
 740                 if (rec_enable_button)
 741                         rec_enable_button->show();
 742
 743                 edit_group_button.hide ();
 744                 hide_button.hide ();
 745                 visual_button.hide ();
 746                 size_button.hide ();
 747                 automation_button.hide ();
 748
 749                 if (is_track() && track()->mode() == ARDOUR::Normal) {
 750                         playlist_button.hide ();
 751                 }
 752
 753         } else {
 754
 755                 hide_meter ();
 756
 757                 /* don't allow name_entry to be hidden while
 758                    it has focus, otherwise the GUI becomes unusable.
 759                 */
 760
 761                 if (name_entry.has_focus()) {
 762                         if (name_entry.get_text() != _route->name()) {
 763                                 name_entry_changed ();
 764                         }
 765                         controls_ebox.grab_focus ();
 766                 }
 767
 768                 hide_name_entry ();
 769                 show_name_label ();
 770
 771                 gm.get_gain_slider().hide();
 772                 mute_button->hide();
 773                 solo_button->hide();
 774                 if (rec_enable_button)
 775                         rec_enable_button->hide();
 776
 777                 edit_group_button.hide ();
 778                 hide_button.hide ();
 779                 visual_button.hide ();
 780                 size_button.hide ();
 781                 automation_button.hide ();
 782                 playlist_button.hide ();
 783                 name_label.set_text (_route->name());
 784         }
 785
 786         if (height_changed) {
 787                 /* only emit the signal if the height really changed */
 788                  _route->gui_changed ("track_height", (void *) 0); /* EMIT_SIGNAL */
 789         }
 790 }
 791
 792 void
 793 RouteTimeAxisView::select_track_color ()
 794 {
 795         if (RouteUI::choose_color ()) {
 796
 797                 if (_view) {
 798                         _view->apply_color (_color, StreamView::RegionColor);
 799                 }
 800         }
 801 }
 802
 803 void
 804 RouteTimeAxisView::reset_samples_per_unit ()
 805 {
 806         set_samples_per_unit (editor.get_current_zoom());
 807 }
 808
 809 void
 810 RouteTimeAxisView::set_samples_per_unit (double spu)
 811 {
 812         double speed = 1.0;
 813
 814         if (get_diskstream() != 0) {
 815                 speed = get_diskstream()->speed();
 816         }
 817
 818         if (_view) {
 819                 _view->set_samples_per_unit (spu * speed);
 820         }
 821
 822         TimeAxisView::set_samples_per_unit (spu * speed);
 823 }
 824
 825 void
 826 RouteTimeAxisView::align_style_changed ()
 827 {
 828         switch (get_diskstream()->alignment_style()) {
 829         case ExistingMaterial:
 830                 if (!align_existing_item->get_active()) {
 831                         align_existing_item->set_active();
 832                 }
 833                 break;
 834         case CaptureTime:
 835                 if (!align_capture_item->get_active()) {
 836                         align_capture_item->set_active();
 837                 }
 838                 break;
 839         }
 840 }
 841
 842 void
 843 RouteTimeAxisView::set_align_style (AlignStyle style)
 844 {
 845         RadioMenuItem* item;
 846
 847         switch (style) {
 848         case ExistingMaterial:
 849                 item = align_existing_item;
 850                 break;
 851         case CaptureTime:
 852                 item = align_capture_item;
 853                 break;
 854         default:
 855                 fatal << string_compose (_("programming error: %1 %2"), "illegal align style in RouteTimeAxisView::set_align_style", style) << endmsg;
 856                 /*NOTREACHED*/
 857                 return;
 858         }
 859
 860         if (item->get_active()) {
 861                 get_diskstream()->set_align_style (style);
 862         }
 863 }
 864
 865 void
 866 RouteTimeAxisView::rename_current_playlist ()
 867 {
 868         ArdourPrompter prompter (true);
 869         string name;
 870
 871         boost::shared_ptr<Diskstream> ds = get_diskstream();
 872         if (!ds || ds->destructive())
 873                 return;
 874
 875         boost::shared_ptr<Playlist> pl = ds->playlist();
 876         if (!pl)
 877                 return;
 878
 879         prompter.set_prompt (_("Name for playlist"));
 880         prompter.set_initial_text (pl->name());
 881         prompter.add_button (_("Rename"), Gtk::RESPONSE_ACCEPT);
 882         prompter.set_response_sensitive (Gtk::RESPONSE_ACCEPT, false);
 883
 884         switch (prompter.run ()) {
 885         case Gtk::RESPONSE_ACCEPT:
 886                 prompter.get_result (name);
 887                 if (name.length()) {
 888                         pl->set_name (name);
 889                 }
 890                 break;
 891
 892         default:
 893                 break;
 894         }
 895 }
 896
 897 std::string
 898 RouteTimeAxisView::resolve_new_group_playlist_name(std::string &basename, vector<boost::shared_ptr<Playlist> > const & playlists)
 899 {
 900         std::string ret(basename);
 901
 902         std::string group_string = "."+edit_group()->name()+".";
 903
 904         // iterate through all playlists
 905         int maxnumber = 0;
 906         for (vector<boost::shared_ptr<Playlist> >::const_iterator i = playlists.begin(); i != playlists.end(); ++i) {
 907                 std::string tmp = (*i)->name();
 908
 909                 std::string::size_type idx = tmp.find(group_string);
 910                 // find those which belong to this group
 911                 if (idx != string::npos) {
 912                         tmp = tmp.substr(idx + group_string.length());
 913
 914                         // and find the largest current number
 915                         int x = atoi(tmp.c_str());
 916                         if (x > maxnumber) {
 917                                 maxnumber = x;
 918                         }
 919                 }
 920         }
 921
 922         maxnumber++;
 923
 924         char buf[32];
 925         snprintf (buf, sizeof(buf), "%d", maxnumber);
 926
 927         ret = this->name()+"."+edit_group()->name()+"."+buf;
 928
 929         return ret;
 930 }
 931
 932 void
 933 RouteTimeAxisView::use_copy_playlist (bool prompt, vector<boost::shared_ptr<Playlist> > const & playlists_before_op)
 934 {
 935         string name;
 936
 937         boost::shared_ptr<Diskstream> ds = get_diskstream();
 938         if (!ds || ds->destructive())
 939                 return;
 940
 941         boost::shared_ptr<const Playlist> pl = ds->playlist();
 942         if (!pl)
 943                 return;
 944
 945         name = pl->name();
 946
 947         if (edit_group() && edit_group()->is_active()) {
 948                 name = resolve_new_group_playlist_name(name, playlists_before_op);
 949         }
 950
 951         while (_session.playlist_by_name(name)) {
 952                 name = Playlist::bump_name (name, _session);
 953         }
 954
 955         // TODO: The prompter "new" button should be de-activated if the user
 956         // specifies a playlist name which already exists in the session.
 957
 958         if (prompt) {
 959
 960                 ArdourPrompter prompter (true);
 961
 962                 prompter.set_prompt (_("Name for Playlist"));
 963                 prompter.set_initial_text (name);
 964                 prompter.add_button (Gtk::Stock::NEW, Gtk::RESPONSE_ACCEPT);
 965                 prompter.set_response_sensitive (Gtk::RESPONSE_ACCEPT, true);
 966                 prompter.show_all ();
 967
 968                 switch (prompter.run ()) {
 969                 case Gtk::RESPONSE_ACCEPT:
 970                         prompter.get_result (name);
 971                         break;
 972
 973                 default:
 974                         return;
 975                 }
 976         }
 977
 978         if (name.length()) {
 979                 ds->use_copy_playlist ();
 980                 ds->playlist()->set_name (name);
 981         }
 982 }
 983
 984 void
 985 RouteTimeAxisView::use_new_playlist (bool prompt, vector<boost::shared_ptr<Playlist> > const & playlists_before_op)
 986 {
 987         string name;
 988
 989         boost::shared_ptr<Diskstream> ds = get_diskstream();
 990         if (!ds || ds->destructive())
 991                 return;
 992
 993         boost::shared_ptr<const Playlist> pl = ds->playlist();
 994         if (!pl)
 995                 return;
 996
 997         name = pl->name();
 998
 999         if (edit_group() && edit_group()->is_active()) {
1000                 name = resolve_new_group_playlist_name(name,playlists_before_op);
1001         }
1002
1003         while (_session.playlist_by_name(name)) {
1004                 name = Playlist::bump_name (name, _session);
1005         }
1006
1007
1008         if (prompt) {
1009
1010                 ArdourPrompter prompter (true);
1011
1012                 prompter.set_prompt (_("Name for Playlist"));
1013                 prompter.set_initial_text (name);
1014                 prompter.add_button (Gtk::Stock::NEW, Gtk::RESPONSE_ACCEPT);
1015                 prompter.set_response_sensitive (Gtk::RESPONSE_ACCEPT, true);
1016
1017                 switch (prompter.run ()) {
1018                 case Gtk::RESPONSE_ACCEPT:
1019                         prompter.get_result (name);
1020                         break;
1021
1022                 default:
1023                         return;
1024                 }
1025         }
1026
1027         if (name.length()) {
1028                 ds->use_new_playlist ();
1029                 ds->playlist()->set_name (name);
1030         }
1031 }
1032
1033 void
1034 RouteTimeAxisView::clear_playlist ()
1035 {
1036         boost::shared_ptr<Diskstream> ds = get_diskstream();
1037         if (!ds || ds->destructive())
1038                 return;
1039
1040         boost::shared_ptr<Playlist> pl = ds->playlist();
1041         if (!pl)
1042                 return;
1043
1044         editor.clear_playlist (pl);
1045 }
1046
1047 void
1048 RouteTimeAxisView::speed_changed ()
1049 {
1050         Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &RouteTimeAxisView::reset_samples_per_unit));
1051 }
1052
1053 void
1054 RouteTimeAxisView::diskstream_changed ()
1055 {
1056         Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &RouteTimeAxisView::update_diskstream_display));
1057 }
1058
1059 void
1060 RouteTimeAxisView::update_diskstream_display ()
1061 {
1062         if (!get_diskstream()) // bus
1063                 return;
1064
1065         set_playlist (get_diskstream()->playlist());
1066         map_frozen ();
1067 }
1068
1069 void
1070 RouteTimeAxisView::selection_click (GdkEventButton* ev)
1071 {
1072         if (Keyboard::modifier_state_equals (ev->state, (Keyboard::TertiaryModifier|Keyboard::PrimaryModifier))) {
1073
1074                 /* special case: select/deselect all tracks */
1075                 if (editor.get_selection().selected (this)) {
1076                         editor.get_selection().clear_tracks ();
1077                 } else {
1078                         editor.select_all_tracks ();
1079                 }
1080
1081                 return;
1082         }
1083
1084         PublicEditor::TrackViewList* tracks = editor.get_valid_views (this, _route->edit_group());
1085
1086         switch (Keyboard::selection_type (ev->state)) {
1087         case Selection::Toggle:
1088                 editor.get_selection().toggle (*tracks);
1089                 break;
1090
1091         case Selection::Set:
1092                 editor.get_selection().set (*tracks);
1093                 break;
1094
1095         case Selection::Extend:
1096                 if (tracks->size() > 1) {
1097                         /* add each one, do not "extend" */
1098                         editor.get_selection().add (*tracks);
1099                 } else {
1100                         /* extend to the single track */
1101                         editor.extend_selection_to_track (*tracks->front());
1102                 }
1103                 break;
1104
1105         case Selection::Add:
1106                 editor.get_selection().add (*tracks);
1107                 break;
1108         }
1109
1110         delete tracks;
1111 }
1112
1113 void
1114 RouteTimeAxisView::set_selected_points (PointSelection& points)
1115 {
1116         for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
1117                 (*i)->set_selected_points (points);
1118         }
1119 }
1120
1121 void
1122 RouteTimeAxisView::set_selected_regionviews (RegionSelection& regions)
1123 {
1124         if (_view) {
1125                 _view->set_selected_regionviews (regions);
1126         }
1127 }
1128
1129 void
1130 RouteTimeAxisView::get_selectables (nframes_t start, nframes_t end, double top, double bot, list<Selectable*>& results)
1131 {
1132         double speed = 1.0;
1133
1134         if (get_diskstream() != 0) {
1135                 speed = get_diskstream()->speed();
1136         }
1137
1138         nframes_t start_adjusted = session_frame_to_track_frame(start, speed);
1139         nframes_t end_adjusted   = session_frame_to_track_frame(end, speed);
1140
1141         if ((_view && ((top < 0.0 && bot < 0.0))) || touched (top, bot)) {
1142                 _view->get_selectables (start_adjusted, end_adjusted, results);
1143         }
1144
1145         /* pick up visible automation tracks */
1146
1147         for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
1148                 if (!(*i)->hidden()) {
1149                         (*i)->get_selectables (start_adjusted, end_adjusted, top, bot, results);
1150                 }
1151         }
1152 }
1153
1154 void
1155 RouteTimeAxisView::get_inverted_selectables (Selection& sel, list<Selectable*>& results)
1156 {
1157         if (_view) {
1158                 _view->get_inverted_selectables (sel, results);
1159         }
1160
1161         for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
1162                 if (!(*i)->hidden()) {
1163                         (*i)->get_inverted_selectables (sel, results);
1164                 }
1165         }
1166
1167         return;
1168 }
1169
1170 RouteGroup*
1171 RouteTimeAxisView::edit_group() const
1172 {
1173         return _route->edit_group();
1174 }
1175
1176 string
1177 RouteTimeAxisView::name() const
1178 {
1179         return _route->name();
1180 }
1181
1182 boost::shared_ptr<Playlist>
1183 RouteTimeAxisView::playlist () const
1184 {
1185         boost::shared_ptr<Diskstream> ds;
1186
1187         if ((ds = get_diskstream()) != 0) {
1188                 return ds->playlist();
1189         } else {
1190                 return boost::shared_ptr<Playlist> ();
1191         }
1192 }
1193
1194 void
1195 RouteTimeAxisView::name_entry_changed ()
1196 {
1197         string x;
1198
1199         x = name_entry.get_text ();
1200
1201         if (x == _route->name()) {
1202                 return;
1203         }
1204
1205         strip_whitespace_edges(x);
1206
1207         if (x.length() == 0) {
1208                 name_entry.set_text (_route->name());
1209                 return;
1210         }
1211
1212         if (_session.route_name_unique (x)) {
1213                 _route->set_name (x, this);
1214         } else {
1215                 ARDOUR_UI::instance()->popup_error (_("A track already exists with that name"));
1216                 name_entry.set_text (_route->name());
1217         }
1218 }
1219
1220 void
1221 RouteTimeAxisView::visual_click ()
1222 {
1223         popup_display_menu (0);
1224 }
1225
1226 void
1227 RouteTimeAxisView::hide_click ()
1228 {
1229         // LAME fix for hide_button refresh fix
1230         hide_button.set_sensitive(false);
1231
1232         editor.hide_track_in_display (*this);
1233
1234         hide_button.set_sensitive(true);
1235 }
1236
1237 boost::shared_ptr<Region>
1238 RouteTimeAxisView::find_next_region (nframes_t pos, RegionPoint point, int32_t dir)
1239 {
1240         boost::shared_ptr<Diskstream> stream;
1241         boost::shared_ptr<Playlist> playlist;
1242
1243         if ((stream = get_diskstream()) != 0 && (playlist = stream->playlist()) != 0) {
1244                 return playlist->find_next_region (pos, point, dir);
1245         }
1246
1247         return boost::shared_ptr<Region> ();
1248 }
1249
1250 nframes64_t
1251 RouteTimeAxisView::find_next_region_boundary (nframes64_t pos, int32_t dir)
1252 {
1253         boost::shared_ptr<Diskstream> stream;
1254         boost::shared_ptr<Playlist> playlist;
1255
1256         if ((stream = get_diskstream()) != 0 && (playlist = stream->playlist()) != 0) {
1257                 return playlist->find_next_region_boundary (pos, dir);
1258         }
1259
1260         return -1;
1261 }
1262
1263 bool
1264 RouteTimeAxisView::cut_copy_clear (Selection& selection, CutCopyOp op)
1265 {
1266         boost::shared_ptr<Playlist> what_we_got;
1267         boost::shared_ptr<Diskstream> ds = get_diskstream();
1268         boost::shared_ptr<Playlist> playlist;
1269         bool ret = false;
1270
1271         if (ds == 0) {
1272                 /* route is a bus, not a track */
1273                 return false;
1274         }
1275
1276         playlist = ds->playlist();
1277
1278         TimeSelection time (selection.time);
1279         float speed = ds->speed();
1280         if (speed != 1.0f) {
1281                 for (TimeSelection::iterator i = time.begin(); i != time.end(); ++i) {
1282                         (*i).start = session_frame_to_track_frame((*i).start, speed);
1283                         (*i).end   = session_frame_to_track_frame((*i).end,   speed);
1284                 }
1285         }
1286
1287         XMLNode &before = playlist->get_state();
1288         switch (op) {
1289         case Cut:
1290                 if ((what_we_got = playlist->cut (time)) != 0) {
1291                         editor.get_cut_buffer().add (what_we_got);
1292                         _session.add_command( new MementoCommand<Playlist>(*playlist.get(), &before, &playlist->get_state()));
1293                         ret = true;
1294                 }
1295                 break;
1296         case Copy:
1297                 if ((what_we_got = playlist->copy (time)) != 0) {
1298                         editor.get_cut_buffer().add (what_we_got);
1299                 }
1300                 break;
1301
1302         case Clear:
1303                 if ((what_we_got = playlist->cut (time)) != 0) {
1304                         _session.add_command( new MementoCommand<Playlist>(*playlist, &before, &playlist->get_state()));
1305                         what_we_got->release ();
1306                         ret = true;
1307                 }
1308                 break;
1309         }
1310
1311         return ret;
1312 }
1313
1314 bool
1315 RouteTimeAxisView::paste (nframes_t pos, float times, Selection& selection, size_t nth)
1316 {
1317         if (!is_track()) {
1318                 return false;
1319         }
1320
1321         boost::shared_ptr<Playlist> playlist = get_diskstream()->playlist();
1322         PlaylistSelection::iterator p;
1323
1324         for (p = selection.playlists.begin(); p != selection.playlists.end() && nth; ++p, --nth);
1325
1326         if (p == selection.playlists.end()) {
1327                 return false;
1328         }
1329
1330         if (get_diskstream()->speed() != 1.0f)
1331                 pos = session_frame_to_track_frame(pos, get_diskstream()->speed() );
1332
1333         XMLNode &before = playlist->get_state();
1334         playlist->paste (*p, pos, times);
1335         _session.add_command( new MementoCommand<Playlist>(*playlist, &before, &playlist->get_state()));
1336
1337         return true;
1338 }
1339
1340
1341 list<TimeAxisView*>
1342 RouteTimeAxisView::get_child_list()
1343 {
1344
1345         list<TimeAxisView*>redirect_children;
1346
1347         for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
1348                 if (!(*i)->hidden()) {
1349                         redirect_children.push_back(*i);
1350                 }
1351         }
1352         return redirect_children;
1353 }
1354
1355
1356 void
1357 RouteTimeAxisView::build_playlist_menu (Gtk::Menu * menu)
1358 {
1359         using namespace Menu_Helpers;
1360
1361         if (!menu || !is_track()) {
1362                 return;
1363         }
1364
1365         MenuList& playlist_items = menu->items();
1366         menu->set_name ("ArdourContextMenu");
1367         playlist_items.clear();
1368
1369         if (playlist_menu) {
1370                 delete playlist_menu;
1371         }
1372
1373         playlist_menu = new Menu;
1374         playlist_menu->set_name ("ArdourContextMenu");
1375
1376         vector<boost::shared_ptr<Playlist> > playlists;
1377         boost::shared_ptr<Diskstream> ds = get_diskstream();
1378         RadioMenuItem::Group playlist_group;
1379
1380         _session.get_playlists (playlists);
1381
1382         for (vector<boost::shared_ptr<Playlist> >::iterator i = playlists.begin(); i != playlists.end(); ++i) {
1383
1384                 if ((*i)->get_orig_diskstream_id() == ds->id()) {
1385                         playlist_items.push_back (RadioMenuElem (playlist_group, (*i)->name(), bind (mem_fun (*this, &RouteTimeAxisView::use_playlist),
1386                                                                                                      boost::weak_ptr<Playlist> (*i))));
1387
1388                         if (ds->playlist()->id() == (*i)->id()) {
1389                                 static_cast<RadioMenuItem*>(&playlist_items.back())->set_active();
1390                         }
1391                 } else if (ds->playlist()->id() == (*i)->id()) {
1392                         playlist_items.push_back (RadioMenuElem (playlist_group, (*i)->name(), bind (mem_fun (*this, &RouteTimeAxisView::use_playlist),
1393                                                                                                      boost::weak_ptr<Playlist>(*i))));
1394                         static_cast<RadioMenuItem*>(&playlist_items.back())->set_active();
1395
1396                 }
1397         }
1398
1399         playlist_items.push_back (SeparatorElem());
1400         playlist_items.push_back (MenuElem (_("Rename"), mem_fun(*this, &RouteTimeAxisView::rename_current_playlist)));
1401         playlist_items.push_back (SeparatorElem());
1402
1403         if (!edit_group() || !edit_group()->is_active()) {
1404                 playlist_items.push_back (MenuElem (_("New"), bind(mem_fun(editor, &PublicEditor::new_playlists), this)));
1405                 playlist_items.push_back (MenuElem (_("New Copy"), bind(mem_fun(editor, &PublicEditor::copy_playlists), this)));
1406
1407         } else {
1408                 // Use a label which tells the user what is happening
1409                 playlist_items.push_back (MenuElem (_("New Take"), bind(mem_fun(editor, &PublicEditor::new_playlists), this)));
1410                 playlist_items.push_back (MenuElem (_("Copy Take"), bind(mem_fun(editor, &PublicEditor::copy_playlists), this)));
1411
1412         }
1413
1414         playlist_items.push_back (SeparatorElem());
1415         playlist_items.push_back (MenuElem (_("Clear Current"), bind(mem_fun(editor, &PublicEditor::clear_playlists), this)));
1416         playlist_items.push_back (SeparatorElem());
1417
1418         playlist_items.push_back (MenuElem(_("Select from all ..."), mem_fun(*this, &RouteTimeAxisView::show_playlist_selector)));
1419 }
1420
1421 void
1422 RouteTimeAxisView::use_playlist (boost::weak_ptr<Playlist> wpl)
1423 {
1424         assert (is_track());
1425
1426         boost::shared_ptr<Playlist> pl (wpl.lock());
1427
1428         if (!pl) {
1429                 return;
1430         }
1431
1432         boost::shared_ptr<AudioPlaylist> apl = boost::dynamic_pointer_cast<AudioPlaylist> (pl);
1433
1434         if (apl) {
1435                 if (get_diskstream()->playlist() == apl) {
1436                         // radio button cotnrols mean this function is called for both the
1437                         // old and new playlist
1438                         return;
1439                 }
1440                 get_diskstream()->use_playlist (apl);
1441
1442
1443                 if (edit_group() && edit_group()->is_active()) {
1444                         //PBD::stacktrace(cerr, 20);
1445                         std::string group_string = "."+edit_group()->name()+".";
1446
1447                         std::string take_name = apl->name();
1448                         std::string::size_type idx = take_name.find(group_string);
1449
1450                         if (idx == std::string::npos)
1451                                 return;
1452
1453                         take_name = take_name.substr(idx + group_string.length()); // find the bit containing the take number / name
1454
1455                         for (list<Route*>::const_iterator i = edit_group()->route_list().begin(); i != edit_group()->route_list().end(); ++i) {
1456                                 if ( (*i) == this->route().get()) {
1457                                         continue;
1458                                 }
1459
1460                                 std::string playlist_name = (*i)->name()+group_string+take_name;
1461
1462                                 Track *track = dynamic_cast<Track *>(*i);
1463                                 if (!track) {
1464                                         continue;
1465                                 }
1466
1467                                 boost::shared_ptr<Playlist> ipl = session().playlist_by_name(playlist_name);
1468                                 if (!ipl) {
1469                                         // No playlist for this track for this take yet, make it
1470                                         track->diskstream()->use_new_playlist();
1471                                         track->diskstream()->playlist()->set_name(playlist_name);
1472                                 } else {
1473                                         track->diskstream()->use_playlist(ipl);
1474                                 }
1475
1476                                 //(*i)->get_dis
1477                         }
1478                 }
1479         }
1480 }
1481
1482 void
1483 RouteTimeAxisView::show_playlist_selector ()
1484 {
1485         editor.playlist_selector().show_for (this);
1486 }
1487
1488 void
1489 RouteTimeAxisView::map_frozen ()
1490 {
1491         if (!is_track()) {
1492                 return;
1493         }
1494
1495         ENSURE_GUI_THREAD (mem_fun(*this, &RouteTimeAxisView::map_frozen));
1496
1497         switch (track()->freeze_state()) {
1498         case Track::Frozen:
1499                 playlist_button.set_sensitive (false);
1500                 rec_enable_button->set_sensitive (false);
1501                 break;
1502         default:
1503                 playlist_button.set_sensitive (true);
1504                 rec_enable_button->set_sensitive (true);
1505                 break;
1506         }
1507 }
1508
1509 void
1510 RouteTimeAxisView::color_handler ()
1511 {
1512         if (timestretch_rect) {
1513                 timestretch_rect->property_outline_color_rgba() = ARDOUR_UI::config()->canvasvar_TimeStretchOutline.get();
1514         }
1515
1516         if (timestretch_rect) {
1517                 timestretch_rect->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_TimeStretchFill.get();
1518         }
1519
1520         reset_meter();
1521 }
1522
1523 void
1524 RouteTimeAxisView::show_all_automation ()
1525 {
1526         no_redraw = true;
1527
1528         for (list<RedirectAutomationInfo*>::iterator i = redirect_automation.begin(); i != redirect_automation.end(); ++i) {
1529                 for (vector<RedirectAutomationNode*>::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) {
1530                         if ((*ii)->view == 0) {
1531                                 add_redirect_automation_curve ((*i)->redirect, (*ii)->what);
1532                         }
1533
1534                         (*ii)->menu_item->set_active (true);
1535                 }
1536         }
1537
1538         no_redraw = false;
1539
1540          _route->gui_changed ("visible_tracks", (void *) 0); /* EMIT_SIGNAL */
1541 }
1542
1543 void
1544 RouteTimeAxisView::show_existing_automation ()
1545 {
1546         no_redraw = true;
1547
1548         for (list<RedirectAutomationInfo*>::iterator i = redirect_automation.begin(); i != redirect_automation.end(); ++i) {
1549                 for (vector<RedirectAutomationNode*>::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) {
1550                         if ((*ii)->view != 0) {
1551                                 (*ii)->menu_item->set_active (true);
1552                         }
1553                 }
1554         }
1555
1556         no_redraw = false;
1557
1558         _route->gui_changed ("visible_tracks", (void *) 0); /* EMIT_SIGNAL */
1559 }
1560
1561 void
1562 RouteTimeAxisView::hide_all_automation ()
1563 {
1564         no_redraw = true;
1565
1566         for (list<RedirectAutomationInfo*>::iterator i = redirect_automation.begin(); i != redirect_automation.end(); ++i) {
1567                 for (vector<RedirectAutomationNode*>::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) {
1568                         (*ii)->menu_item->set_active (false);
1569                 }
1570         }
1571
1572         no_redraw = false;
1573          _route->gui_changed ("visible_tracks", (void *) 0); /* EMIT_SIGNAL */
1574 }
1575
1576
1577 void
1578 RouteTimeAxisView::region_view_added (RegionView* rv)
1579 {
1580         for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
1581                 AutomationTimeAxisView* atv;
1582
1583                 if ((atv = dynamic_cast<AutomationTimeAxisView*> (*i)) != 0) {
1584                         rv->add_ghost (*atv);
1585                 }
1586         }
1587 }
1588
1589 void
1590 RouteTimeAxisView::add_ghost_to_redirect (RegionView* rv, AutomationTimeAxisView* atv)
1591 {
1592         rv->add_ghost (*atv);
1593 }
1594
1595 RouteTimeAxisView::RedirectAutomationInfo::~RedirectAutomationInfo ()
1596 {
1597         for (vector<RedirectAutomationNode*>::iterator i = lines.begin(); i != lines.end(); ++i) {
1598                 delete *i;
1599         }
1600 }
1601
1602
1603 RouteTimeAxisView::RedirectAutomationNode::~RedirectAutomationNode ()
1604 {
1605         parent.remove_ran (this);
1606
1607         if (view) {
1608                 delete view;
1609         }
1610 }
1611
1612 void
1613 RouteTimeAxisView::remove_ran (RedirectAutomationNode* ran)
1614 {
1615         if (ran->view) {
1616                 remove_child (ran->view);
1617         }
1618 }
1619
1620 RouteTimeAxisView::RedirectAutomationNode*
1621 RouteTimeAxisView::find_redirect_automation_node (boost::shared_ptr<Redirect> redirect, uint32_t what)
1622 {
1623         for (list<RedirectAutomationInfo*>::iterator i = redirect_automation.begin(); i != redirect_automation.end(); ++i) {
1624
1625                 if ((*i)->redirect == redirect) {
1626
1627                         for (vector<RedirectAutomationNode*>::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) {
1628                                 if ((*ii)->what == what) {
1629                                         return *ii;
1630                                 }
1631                         }
1632                 }
1633         }
1634
1635         return 0;
1636 }
1637
1638 // FIXME: duplicated in midi_time_axis.cc
1639 static string
1640 legalize_for_xml_node (string str)
1641 {
1642         string::size_type pos;
1643         string legal_chars = "abcdefghijklmnopqrtsuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_=:";
1644         string legal;
1645
1646         legal = str;
1647         pos = 0;
1648
1649         while ((pos = legal.find_first_not_of (legal_chars, pos)) != string::npos) {
1650                 legal.replace (pos, 1, "_");
1651                 pos += 1;
1652         }
1653
1654         return legal;
1655 }
1656
1657
1658 void
1659 RouteTimeAxisView::add_redirect_automation_curve (boost::shared_ptr<Redirect> redirect, uint32_t what)
1660 {
1661         RedirectAutomationLine* ral;
1662         string name;
1663         RedirectAutomationNode* ran;
1664
1665         if ((ran = find_redirect_automation_node (redirect, what)) == 0) {
1666                 fatal << _("programming error: ")
1667                       << string_compose (X_("redirect automation curve for %1:%2 not registered with audio track!"),
1668                                   redirect->name(), what)
1669                       << endmsg;
1670                 /*NOTREACHED*/
1671                 return;
1672         }
1673
1674         if (ran->view) {
1675                 return;
1676         }
1677
1678         name = redirect->describe_parameter (what);
1679
1680         /* create a string that is a legal XML node name that can be used to refer to this redirect+port combination */
1681
1682         char state_name[256];
1683         snprintf (state_name, sizeof (state_name), "Redirect-%s-%" PRIu32, legalize_for_xml_node (redirect->name()).c_str(), what);
1684
1685         ran->view = new RedirectAutomationTimeAxisView (_session, _route, editor, *this, parent_canvas, name, what, *redirect, state_name);
1686
1687         ral = new RedirectAutomationLine (name,
1688                                           *redirect, what, _session, *ran->view,
1689                                           *ran->view->canvas_display, redirect->automation_list (what));
1690
1691         ral->set_line_color (ARDOUR_UI::config()->canvasvar_RedirectAutomationLine.get());
1692         ral->queue_reset ();
1693
1694         ran->view->add_line (*ral);
1695
1696         ran->view->Hiding.connect (bind (mem_fun(*this, &RouteTimeAxisView::redirect_automation_track_hidden), ran, redirect));
1697
1698         if (!ran->view->marked_for_display()) {
1699                 ran->view->hide ();
1700         } else {
1701                 ran->menu_item->set_active (true);
1702         }
1703
1704         add_child (ran->view);
1705
1706         if (_view) {
1707                 _view->foreach_regionview (bind (mem_fun(*this, &RouteTimeAxisView::add_ghost_to_redirect), ran->view));
1708         }
1709
1710         redirect->mark_automation_visible (what, true);
1711 }
1712
1713 void
1714 RouteTimeAxisView::redirect_automation_track_hidden (RouteTimeAxisView::RedirectAutomationNode* ran, boost::shared_ptr<Redirect> r)
1715 {
1716         if (!_hidden) {
1717                 ran->menu_item->set_active (false);
1718         }
1719
1720         r->mark_automation_visible (ran->what, false);
1721
1722          _route->gui_changed ("visible_tracks", (void *) 0); /* EMIT_SIGNAL */
1723 }
1724
1725 void
1726 RouteTimeAxisView::add_existing_redirect_automation_curves (boost::shared_ptr<Redirect> redirect)
1727 {
1728         set<uint32_t> s;
1729         RedirectAutomationLine *ral;
1730
1731         redirect->what_has_visible_automation (s);
1732
1733         for (set<uint32_t>::iterator i = s.begin(); i != s.end(); ++i) {
1734
1735                 if ((ral = find_redirect_automation_curve (redirect, *i)) != 0) {
1736                         ral->queue_reset ();
1737                 } else {
1738                         add_redirect_automation_curve (redirect, (*i));
1739                 }
1740         }
1741 }
1742
1743 void
1744 RouteTimeAxisView::add_redirect_to_subplugin_menu (boost::shared_ptr<Redirect> r)
1745 {
1746         using namespace Menu_Helpers;
1747         RedirectAutomationInfo *rai;
1748         list<RedirectAutomationInfo*>::iterator x;
1749
1750         const std::set<uint32_t>& automatable = r->what_can_be_automated ();
1751         std::set<uint32_t> has_visible_automation;
1752
1753         r->what_has_visible_automation(has_visible_automation);
1754
1755         if (automatable.empty()) {
1756                 return;
1757         }
1758
1759         for (x = redirect_automation.begin(); x != redirect_automation.end(); ++x) {
1760                 if ((*x)->redirect == r) {
1761                         break;
1762                 }
1763         }
1764
1765         if (x == redirect_automation.end()) {
1766
1767                 rai = new RedirectAutomationInfo (r);
1768                 redirect_automation.push_back (rai);
1769
1770         } else {
1771
1772                 rai = *x;
1773
1774         }
1775
1776         /* any older menu was deleted at the top of redirects_changed()
1777            when we cleared the subplugin menu.
1778         */
1779
1780         rai->menu = manage (new Menu);
1781         MenuList& items = rai->menu->items();
1782         rai->menu->set_name ("ArdourContextMenu");
1783
1784         items.clear ();
1785
1786         for (std::set<uint32_t>::const_iterator i = automatable.begin(); i != automatable.end(); ++i) {
1787
1788                 RedirectAutomationNode* ran;
1789                 CheckMenuItem* mitem;
1790
1791                 string name = r->describe_parameter (*i);
1792
1793                 items.push_back (CheckMenuElem (name));
1794                 mitem = dynamic_cast<CheckMenuItem*> (&items.back());
1795
1796                 if (has_visible_automation.find((*i)) != has_visible_automation.end()) {
1797                         mitem->set_active(true);
1798                 }
1799
1800                 if ((ran = find_redirect_automation_node (r, *i)) == 0) {
1801
1802                         /* new item */
1803
1804                         ran = new RedirectAutomationNode (*i, mitem, *this);
1805
1806                         rai->lines.push_back (ran);
1807
1808                 } else {
1809
1810                         ran->menu_item = mitem;
1811
1812                 }
1813
1814                 mitem->signal_toggled().connect (bind (mem_fun(*this, &RouteTimeAxisView::redirect_menu_item_toggled), rai, ran));
1815         }
1816
1817         /* add the menu for this redirect, because the subplugin
1818            menu is always cleared at the top of redirects_changed().
1819            this is the result of some poor design in gtkmm and/or
1820            GTK+.
1821         */
1822
1823         subplugin_menu.items().push_back (MenuElem (r->name(), *rai->menu));
1824         rai->valid = true;
1825 }
1826
1827 void
1828 RouteTimeAxisView::redirect_menu_item_toggled (RouteTimeAxisView::RedirectAutomationInfo* rai,
1829                                                RouteTimeAxisView::RedirectAutomationNode* ran)
1830 {
1831         bool showit = ran->menu_item->get_active();
1832         bool redraw = false;
1833
1834         if (ran->view == 0 && showit) {
1835                 add_redirect_automation_curve (rai->redirect, ran->what);
1836                 redraw = true;
1837         }
1838
1839         if (showit != ran->view->marked_for_display()) {
1840
1841                 if (showit) {
1842                         ran->view->set_marked_for_display (true);
1843                         ran->view->canvas_display->show();
1844                         ran->view->canvas_background->show();
1845                 } else {
1846                         rai->redirect->mark_automation_visible (ran->what, true);
1847                         ran->view->set_marked_for_display (false);
1848                         ran->view->hide ();
1849                 }
1850
1851                 redraw = true;
1852
1853         }
1854
1855         if (redraw && !no_redraw) {
1856
1857                 /* now trigger a redisplay */
1858
1859                  _route->gui_changed ("visible_tracks", (void *) 0); /* EMIT_SIGNAL */
1860
1861         }
1862 }
1863
1864 void
1865 RouteTimeAxisView::redirects_changed (void *src)
1866 {
1867         using namespace Menu_Helpers;
1868
1869         for (list<RedirectAutomationInfo*>::iterator i = redirect_automation.begin(); i != redirect_automation.end(); ++i) {
1870                 (*i)->valid = false;
1871         }
1872
1873         subplugin_menu.items().clear ();
1874
1875         _route->foreach_redirect (this, &RouteTimeAxisView::add_redirect_to_subplugin_menu);
1876         _route->foreach_redirect (this, &RouteTimeAxisView::add_existing_redirect_automation_curves);
1877
1878         for (list<RedirectAutomationInfo*>::iterator i = redirect_automation.begin(); i != redirect_automation.end(); ) {
1879
1880                 list<RedirectAutomationInfo*>::iterator tmp;
1881
1882                 tmp = i;
1883                 ++tmp;
1884
1885                 if (!(*i)->valid) {
1886
1887                         delete *i;
1888                         redirect_automation.erase (i);
1889
1890                 }
1891
1892                 i = tmp;
1893         }
1894
1895         /* change in visibility was possible */
1896
1897         _route->gui_changed ("visible_tracks", this);
1898 }
1899
1900 RedirectAutomationLine *
1901 RouteTimeAxisView::find_redirect_automation_curve (boost::shared_ptr<Redirect> redirect, uint32_t what)
1902 {
1903         RedirectAutomationNode* ran;
1904
1905         if ((ran = find_redirect_automation_node (redirect, what)) != 0) {
1906                 if (ran->view) {
1907                         return dynamic_cast<RedirectAutomationLine*> (ran->view->lines.front());
1908                 }
1909         }
1910
1911         return 0;
1912 }
1913
1914 void
1915 RouteTimeAxisView::reset_redirect_automation_curves ()
1916 {
1917         for (vector<RedirectAutomationLine*>::iterator i = redirect_automation_curves.begin(); i != redirect_automation_curves.end(); ++i) {
1918                 (*i)->reset();
1919         }
1920 }
1921
1922 void
1923 RouteTimeAxisView::update_rec_display ()
1924 {
1925         RouteUI::update_rec_display ();
1926         name_entry.set_sensitive (!_route->record_enabled());
1927 }
1928
1929 void
1930 RouteTimeAxisView::fast_update ()
1931 {
1932         gm.get_level_meter().update_meters ();
1933 }
1934
1935 void
1936 RouteTimeAxisView::hide_meter ()
1937 {
1938         clear_meter ();
1939         gm.get_level_meter().hide_meters ();
1940 }
1941
1942 void
1943 RouteTimeAxisView::show_meter ()
1944 {
1945         reset_meter ();
1946 }
1947
1948 void
1949 RouteTimeAxisView::reset_meter ()
1950 {
1951         if (Config->get_show_track_meters()) {
1952                 gm.get_level_meter().setup_meters (height-5);
1953         } else {
1954                 hide_meter ();
1955         }
1956 }
1957
1958 void
1959 RouteTimeAxisView::clear_meter ()
1960 {
1961         gm.get_level_meter().clear_meters ();
1962 }
1963
1964 void
1965 RouteTimeAxisView::meter_changed (void *src)
1966 {
1967         ENSURE_GUI_THREAD (bind (mem_fun(*this, &RouteTimeAxisView::meter_changed), src));
1968         reset_meter();
1969 }
1970
1971 void
1972 RouteTimeAxisView::io_changed (IOChange change, void *src)
1973 {
1974         reset_meter ();
1975 }
1976