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