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