?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fixes for OS X compile of last commit
[ardour2.git] / gtk2_ardour / editor_ops.cc
blobc3464033b38bbe59fb5b8f25e604bedc4516698d
1 /*
2 Copyright (C) 2000-2004 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
20 #include <unistd.h>
21
22 #include <cstdlib>
23 #include <cmath>
24 #include <string>
25 #include <map>
26 #include <set>
27
28 #include <pbd/error.h>
29 #include <pbd/basename.h>
30 #include <pbd/pthread_utils.h>
31 #include <pbd/memento_command.h>
32 #include <pbd/whitespace.h>
33
34 #include <gtkmm2ext/utils.h>
35 #include <gtkmm2ext/choice.h>
36 #include <gtkmm2ext/popup.h>
37
38 #include <ardour/audioengine.h>
39 #include <ardour/session.h>
40 #include <ardour/audioplaylist.h>
41 #include <ardour/audioregion.h>
42 #include <ardour/audio_diskstream.h>
43 #include <ardour/utils.h>
44 #include <ardour/location.h>
45 #include <ardour/named_selection.h>
46 #include <ardour/audio_track.h>
47 #include <ardour/audiofilesource.h>
48 #include <ardour/audioplaylist.h>
49 #include <ardour/region_factory.h>
50 #include <ardour/playlist_factory.h>
51 #include <ardour/reverse.h>
52 #include <ardour/transient_detector.h>
53 #include <ardour/dB.h>
54
55 #include "ardour_ui.h"
56 #include "editor.h"
57 #include "time_axis_view.h"
58 #include "route_time_axis.h"
59 #include "audio_time_axis.h"
60 #include "automation_time_axis.h"
61 #include "streamview.h"
62 #include "audio_streamview.h"
63 #include "audio_region_view.h"
64 #include "rgb_macros.h"
65 #include "selection_templates.h"
66 #include "selection.h"
67 #include "editing.h"
68 #include "gtk-custom-hruler.h"
69 #include "gui_thread.h"
70 #include "keyboard.h"
71 #include "utils.h"
72
73 #include "i18n.h"
74
75 using namespace std;
76 using namespace ARDOUR;
77 using namespace PBD;
78 using namespace sigc;
79 using namespace Gtk;
80 using namespace Gtkmm2ext;
81 using namespace Editing;
82
83 /***********************************************************************
84 Editor operations
85 ***********************************************************************/
86
87 void
88 Editor::undo (uint32_t n)
89 {
90 if (session) {
91 session->undo (n);
92 }
93 }
94
95 void
96 Editor::redo (uint32_t n)
97 {
98 if (session) {
99 session->redo (n);
100 }
101 }
102
103 void
104 Editor::split_region ()
105 {
106 split_region_at (get_preferred_edit_position());
107 }
108
109 void
110 Editor::split_region_at (nframes64_t where)
111 {
112 RegionSelection rs;
113
114 get_regions_for_action (rs);
115 split_regions_at (where, selection->regions);
116 }
117
118 void
119 Editor::split_regions_at (nframes64_t where, RegionSelection& regions)
120 {
121 if (regions.empty()) {
122 return;
123 }
124
125 begin_reversible_command (_("split"));
126
127 // if splitting a single region, and snap-to is using
128 // region boundaries, don't pay attention to them
129
130 if (regions.size() == 1) {
131 switch (snap_type) {
132 case SnapToRegionStart:
133 case SnapToRegionSync:
134 case SnapToRegionEnd:
135 break;
136 default:
137 snap_to (where);
138 }
139 } else {
140 snap_to (where);
141 }
142
143 for (RegionSelection::iterator a = regions.begin(); a != regions.end(); ) {
144
145 RegionSelection::iterator tmp;
146
147 /* XXX this test needs to be more complicated, to make sure we really
148 have something to split.
149 */
150
151 if (!(*a)->region()->covers (where)) {
152 ++a;
153 continue;
154 }
155
156 tmp = a;
157 ++tmp;
158
159 boost::shared_ptr<Playlist> pl = (*a)->region()->playlist();
160
161 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*a);
162
163 if (arv) {
164 _new_regionviews_show_envelope = arv->envelope_visible();
165 }
166
167 if (pl) {
168 XMLNode &before = pl->get_state();
169 pl->split_region ((*a)->region(), where);
170 XMLNode &after = pl->get_state();
171 session->add_command(new MementoCommand<Playlist>(*pl, &before, &after));
172 }
173
174 a = tmp;
175 }
176
177 commit_reversible_command ();
178 _new_regionviews_show_envelope = false;
179 }
180
181 void
182 Editor::remove_clicked_region ()
183 {
184 if (clicked_audio_trackview == 0 || clicked_regionview == 0) {
185 return;
186 }
187
188 boost::shared_ptr<Playlist> playlist = clicked_audio_trackview->playlist();
189
190 begin_reversible_command (_("remove region"));
191 XMLNode &before = playlist->get_state();
192 playlist->remove_region (clicked_regionview->region());
193 XMLNode &after = playlist->get_state();
194 session->add_command(new MementoCommand<Playlist>(*playlist, &before, &after));
195 commit_reversible_command ();
196 }
197
198 void
199 Editor::remove_region ()
200 {
201
202 RegionSelection rs;
203 get_regions_for_action (rs);
204
205 if (!session) {
206 return;
207 }
208
209 if (rs.empty()) {
210 return;
211 }
212
213 begin_reversible_command (_("remove region"));
214
215 list<boost::shared_ptr<Region> > regions_to_remove;
216
217 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
218 // we can't just remove the region(s) in this loop because
219 // this removes them from the RegionSelection, and they thus
220 // disappear from underneath the iterator, and the ++i above
221 // SEGVs in a puzzling fashion.
222
223 // so, first iterate over the regions to be removed from rs and
224 // add them to the regions_to_remove list, and then
225 // iterate over the list to actually remove them.
226
227 regions_to_remove.push_back ((*i)->region());
228 }
229
230 for (list<boost::shared_ptr<Region> >::iterator rl = regions_to_remove.begin(); rl != regions_to_remove.end(); ++rl) {
231 boost::shared_ptr<Playlist> playlist = (*rl)->playlist();
232 if (!playlist) {
233 // is this check necessary?
234 continue;
235 }
236
237 XMLNode &before = playlist->get_state();
238 playlist->remove_region (*rl);
239 XMLNode &after = playlist->get_state();
240 session->add_command(new MementoCommand<Playlist>(*playlist, &before, &after));
241 }
242 commit_reversible_command ();
243 }
244
245 boost::shared_ptr<Region>
246 Editor::select_region_for_operation (int dir, TimeAxisView **tv)
247 {
248 RegionView* rv;
249 boost::shared_ptr<Region> region;
250 nframes64_t start = 0;
251
252 if (selection->time.start () == selection->time.end_frame ()) {
253
254 /* no current selection-> is there a selected regionview? */
255
256 if (selection->regions.empty()) {
257 return region;
258 }
259
260 }
261
262 if (!selection->regions.empty()) {
263
264 rv = *(selection->regions.begin());
265 (*tv) = &rv->get_time_axis_view();
266 region = rv->region();
267
268 } else if (!selection->tracks.empty()) {
269
270 (*tv) = selection->tracks.front();
271
272 RouteTimeAxisView* rtv;
273
274 if ((rtv = dynamic_cast<RouteTimeAxisView*> (*tv)) != 0) {
275 boost::shared_ptr<Playlist> pl;
276
277 if ((pl = rtv->playlist()) == 0) {
278 return region;
279 }
280
281 region = pl->top_region_at (start);
282 }
283 }
284
285 return region;
286 }
287
288 void
289 Editor::extend_selection_to_end_of_region (bool next)
290 {
291 TimeAxisView *tv;
292 boost::shared_ptr<Region> region;
293 nframes64_t start;
294
295 if ((region = select_region_for_operation (next ? 1 : 0, &tv)) == 0) {
296 return;
297 }
298
299 if (region && selection->time.start () == selection->time.end_frame ()) {
300 start = region->position();
301 } else {
302 start = selection->time.start ();
303 }
304
305 /* Try to leave the selection with the same route if possible */
306
307 if ((tv = selection->time.track) == 0) {
308 return;
309 }
310
311 begin_reversible_command (_("extend selection"));
312 selection->set (tv, start, region->position() + region->length());
313 commit_reversible_command ();
314 }
315
316 void
317 Editor::extend_selection_to_start_of_region (bool previous)
318 {
319 TimeAxisView *tv;
320 boost::shared_ptr<Region> region;
321 nframes64_t end;
322
323 if ((region = select_region_for_operation (previous ? -1 : 0, &tv)) == 0) {
324 return;
325 }
326
327 if (region && selection->time.start () == selection->time.end_frame ()) {
328 end = region->position() + region->length();
329 } else {
330 end = selection->time.end_frame ();
331 }
332
333 /* Try to leave the selection with the same route if possible */
334
335 if ((tv = selection->time.track) == 0) {
336 return;
337 }
338
339 begin_reversible_command (_("extend selection"));
340 selection->set (tv, region->position(), end);
341 commit_reversible_command ();
342 }
343
344 bool
345 Editor::nudge_forward_release (GdkEventButton* ev)
346 {
347 if (ev->state & Keyboard::PrimaryModifier) {
348 nudge_forward (false, true);
349 } else {
350 nudge_forward (false, false);
351 }
352 return false;
353 }
354
355 bool
356 Editor::nudge_backward_release (GdkEventButton* ev)
357 {
358 if (ev->state & Keyboard::PrimaryModifier) {
359 nudge_backward (false, true);
360 } else {
361 nudge_backward (false, false);
362 }
363 return false;
364 }
365
366
367 void
368 Editor::nudge_forward (bool next, bool force_playhead)
369 {
370 nframes64_t distance;
371 nframes64_t next_distance;
372 RegionSelection rs;
373
374 get_regions_for_action (rs);
375
376 if (!session) return;
377
378 if (!force_playhead && !rs.empty()) {
379
380 begin_reversible_command (_("nudge regions forward"));
381
382 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
383 boost::shared_ptr<Region> r ((*i)->region());
384
385 distance = get_nudge_distance (r->position(), next_distance);
386
387 if (next) {
388 distance = next_distance;
389 }
390
391 XMLNode &before = r->playlist()->get_state();
392 r->set_position (r->position() + distance, this);
393 XMLNode &after = r->playlist()->get_state();
394 session->add_command (new MementoCommand<Playlist>(*(r->playlist()), &before, &after));
395 }
396
397 commit_reversible_command ();
398
399
400 } else if (!force_playhead && !selection->markers.empty()) {
401
402 bool is_start;
403
404 begin_reversible_command (_("nudge location forward"));
405
406 for (MarkerSelection::iterator i = selection->markers.begin(); i != selection->markers.end(); ++i) {
407
408 Location* loc = find_location_from_marker ((*i), is_start);
409
410 if (loc) {
411
412 XMLNode& before (loc->get_state());
413
414 if (is_start) {
415 distance = get_nudge_distance (loc->start(), next_distance);
416 if (next) {
417 distance = next_distance;
418 }
419 if (max_frames - distance > loc->start() + loc->length()) {
420 loc->set_start (loc->start() + distance);
421 } else {
422 loc->set_start (max_frames - loc->length());
423 }
424 } else {
425 distance = get_nudge_distance (loc->end(), next_distance);
426 if (next) {
427 distance = next_distance;
428 }
429 if (max_frames - distance > loc->end()) {
430 loc->set_end (loc->end() + distance);
431 } else {
432 loc->set_end (max_frames);
433 }
434 }
435 XMLNode& after (loc->get_state());
436 session->add_command (new MementoCommand<Location>(*loc, &before, &after));
437 }
438 }
439
440 commit_reversible_command ();
441
442 } else {
443 distance = get_nudge_distance (playhead_cursor->current_frame, next_distance);
444 session->request_locate (playhead_cursor->current_frame + distance);
445 }
446 }
447
448 void
449 Editor::nudge_backward (bool next, bool force_playhead)
450 {
451 nframes64_t distance;
452 nframes64_t next_distance;
453 RegionSelection rs;
454
455 get_regions_for_action (rs);
456
457 if (!session) return;
458
459 if (!force_playhead && !rs.empty()) {
460
461 begin_reversible_command (_("nudge regions backward"));
462
463 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
464 boost::shared_ptr<Region> r ((*i)->region());
465
466 distance = get_nudge_distance (r->position(), next_distance);
467
468 if (next) {
469 distance = next_distance;
470 }
471
472 XMLNode &before = r->playlist()->get_state();
473
474 if (r->position() > distance) {
475 r->set_position (r->position() - distance, this);
476 } else {
477 r->set_position (0, this);
478 }
479 XMLNode &after = r->playlist()->get_state();
480 session->add_command(new MementoCommand<Playlist>(*(r->playlist()), &before, &after));
481 }
482
483 commit_reversible_command ();
484
485 } else if (!force_playhead && !selection->markers.empty()) {
486
487 bool is_start;
488
489 begin_reversible_command (_("nudge location forward"));
490
491 for (MarkerSelection::iterator i = selection->markers.begin(); i != selection->markers.end(); ++i) {
492
493 Location* loc = find_location_from_marker ((*i), is_start);
494
495 if (loc) {
496
497 XMLNode& before (loc->get_state());
498
499 if (is_start) {
500 distance = get_nudge_distance (loc->start(), next_distance);
501 if (next) {
502 distance = next_distance;
503 }
504 if (distance < loc->start()) {
505 loc->set_start (loc->start() - distance);
506 } else {
507 loc->set_start (0);
508 }
509 } else {
510 distance = get_nudge_distance (loc->end(), next_distance);
511
512 if (next) {
513 distance = next_distance;
514 }
515
516 if (distance < loc->end() - loc->length()) {
517 loc->set_end (loc->end() - distance);
518 } else {
519 loc->set_end (loc->length());
520 }
521 }
522
523 XMLNode& after (loc->get_state());
524 session->add_command (new MementoCommand<Location>(*loc, &before, &after));
525 }
526 }
527
528 commit_reversible_command ();
529
530 } else {
531
532 distance = get_nudge_distance (playhead_cursor->current_frame, next_distance);
533
534 if (playhead_cursor->current_frame > distance) {
535 session->request_locate (playhead_cursor->current_frame - distance);
536 } else {
537 session->goto_start();
538 }
539 }
540 }
541
542 void
543 Editor::nudge_forward_capture_offset ()
544 {
545 nframes64_t distance;
546 RegionSelection rs;
547
548 get_regions_for_action (rs);
549
550 if (!session) return;
551
552 if (!rs.empty()) {
553
554 begin_reversible_command (_("nudge forward"));
555
556 distance = session->worst_output_latency();
557
558 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
559 boost::shared_ptr<Region> r ((*i)->region());
560
561 XMLNode &before = r->playlist()->get_state();
562 r->set_position (r->position() + distance, this);
563 XMLNode &after = r->playlist()->get_state();
564 session->add_command(new MementoCommand<Playlist>(*(r->playlist()), &before, &after));
565 }
566
567 commit_reversible_command ();
568
569 }
570 }
571
572 void
573 Editor::nudge_backward_capture_offset ()
574 {
575 nframes64_t distance;
576 RegionSelection rs;
577
578 get_regions_for_action (rs);
579
580 if (!session) return;
581
582 if (!rs.empty()) {
583
584 begin_reversible_command (_("nudge forward"));
585
586 distance = session->worst_output_latency();
587
588 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
589 boost::shared_ptr<Region> r ((*i)->region());
590
591 XMLNode &before = r->playlist()->get_state();
592
593 if (r->position() > distance) {
594 r->set_position (r->position() - distance, this);
595 } else {
596 r->set_position (0, this);
597 }
598 XMLNode &after = r->playlist()->get_state();
599 session->add_command(new MementoCommand<Playlist>(*(r->playlist()), &before, &after));
600 }
601
602 commit_reversible_command ();
603 }
604 }
605
606 /* DISPLAY MOTION */
607
608 void
609 Editor::move_to_start ()
610 {
611 session->goto_start ();
612 }
613
614 void
615 Editor::move_to_end ()
616 {
617
618 session->request_locate (session->current_end_frame());
619 }
620
621 void
622 Editor::build_region_boundary_cache ()
623 {
624 nframes64_t pos = 0;
625 vector<RegionPoint> interesting_points;
626 boost::shared_ptr<Region> r;
627 TrackViewList tracks;
628 bool at_end = false;
629
630 region_boundary_cache.clear ();
631
632 if (session == 0) {
633 return;
634 }
635
636 switch (snap_type) {
637 case SnapToRegionStart:
638 interesting_points.push_back (Start);
639 break;
640 case SnapToRegionEnd:
641 interesting_points.push_back (End);
642 break;
643 case SnapToRegionSync:
644 interesting_points.push_back (SyncPoint);
645 break;
646 case SnapToRegionBoundary:
647 interesting_points.push_back (Start);
648 interesting_points.push_back (End);
649 break;
650 default:
651 fatal << string_compose (_("build_region_boundary_cache called with snap_type = %1"), snap_type) << endmsg;
652 /*NOTREACHED*/
653 return;
654 }
655
656 TimeAxisView *ontrack = 0;
657 TrackViewList tlist;
658
659 if (!selection->tracks.empty()) {
660 tlist = selection->tracks;
661 } else {
662 tlist = track_views;
663 }
664
665 while (pos < session->current_end_frame() && !at_end) {
666
667 nframes64_t rpos;
668 nframes64_t lpos = max_frames;
669
670 for (vector<RegionPoint>::iterator p = interesting_points.begin(); p != interesting_points.end(); ++p) {
671
672 if ((r = find_next_region (pos, *p, 1, tlist, &ontrack)) == 0) {
673 if (*p == interesting_points.back()) {
674 at_end = true;
675 }
676 /* move to next point type */
677 continue;
678 }
679
680 switch (*p) {
681 case Start:
682 rpos = r->first_frame();
683 break;
684
685 case End:
686 rpos = r->last_frame();
687 break;
688
689 case SyncPoint:
690 rpos = r->sync_position ();
691 //r->adjust_to_sync (r->first_frame());
692 break;
693
694 default:
695 break;
696 }
697
698 float speed = 1.0f;
699 AudioTimeAxisView *atav;
700
701 if (ontrack != 0 && (atav = dynamic_cast<AudioTimeAxisView*>(ontrack)) != 0 ) {
702 if (atav->get_diskstream() != 0) {
703 speed = atav->get_diskstream()->speed();
704 }
705 }
706
707 rpos = track_frame_to_session_frame (rpos, speed);
708
709 if (rpos < lpos) {
710 lpos = rpos;
711 }
712
713 /* prevent duplicates, but we don't use set<> because we want to be able
714 to sort later.
715 */
716
717 vector<nframes64_t>::iterator ri;
718
719 for (ri = region_boundary_cache.begin(); ri != region_boundary_cache.end(); ++ri) {
720 if (*ri == rpos) {
721 break;
722 }
723 }
724
725 if (ri == region_boundary_cache.end()) {
726 region_boundary_cache.push_back (rpos);
727 }
728 }
729
730 pos = lpos + 1;
731 }
732
733 /* finally sort to be sure that the order is correct */
734
735 sort (region_boundary_cache.begin(), region_boundary_cache.end());
736 }
737
738 boost::shared_ptr<Region>
739 Editor::find_next_region (nframes64_t frame, RegionPoint point, int32_t dir, TrackViewList& tracks, TimeAxisView **ontrack)
740 {
741 TrackViewList::iterator i;
742 nframes64_t closest = max_frames;
743 boost::shared_ptr<Region> ret;
744 nframes64_t rpos = 0;
745
746 float track_speed;
747 nframes64_t track_frame;
748 AudioTimeAxisView *atav;
749
750 for (i = tracks.begin(); i != tracks.end(); ++i) {
751
752 nframes64_t distance;
753 boost::shared_ptr<Region> r;
754
755 track_speed = 1.0f;
756 if ( (atav = dynamic_cast<AudioTimeAxisView*>(*i)) != 0 ) {
757 if (atav->get_diskstream()!=0)
758 track_speed = atav->get_diskstream()->speed();
759 }
760
761 track_frame = session_frame_to_track_frame(frame, track_speed);
762
763 if ((r = (*i)->find_next_region (track_frame, point, dir)) == 0) {
764 continue;
765 }
766
767 switch (point) {
768 case Start:
769 rpos = r->first_frame ();
770 break;
771
772 case End:
773 rpos = r->last_frame ();
774 break;
775
776 case SyncPoint:
777 rpos = r->sync_position ();
778 // r->adjust_to_sync (r->first_frame());
779 break;
780 }
781
782 // rpos is a "track frame", converting it to "session frame"
783 rpos = track_frame_to_session_frame(rpos, track_speed);
784
785 if (rpos > frame) {
786 distance = rpos - frame;
787 } else {
788 distance = frame - rpos;
789 }
790
791 if (distance < closest) {
792 closest = distance;
793 if (ontrack != 0)
794 *ontrack = (*i);
795 ret = r;
796 }
797 }
798
799 return ret;
800 }
801
802 nframes64_t
803 Editor::find_next_region_boundary (nframes64_t pos, int32_t dir, const TrackViewList& tracks)
804 {
805 nframes64_t distance = max_frames;
806 nframes64_t current_nearest = -1;
807
808
809 for (TrackViewList::const_iterator i = tracks.begin(); i != tracks.end(); ++i) {
810 nframes64_t contender;
811 nframes64_t d;
812
813 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*i);
814
815 if (!rtv) {
816 continue;
817 }
818
819 if ((contender = rtv->find_next_region_boundary (pos, dir)) < 0) {
820 continue;
821 }
822
823 d = ::llabs (pos - contender);
824
825 if (d < distance) {
826 current_nearest = contender;
827 distance = d;
828 }
829 }
830
831 return current_nearest;
832 }
833
834 nframes64_t
835 Editor::get_region_boundary (nframes64_t pos, int32_t dir, bool with_selection, bool only_onscreen)
836 {
837 nframes64_t target;
838 TrackViewList tvl;
839
840 if (with_selection && Config->get_region_boundaries_from_selected_tracks()) {
841
842 if (!selection->tracks.empty()) {
843
844 target = find_next_region_boundary (pos, dir, selection->tracks);
845
846 } else {
847
848 if (only_onscreen || Config->get_region_boundaries_from_onscreen_tracks()) {
849 get_onscreen_tracks (tvl);
850 target = find_next_region_boundary (pos, dir, tvl);
851 } else {
852 target = find_next_region_boundary (pos, dir, track_views);
853 }
854 }
855
856 } else {
857
858 if (only_onscreen || Config->get_region_boundaries_from_onscreen_tracks()) {
859 get_onscreen_tracks (tvl);
860 target = find_next_region_boundary (pos, dir, tvl);
861 } else {
862 target = find_next_region_boundary (pos, dir, track_views);
863 }
864 }
865
866 return target;
867 }
868
869 void
870 Editor::cursor_to_region_boundary (bool with_selection, int32_t dir)
871 {
872 nframes64_t pos = playhead_cursor->current_frame;
873 nframes64_t target;
874
875 if (!session) {
876 return;
877 }
878
879 // so we don't find the current region again..
880 if (dir > 0 || pos > 0) {
881 pos += dir;
882 }
883
884 if ((target = get_region_boundary (pos, dir, with_selection, false)) < 0) {
885 return;
886 }
887
888
889 session->request_locate (target);
890 }
891
892 void
893 Editor::cursor_to_next_region_boundary (bool with_selection)
894 {
895 cursor_to_region_boundary (with_selection, 1);
896 }
897
898 void
899 Editor::cursor_to_previous_region_boundary (bool with_selection)
900 {
901 cursor_to_region_boundary (with_selection, -1);
902 }
903
904 void
905 Editor::cursor_to_region_point (Cursor* cursor, RegionPoint point, int32_t dir)
906 {
907 boost::shared_ptr<Region> r;
908 nframes64_t pos = cursor->current_frame;
909
910 if (!session) {
911 return;
912 }
913
914 TimeAxisView *ontrack = 0;
915
916 // so we don't find the current region again..
917 if (dir>0 || pos>0)
918 pos+=dir;
919
920 if (!selection->tracks.empty()) {
921
922 r = find_next_region (pos, point, dir, selection->tracks, &ontrack);
923
924 } else if (clicked_trackview) {
925
926 TrackViewList t;
927 t.push_back (clicked_trackview);
928
929 r = find_next_region (pos, point, dir, t, &ontrack);
930
931 } else {
932
933 r = find_next_region (pos, point, dir, track_views, &ontrack);
934 }
935
936 if (r == 0) {
937 return;
938 }
939
940 switch (point){
941 case Start:
942 pos = r->first_frame ();
943 break;
944
945 case End:
946 pos = r->last_frame ();
947 break;
948
949 case SyncPoint:
950 pos = r->sync_position ();
951 // r->adjust_to_sync (r->first_frame());
952 break;
953 }
954
955 float speed = 1.0f;
956 AudioTimeAxisView *atav;
957
958 if ( ontrack != 0 && (atav = dynamic_cast<AudioTimeAxisView*>(ontrack)) != 0 ) {
959 if (atav->get_diskstream() != 0) {
960 speed = atav->get_diskstream()->speed();
961 }
962 }
963
964 pos = track_frame_to_session_frame(pos, speed);
965
966 if (cursor == playhead_cursor) {
967 session->request_locate (pos);
968 } else {
969 cursor->set_position (pos);
970 }
971 }
972
973 void
974 Editor::cursor_to_next_region_point (Cursor* cursor, RegionPoint point)
975 {
976 cursor_to_region_point (cursor, point, 1);
977 }
978
979 void
980 Editor::cursor_to_previous_region_point (Cursor* cursor, RegionPoint point)
981 {
982 cursor_to_region_point (cursor, point, -1);
983 }
984
985 void
986 Editor::cursor_to_selection_start (Cursor *cursor)
987 {
988 nframes64_t pos = 0;
989 RegionSelection rs;
990
991 get_regions_for_action (rs);
992
993 switch (mouse_mode) {
994 case MouseObject:
995 if (!rs.empty()) {
996 pos = rs.start();
997 }
998 break;
999
1000 case MouseRange:
1001 if (!selection->time.empty()) {
1002 pos = selection->time.start ();
1003 }
1004 break;
1005
1006 default:
1007 return;
1008 }
1009
1010 if (cursor == playhead_cursor) {
1011 session->request_locate (pos);
1012 } else {
1013 cursor->set_position (pos);
1014 }
1015 }
1016
1017 void
1018 Editor::cursor_to_selection_end (Cursor *cursor)
1019 {
1020 nframes64_t pos = 0;
1021 RegionSelection rs;
1022
1023 get_regions_for_action (rs);
1024
1025 switch (mouse_mode) {
1026 case MouseObject:
1027 if (!rs.empty()) {
1028 pos = rs.end_frame();
1029 }
1030 break;
1031
1032 case MouseRange:
1033 if (!selection->time.empty()) {
1034 pos = selection->time.end_frame ();
1035 }
1036 break;
1037
1038 default:
1039 return;
1040 }
1041
1042 if (cursor == playhead_cursor) {
1043 session->request_locate (pos);
1044 } else {
1045 cursor->set_position (pos);
1046 }
1047 }
1048
1049 void
1050 Editor::selected_marker_to_region_boundary (bool with_selection, int32_t dir)
1051 {
1052 nframes64_t target;
1053 Location* loc;
1054 bool ignored;
1055
1056 if (!session) {
1057 return;
1058 }
1059
1060 if (selection->markers.empty()) {
1061 nframes64_t mouse;
1062 bool ignored;
1063
1064 if (!mouse_frame (mouse, ignored)) {
1065 return;
1066 }
1067
1068 add_location_mark (mouse);
1069 }
1070
1071 if ((loc = find_location_from_marker (selection->markers.front(), ignored)) == 0) {
1072 return;
1073 }
1074
1075 nframes64_t pos = loc->start();
1076
1077 // so we don't find the current region again..
1078 if (dir > 0 || pos > 0) {
1079 pos += dir;
1080 }
1081
1082 if ((target = get_region_boundary (pos, dir, with_selection, false)) < 0) {
1083 return;
1084 }
1085
1086 loc->move_to (target);
1087 }
1088
1089 void
1090 Editor::selected_marker_to_next_region_boundary (bool with_selection)
1091 {
1092 selected_marker_to_region_boundary (with_selection, 1);
1093 }
1094
1095 void
1096 Editor::selected_marker_to_previous_region_boundary (bool with_selection)
1097 {
1098 selected_marker_to_region_boundary (with_selection, -1);
1099 }
1100
1101 void
1102 Editor::selected_marker_to_region_point (RegionPoint point, int32_t dir)
1103 {
1104 boost::shared_ptr<Region> r;
1105 nframes64_t pos;
1106 Location* loc;
1107 bool ignored;
1108
1109 if (!session || selection->markers.empty()) {
1110 return;
1111 }
1112
1113 if ((loc = find_location_from_marker (selection->markers.front(), ignored)) == 0) {
1114 return;
1115 }
1116
1117 TimeAxisView *ontrack = 0;
1118
1119 pos = loc->start();
1120
1121 // so we don't find the current region again..
1122 if (dir>0 || pos>0)
1123 pos+=dir;
1124
1125 if (!selection->tracks.empty()) {
1126
1127 r = find_next_region (pos, point, dir, selection->tracks, &ontrack);
1128
1129 } else if (clicked_trackview) {
1130
1131 TrackViewList t;
1132 t.push_back (clicked_trackview);
1133
1134 r = find_next_region (pos, point, dir, t, &ontrack);
1135
1136 } else {
1137
1138 r = find_next_region (pos, point, dir, track_views, &ontrack);
1139 }
1140
1141 if (r == 0) {
1142 return;
1143 }
1144
1145 switch (point){
1146 case Start:
1147 pos = r->first_frame ();
1148 break;
1149
1150 case End:
1151 pos = r->last_frame ();
1152 break;
1153
1154 case SyncPoint:
1155 pos = r->adjust_to_sync (r->first_frame());
1156 break;
1157 }
1158
1159 float speed = 1.0f;
1160 AudioTimeAxisView *atav;
1161
1162 if ( ontrack != 0 && (atav = dynamic_cast<AudioTimeAxisView*>(ontrack)) != 0 ) {
1163 if (atav->get_diskstream() != 0) {
1164 speed = atav->get_diskstream()->speed();
1165 }
1166 }
1167
1168 pos = track_frame_to_session_frame(pos, speed);
1169
1170 loc->move_to (pos);
1171 }
1172
1173 void
1174 Editor::selected_marker_to_next_region_point (RegionPoint point)
1175 {
1176 selected_marker_to_region_point (point, 1);
1177 }
1178
1179 void
1180 Editor::selected_marker_to_previous_region_point (RegionPoint point)
1181 {
1182 selected_marker_to_region_point (point, -1);
1183 }
1184
1185 void
1186 Editor::selected_marker_to_selection_start ()
1187 {
1188 nframes64_t pos = 0;
1189 Location* loc;
1190 bool ignored;
1191
1192 if (!session || selection->markers.empty()) {
1193 return;
1194 }
1195
1196 if ((loc = find_location_from_marker (selection->markers.front(), ignored)) == 0) {
1197 return;
1198 }
1199
1200 RegionSelection rs;
1201
1202 get_regions_for_action (rs);
1203
1204 switch (mouse_mode) {
1205 case MouseObject:
1206 if (!rs.empty()) {
1207 pos = rs.start();
1208 }
1209 break;
1210
1211 case MouseRange:
1212 if (!selection->time.empty()) {
1213 pos = selection->time.start ();
1214 }
1215 break;
1216
1217 default:
1218 return;
1219 }
1220
1221 loc->move_to (pos);
1222 }
1223
1224 void
1225 Editor::selected_marker_to_selection_end ()
1226 {
1227 nframes64_t pos = 0;
1228 Location* loc;
1229 bool ignored;
1230
1231 if (!session || selection->markers.empty()) {
1232 return;
1233 }
1234
1235 if ((loc = find_location_from_marker (selection->markers.front(), ignored)) == 0) {
1236 return;
1237 }
1238
1239 RegionSelection rs;
1240
1241 get_regions_for_action (rs);
1242
1243 switch (mouse_mode) {
1244 case MouseObject:
1245 if (!rs.empty()) {
1246 pos = rs.end_frame();
1247 }
1248 break;
1249
1250 case MouseRange:
1251 if (!selection->time.empty()) {
1252 pos = selection->time.end_frame ();
1253 }
1254 break;
1255
1256 default:
1257 return;
1258 }
1259
1260 loc->move_to (pos);
1261 }
1262
1263 void
1264 Editor::scroll_playhead (bool forward)
1265 {
1266 nframes64_t pos = playhead_cursor->current_frame;
1267 nframes64_t delta = (nframes64_t) floor (current_page_frames() / 0.8);
1268
1269 if (forward) {
1270 if (pos == max_frames) {
1271 return;
1272 }
1273
1274 if (pos < max_frames - delta) {
1275 pos += delta ;
1276 } else {
1277 pos = max_frames;
1278 }
1279
1280 } else {
1281
1282 if (pos == 0) {
1283 return;
1284 }
1285
1286 if (pos > delta) {
1287 pos -= delta;
1288 } else {
1289 pos = 0;
1290 }
1291 }
1292
1293 session->request_locate (pos);
1294 }
1295
1296 void
1297 Editor::playhead_backward ()
1298 {
1299 nframes64_t pos;
1300 nframes64_t cnt;
1301 float prefix;
1302 bool was_floating;
1303
1304 if (get_prefix (prefix, was_floating)) {
1305 cnt = 1;
1306 } else {
1307 if (was_floating) {
1308 cnt = (nframes64_t) floor (prefix * session->frame_rate ());
1309 } else {
1310 cnt = (nframes64_t) prefix;
1311 }
1312 }
1313
1314 pos = playhead_cursor->current_frame;
1315
1316 if ((nframes64_t) pos < cnt) {
1317 pos = 0;
1318 } else {
1319 pos -= cnt;
1320 }
1321
1322 /* XXX this is completely insane. with the current buffering
1323 design, we'll force a complete track buffer flush and
1324 reload, just to move 1 sample !!!
1325 */
1326
1327 session->request_locate (pos);
1328 }
1329
1330 void
1331 Editor::playhead_forward ()
1332 {
1333 nframes64_t pos;
1334 nframes64_t cnt;
1335 bool was_floating;
1336 float prefix;
1337
1338 if (get_prefix (prefix, was_floating)) {
1339 cnt = 1;
1340 } else {
1341 if (was_floating) {
1342 cnt = (nframes64_t) floor (prefix * session->frame_rate ());
1343 } else {
1344 cnt = (nframes64_t) floor (prefix);
1345 }
1346 }
1347
1348 pos = playhead_cursor->current_frame;
1349
1350 /* XXX this is completely insane. with the current buffering
1351 design, we'll force a complete track buffer flush and
1352 reload, just to move 1 sample !!!
1353 */
1354
1355 session->request_locate (pos+cnt);
1356 }
1357
1358 void
1359 Editor::cursor_align (bool playhead_to_edit)
1360 {
1361 if (!session) {
1362 return;
1363 }
1364
1365 if (playhead_to_edit) {
1366
1367 if (selection->markers.empty()) {
1368 return;
1369 }
1370
1371 session->request_locate (selection->markers.front()->position(), session->transport_rolling());
1372
1373 } else {
1374
1375 /* move selected markers to playhead */
1376
1377 for (MarkerSelection::iterator i = selection->markers.begin(); i != selection->markers.end(); ++i) {
1378 bool ignored;
1379
1380 Location* loc = find_location_from_marker (*i, ignored);
1381
1382 if (loc->is_mark()) {
1383 loc->set_start (playhead_cursor->current_frame);
1384 } else {
1385 loc->set (playhead_cursor->current_frame,
1386 playhead_cursor->current_frame + loc->length());
1387 }
1388 }
1389 }
1390 }
1391
1392 void
1393 Editor::edit_cursor_backward ()
1394 {
1395 nframes64_t pos;
1396 nframes64_t cnt;
1397 float prefix;
1398 bool was_floating;
1399
1400 if (get_prefix (prefix, was_floating)) {
1401 cnt = 1;
1402 } else {
1403 if (was_floating) {
1404 cnt = (nframes64_t) floor (prefix * session->frame_rate ());
1405 } else {
1406 cnt = (nframes64_t) prefix;
1407 }
1408 }
1409
1410 if ((pos = get_preferred_edit_position()) < 0) {
1411 return;
1412 }
1413
1414 if (pos < cnt) {
1415 pos = 0;
1416 } else {
1417 pos -= cnt;
1418 }
1419
1420 // EDIT CURSOR edit_cursor->set_position (pos);
1421 }
1422
1423 void
1424 Editor::edit_cursor_forward ()
1425 {
1426 //nframes64_t pos;
1427 nframes64_t cnt;
1428 bool was_floating;
1429 float prefix;
1430
1431 if (get_prefix (prefix, was_floating)) {
1432 cnt = 1;
1433 } else {
1434 if (was_floating) {
1435 cnt = (nframes64_t) floor (prefix * session->frame_rate ());
1436 } else {
1437 cnt = (nframes64_t) floor (prefix);
1438 }
1439 }
1440
1441 // pos = edit_cursor->current_frame;
1442 // EDIT CURSOR edit_cursor->set_position (pos+cnt);
1443 }
1444
1445 void
1446 Editor::goto_frame ()
1447 {
1448 float prefix;
1449 bool was_floating;
1450 nframes64_t frame;
1451
1452 if (get_prefix (prefix, was_floating)) {
1453 return;
1454 }
1455
1456 if (was_floating) {
1457 frame = (nframes64_t) floor (prefix * session->frame_rate());
1458 } else {
1459 frame = (nframes64_t) floor (prefix);
1460 }
1461
1462 session->request_locate (frame);
1463 }
1464
1465 void
1466 Editor::scroll_backward (float pages)
1467 {
1468 nframes64_t frame;
1469 nframes64_t one_page = (nframes64_t) rint (canvas_width * frames_per_unit);
1470 bool was_floating;
1471 float prefix;
1472 nframes64_t cnt;
1473
1474 if (get_prefix (prefix, was_floating)) {
1475 cnt = (nframes64_t) floor (pages * one_page);
1476 } else {
1477 if (was_floating) {
1478 cnt = (nframes64_t) floor (prefix * session->frame_rate());
1479 } else {
1480 cnt = (nframes64_t) floor (prefix * one_page);
1481 }
1482 }
1483
1484 if (leftmost_frame < cnt) {
1485 frame = 0;
1486 } else {
1487 frame = leftmost_frame - cnt;
1488 }
1489
1490 reset_x_origin (frame);
1491 }
1492
1493 void
1494 Editor::scroll_forward (float pages)
1495 {
1496 nframes64_t frame;
1497 nframes64_t one_page = (nframes64_t) rint (canvas_width * frames_per_unit);
1498 bool was_floating;
1499 float prefix;
1500 nframes64_t cnt;
1501
1502 if (get_prefix (prefix, was_floating)) {
1503 cnt = (nframes64_t) floor (pages * one_page);
1504 } else {
1505 if (was_floating) {
1506 cnt = (nframes64_t) floor (prefix * session->frame_rate());
1507 } else {
1508 cnt = (nframes64_t) floor (prefix * one_page);
1509 }
1510 }
1511
1512 if (max_frames - cnt < leftmost_frame) {
1513 frame = max_frames - cnt;
1514 } else {
1515 frame = leftmost_frame + cnt;
1516 }
1517
1518 reset_x_origin (frame);
1519 }
1520
1521 void
1522 Editor::scroll_tracks_down ()
1523 {
1524 float prefix;
1525 bool was_floating;
1526 int cnt;
1527
1528 if (get_prefix (prefix, was_floating)) {
1529 cnt = 1;
1530 } else {
1531 cnt = (int) floor (prefix);
1532 }
1533
1534 double vert_value = vertical_adjustment.get_value() + (cnt *
1535 vertical_adjustment.get_page_size());
1536 if (vert_value > vertical_adjustment.get_upper() - canvas_height) {
1537 vert_value = vertical_adjustment.get_upper() - canvas_height;
1538 }
1539 vertical_adjustment.set_value (vert_value);
1540 }
1541
1542 void
1543 Editor::scroll_tracks_up ()
1544 {
1545 float prefix;
1546 bool was_floating;
1547 int cnt;
1548
1549 if (get_prefix (prefix, was_floating)) {
1550 cnt = 1;
1551 } else {
1552 cnt = (int) floor (prefix);
1553 }
1554
1555 vertical_adjustment.set_value (vertical_adjustment.get_value() - (cnt * vertical_adjustment.get_page_size()));
1556 }
1557
1558 void
1559 Editor::scroll_tracks_down_line ()
1560 {
1561
1562 Gtk::Adjustment* adj = edit_vscrollbar.get_adjustment();
1563 double vert_value = adj->get_value() + 60;
1564
1565 if (vert_value>adj->get_upper() - canvas_height) {
1566 vert_value = adj->get_upper() - canvas_height;
1567 }
1568 adj->set_value (vert_value);
1569 }
1570
1571 void
1572 Editor::scroll_tracks_up_line ()
1573 {
1574 Gtk::Adjustment* adj = edit_vscrollbar.get_adjustment();
1575 adj->set_value (adj->get_value() - 60);
1576 }
1577
1578 /* ZOOM */
1579
1580 void
1581 Editor::temporal_zoom_step (bool coarser)
1582 {
1583 ENSURE_GUI_THREAD (bind (mem_fun (*this, &Editor::temporal_zoom_step), coarser));
1584
1585 double nfpu;
1586
1587 nfpu = frames_per_unit;
1588
1589 if (coarser) {
1590 nfpu *= 1.61803399;
1591 } else {
1592 nfpu = max(1.0,(nfpu/1.61803399));
1593 }
1594
1595 temporal_zoom (nfpu);
1596 }
1597
1598 void
1599 Editor::temporal_zoom (gdouble fpu)
1600 {
1601 if (!session) return;
1602
1603 nframes64_t current_page = current_page_frames();
1604 nframes64_t current_leftmost = leftmost_frame;
1605 nframes64_t current_rightmost;
1606 nframes64_t current_center;
1607 nframes64_t new_page_size;
1608 nframes64_t half_page_size;
1609 nframes64_t leftmost_after_zoom = 0;
1610 nframes64_t where;
1611 bool in_track_canvas;
1612 double nfpu;
1613 double l;
1614
1615 /* XXX this limit is also in ::set_frames_per_unit() */
1616
1617 if (frames_per_unit < 1.0 && fpu <= frames_per_unit) {
1618 return;
1619 }
1620
1621 nfpu = fpu;
1622
1623 new_page_size = (nframes64_t) floor (canvas_width * nfpu);
1624 half_page_size = new_page_size / 2;
1625
1626 switch (zoom_focus) {
1627 case ZoomFocusLeft:
1628 leftmost_after_zoom = current_leftmost;
1629 break;
1630
1631 case ZoomFocusRight:
1632 current_rightmost = leftmost_frame + current_page;
1633 if (current_rightmost < new_page_size) {
1634 leftmost_after_zoom = 0;
1635 } else {
1636 leftmost_after_zoom = current_rightmost - new_page_size;
1637 }
1638 break;
1639
1640 case ZoomFocusCenter:
1641 current_center = current_leftmost + (current_page/2);
1642 if (current_center < half_page_size) {
1643 leftmost_after_zoom = 0;
1644 } else {
1645 leftmost_after_zoom = current_center - half_page_size;
1646 }
1647 break;
1648
1649 case ZoomFocusPlayhead:
1650 /* try to keep the playhead in the same place */
1651
1652 where = playhead_cursor->current_frame;
1653
1654 l = - ((new_page_size * ((where - current_leftmost)/(double)current_page)) - where);
1655
1656 if (l < 0) {
1657 leftmost_after_zoom = 0;
1658 } else if (l > max_frames) {
1659 leftmost_after_zoom = max_frames - new_page_size;
1660 } else {
1661 leftmost_after_zoom = (nframes64_t) l;
1662 }
1663 break;
1664
1665 case ZoomFocusMouse:
1666 /* try to keep the mouse over the same point in the display */
1667
1668 if (!mouse_frame (where, in_track_canvas)) {
1669 /* use playhead instead */
1670 where = playhead_cursor->current_frame;
1671
1672 if (where < half_page_size) {
1673 leftmost_after_zoom = 0;
1674 } else {
1675 leftmost_after_zoom = where - half_page_size;
1676 }
1677
1678 } else {
1679
1680 l = - ((new_page_size * ((where - current_leftmost)/(double)current_page)) - where);
1681
1682 if (l < 0) {
1683 leftmost_after_zoom = 0;
1684 } else if (l > max_frames) {
1685 leftmost_after_zoom = max_frames - new_page_size;
1686 } else {
1687 leftmost_after_zoom = (nframes64_t) l;
1688 }
1689 }
1690
1691 break;
1692
1693 case ZoomFocusEdit:
1694 /* try to keep the edit point in the same place */
1695 where = get_preferred_edit_position ();
1696
1697 if (where > 0) {
1698
1699 double l = - ((new_page_size * ((where - current_leftmost)/(double)current_page)) - where);
1700
1701 if (l < 0) {
1702 leftmost_after_zoom = 0;
1703 } else if (l > max_frames) {
1704 leftmost_after_zoom = max_frames - new_page_size;
1705 } else {
1706 leftmost_after_zoom = (nframes64_t) l;
1707 }
1708
1709 } else {
1710 /* edit point not defined */
1711 return;
1712 }
1713 break;
1714
1715 }
1716
1717 // leftmost_after_zoom = min (leftmost_after_zoom, session->current_end_frame());
1718
1719 reposition_and_zoom (leftmost_after_zoom, nfpu);
1720 }
1721
1722 void
1723 Editor::temporal_zoom_region (bool both_axes)
1724 {
1725
1726 nframes64_t start = max_frames;
1727 nframes64_t end = 0;
1728 RegionSelection rs;
1729 set<TimeAxisView*> tracks;
1730
1731 get_regions_for_action (rs);
1732
1733 if (rs.empty()) {
1734 return;
1735 }
1736
1737 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
1738
1739 if ((*i)->region()->position() < start) {
1740 start = (*i)->region()->position();
1741 }
1742
1743 if ((*i)->region()->last_frame() + 1 > end) {
1744 end = (*i)->region()->last_frame() + 1;
1745 }
1746
1747 tracks.insert (&((*i)->get_time_axis_view()));
1748 }
1749
1750 /* now comes an "interesting" hack ... make sure we leave a little space
1751 at each end of the editor so that the zoom doesn't fit the region
1752 precisely to the screen.
1753 */
1754
1755 GdkScreen* screen = gdk_screen_get_default ();
1756 gint pixwidth = gdk_screen_get_width (screen);
1757 gint mmwidth = gdk_screen_get_width_mm (screen);
1758 double pix_per_mm = (double) pixwidth/ (double) mmwidth;
1759 double one_centimeter_in_pixels = pix_per_mm * 10.0;
1760
1761 if ((start == 0 && end == 0) || end < start) {
1762 return;
1763 }
1764
1765 nframes64_t range = end - start;
1766 double new_fpu = (double)range / (double)canvas_width;
1767 nframes64_t extra_samples = (nframes64_t) floor (one_centimeter_in_pixels * new_fpu);
1768
1769 if (start > extra_samples) {
1770 start -= extra_samples;
1771 } else {
1772 start = 0;
1773 }
1774
1775 if (max_frames - extra_samples > end) {
1776 end += extra_samples;
1777 } else {
1778 end = max_frames;
1779 }
1780
1781 if (both_axes) {
1782 /* save visual state with track states included, and prevent
1783 set_frames_per_unit() from doing it again.
1784 */
1785 undo_visual_stack.push_back (current_visual_state(true));
1786 no_save_visual = true;
1787 }
1788
1789 temporal_zoom_by_frame (start, end, "zoom to region");
1790
1791 if (both_axes) {
1792 uint32_t per_track_height = (uint32_t) floor ((canvas_height - canvas_timebars_vsize - 10.0) / tracks.size());
1793
1794 /* set visible track heights appropriately */
1795
1796 for (set<TimeAxisView*>::iterator t = tracks.begin(); t != tracks.end(); ++t) {
1797 (*t)->set_height (per_track_height);
1798 }
1799
1800 /* hide irrelevant tracks */
1801
1802 no_route_list_redisplay = true;
1803
1804 for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
1805 if (find (tracks.begin(), tracks.end(), (*i)) == tracks.end()) {
1806 hide_track_in_display (**i, true);
1807 }
1808 }
1809
1810 no_route_list_redisplay = false;
1811 redisplay_route_list ();
1812
1813 vertical_adjustment.set_value (0);
1814 no_save_visual = false;
1815 }
1816
1817 redo_visual_stack.push_back (current_visual_state());
1818 }
1819
1820 void
1821 Editor::toggle_zoom_region (bool both_axes)
1822 {
1823 temporal_zoom_region (both_axes);
1824 }
1825
1826 void
1827 Editor::temporal_zoom_selection ()
1828 {
1829 if (!selection) return;
1830
1831 if (selection->time.empty()) {
1832 return;
1833 }
1834
1835 nframes64_t start = selection->time[clicked_selection].start;
1836 nframes64_t end = selection->time[clicked_selection].end;
1837
1838 temporal_zoom_by_frame (start, end, "zoom to selection");
1839 }
1840
1841 void
1842 Editor::temporal_zoom_session ()
1843 {
1844 ENSURE_GUI_THREAD (mem_fun (*this, &Editor::temporal_zoom_session));
1845
1846 if (session) {
1847 temporal_zoom_by_frame (session->current_start_frame(), session->current_end_frame(), "zoom to session");
1848 }
1849 }
1850
1851 void
1852 Editor::temporal_zoom_by_frame (nframes64_t start, nframes64_t end, const string & op)
1853 {
1854 if (!session) return;
1855
1856 if ((start == 0 && end == 0) || end < start) {
1857 return;
1858 }
1859
1860 nframes64_t range = end - start;
1861
1862 double new_fpu = (double)range / (double)canvas_width;
1863
1864 nframes64_t new_page = (nframes64_t) floor (canvas_width * new_fpu);
1865 nframes64_t middle = (nframes64_t) floor( (double)start + ((double)range / 2.0f ));
1866 nframes64_t new_leftmost = (nframes64_t) floor( (double)middle - ((double)new_page/2.0f));
1867
1868 if (new_leftmost > middle) {
1869 new_leftmost = 0;
1870 }
1871
1872 reposition_and_zoom (new_leftmost, new_fpu);
1873 }
1874
1875 void
1876 Editor::temporal_zoom_to_frame (bool coarser, nframes64_t frame)
1877 {
1878 if (!session) {
1879 return;
1880 }
1881 double range_before = frame - leftmost_frame;
1882 double new_fpu;
1883
1884 new_fpu = frames_per_unit;
1885
1886 if (coarser) {
1887 new_fpu *= 1.61803399;
1888 range_before *= 1.61803399;
1889 } else {
1890 new_fpu = max(1.0,(new_fpu/1.61803399));
1891 range_before /= 1.61803399;
1892 }
1893
1894 if (new_fpu == frames_per_unit) {
1895 return;
1896 }
1897
1898 nframes64_t new_leftmost = frame - (nframes64_t)range_before;
1899
1900 if (new_leftmost > frame) {
1901 new_leftmost = 0;
1902 }
1903 // begin_reversible_command (_("zoom to frame"));
1904 // session->add_undo (bind (mem_fun(*this, &Editor::reposition_and_zoom), leftmost_frame, frames_per_unit));
1905 // session->add_redo (bind (mem_fun(*this, &Editor::reposition_and_zoom), new_leftmost, new_fpu));
1906 // commit_reversible_command ();
1907
1908 reposition_and_zoom (new_leftmost, new_fpu);
1909 }
1910
1911
1912 bool
1913 Editor::choose_new_marker_name(string &name) {
1914
1915 if (!Config->get_name_new_markers()) {
1916 /* don't prompt user for a new name */
1917 return true;
1918 }
1919
1920 ArdourPrompter dialog (true);
1921
1922 dialog.set_prompt (_("New Name:"));
1923
1924 dialog.set_title (_("New Location Marker"));
1925
1926 dialog.set_name ("MarkNameWindow");
1927 dialog.set_size_request (250, -1);
1928 dialog.set_position (Gtk::WIN_POS_MOUSE);
1929
1930 dialog.add_button (Stock::OK, RESPONSE_ACCEPT);
1931 dialog.set_initial_text (name);
1932
1933 dialog.show ();
1934
1935 switch (dialog.run ()) {
1936 case RESPONSE_ACCEPT:
1937 break;
1938 default:
1939 return false;
1940 }
1941
1942 dialog.get_result(name);
1943 return true;
1944
1945 }
1946
1947
1948 void
1949 Editor::add_location_from_selection ()
1950 {
1951 string rangename;
1952
1953 if (selection->time.empty()) {
1954 return;
1955 }
1956
1957 if (session == 0 || clicked_trackview == 0) {
1958 return;
1959 }
1960
1961 nframes64_t start = selection->time[clicked_selection].start;
1962 nframes64_t end = selection->time[clicked_selection].end;
1963
1964 session->locations()->next_available_name(rangename,"selection");
1965 Location *location = new Location (start, end, rangename, Location::IsRangeMarker);
1966
1967 session->begin_reversible_command (_("add marker"));
1968 XMLNode &before = session->locations()->get_state();
1969 session->locations()->add (location, true);
1970 XMLNode &after = session->locations()->get_state();
1971 session->add_command(new MementoCommand<Locations>(*(session->locations()), &before, &after));
1972 session->commit_reversible_command ();
1973 }
1974
1975 void
1976 Editor::add_location_mark (nframes64_t where)
1977 {
1978 string markername;
1979
1980 select_new_marker = true;
1981
1982 session->locations()->next_available_name(markername,"mark");
1983 if (!choose_new_marker_name(markername)) {
1984 return;
1985 }
1986 Location *location = new Location (where, where, markername, Location::IsMark);
1987 session->begin_reversible_command (_("add marker"));
1988 XMLNode &before = session->locations()->get_state();
1989 session->locations()->add (location, true);
1990 XMLNode &after = session->locations()->get_state();
1991 session->add_command(new MementoCommand<Locations>(*(session->locations()), &before, &after));
1992 session->commit_reversible_command ();
1993 }
1994
1995 void
1996 Editor::add_location_from_playhead_cursor ()
1997 {
1998 add_location_mark (session->audible_frame());
1999 }
2000
2001 void
2002 Editor::add_locations_from_audio_region ()
2003 {
2004 RegionSelection rs;
2005
2006 get_regions_for_action (rs);
2007
2008 if (rs.empty()) {
2009 return;
2010 }
2011
2012 session->begin_reversible_command (rs.size () > 1 ? _("add markers") : _("add marker"));
2013 XMLNode &before = session->locations()->get_state();
2014
2015 cerr << "Add locations\n";
2016
2017 for (RegionSelection::iterator i = rs.begin (); i != rs.end (); ++i) {
2018
2019 boost::shared_ptr<Region> region = (*i)->region ();
2020
2021 Location *location = new Location (region->position(), region->last_frame(), region->name(), Location::IsRangeMarker);
2022
2023 session->locations()->add (location, true);
2024 }
2025
2026 XMLNode &after = session->locations()->get_state();
2027 session->add_command (new MementoCommand<Locations>(*(session->locations()), &before, &after));
2028 session->commit_reversible_command ();
2029 }
2030
2031 void
2032 Editor::add_location_from_audio_region ()
2033 {
2034 RegionSelection rs;
2035
2036 get_regions_for_action (rs);
2037
2038 if (rs.empty()) {
2039 return;
2040 }
2041
2042 session->begin_reversible_command (_("add marker"));
2043 XMLNode &before = session->locations()->get_state();
2044
2045 string markername;
2046
2047 if (rs.size() > 1) { // more than one region selected
2048 session->locations()->next_available_name(markername, "regions");
2049 } else {
2050 RegionView* rv = *(rs.begin());
2051 boost::shared_ptr<Region> region = rv->region();
2052 markername = region->name();
2053 }
2054
2055 if (!choose_new_marker_name(markername)) {
2056 return;
2057 }
2058
2059 cerr << "Add location\n";
2060
2061 // single range spanning all selected
2062 Location *location = new Location (rs.start(), rs.end_frame(), markername, Location::IsRangeMarker);
2063 session->locations()->add (location, true);
2064
2065 XMLNode &after = session->locations()->get_state();
2066 session->add_command (new MementoCommand<Locations>(*(session->locations()), &before, &after));
2067 session->commit_reversible_command ();
2068 }
2069
2070 void
2071 Editor::amplitude_zoom_step (bool in)
2072 {
2073 gdouble zoom = 1.0;
2074
2075 if (in) {
2076 zoom *= 2.0;
2077 } else {
2078 if (zoom > 2.0) {
2079 zoom /= 2.0;
2080 } else {
2081 zoom = 1.0;
2082 }
2083 }
2084
2085 #ifdef FIX_FOR_CANVAS
2086 /* XXX DO SOMETHING */
2087 #endif
2088 }
2089
2090
2091 /* DELETION */
2092
2093
2094 void
2095 Editor::delete_sample_forward ()
2096 {
2097 }
2098
2099 void
2100 Editor::delete_sample_backward ()
2101 {
2102 }
2103
2104 void
2105 Editor::delete_screen ()
2106 {
2107 }
2108
2109 /* SEARCH */
2110
2111 void
2112 Editor::search_backwards ()
2113 {
2114 /* what ? */
2115 }
2116
2117 void
2118 Editor::search_forwards ()
2119 {
2120 /* what ? */
2121 }
2122
2123 /* MARKS */
2124
2125 void
2126 Editor::jump_forward_to_mark ()
2127 {
2128 if (!session) {
2129 return;
2130 }
2131
2132 Location *location = session->locations()->first_location_after (playhead_cursor->current_frame);
2133
2134 if (location) {
2135 session->request_locate (location->start(), session->transport_rolling());
2136 } else {
2137 session->request_locate (session->current_end_frame());
2138 }
2139 }
2140
2141 void
2142 Editor::jump_backward_to_mark ()
2143 {
2144 if (!session) {
2145 return;
2146 }
2147
2148 Location *location = session->locations()->first_location_before (playhead_cursor->current_frame);
2149
2150 if (location) {
2151 session->request_locate (location->start(), session->transport_rolling());
2152 } else {
2153 session->goto_start ();
2154 }
2155 }
2156
2157 void
2158 Editor::set_mark ()
2159 {
2160 nframes64_t pos;
2161 float prefix;
2162 bool was_floating;
2163 string markername;
2164
2165 if (get_prefix (prefix, was_floating)) {
2166 pos = session->audible_frame ();
2167 } else {
2168 if (was_floating) {
2169 pos = (nframes64_t) floor (prefix * session->frame_rate ());
2170 } else {
2171 pos = (nframes64_t) floor (prefix);
2172 }
2173 }
2174
2175 session->locations()->next_available_name(markername,"mark");
2176 if (!choose_new_marker_name(markername)) {
2177 return;
2178 }
2179 session->locations()->add (new Location (pos, 0, markername, Location::IsMark), true);
2180 }
2181
2182 void
2183 Editor::clear_markers ()
2184 {
2185 if (session) {
2186 session->begin_reversible_command (_("clear markers"));
2187 XMLNode &before = session->locations()->get_state();
2188 session->locations()->clear_markers ();
2189 XMLNode &after = session->locations()->get_state();
2190 session->add_command(new MementoCommand<Locations>(*(session->locations()), &before, &after));
2191 session->commit_reversible_command ();
2192 }
2193 }
2194
2195 void
2196 Editor::clear_ranges ()
2197 {
2198 if (session) {
2199 session->begin_reversible_command (_("clear ranges"));
2200 XMLNode &before = session->locations()->get_state();
2201
2202 Location * looploc = session->locations()->auto_loop_location();
2203 Location * punchloc = session->locations()->auto_punch_location();
2204
2205 session->locations()->clear_ranges ();
2206 // re-add these
2207 if (looploc) session->locations()->add (looploc);
2208 if (punchloc) session->locations()->add (punchloc);
2209
2210 XMLNode &after = session->locations()->get_state();
2211 session->add_command(new MementoCommand<Locations>(*(session->locations()), &before, &after));
2212 session->commit_reversible_command ();
2213 }
2214 }
2215
2216 void
2217 Editor::clear_locations ()
2218 {
2219 session->begin_reversible_command (_("clear locations"));
2220 XMLNode &before = session->locations()->get_state();
2221 session->locations()->clear ();
2222 XMLNode &after = session->locations()->get_state();
2223 session->add_command(new MementoCommand<Locations>(*(session->locations()), &before, &after));
2224 session->commit_reversible_command ();
2225 session->locations()->clear ();
2226 }
2227
2228 void
2229 Editor::unhide_markers ()
2230 {
2231 for (LocationMarkerMap::iterator i = location_markers.begin(); i != location_markers.end(); ++i) {
2232 Location *l = (*i).first;
2233 if (l->is_hidden() && l->is_mark()) {
2234 l->set_hidden(false, this);
2235 }
2236 }
2237 }
2238
2239 void
2240 Editor::unhide_ranges ()
2241 {
2242 for (LocationMarkerMap::iterator i = location_markers.begin(); i != location_markers.end(); ++i) {
2243 Location *l = (*i).first;
2244 if (l->is_hidden() && l->is_range_marker()) {
2245 l->set_hidden(false, this);
2246 }
2247 }
2248 }
2249
2250 /* INSERT/REPLACE */
2251
2252 void
2253 Editor::insert_region_list_drag (boost::shared_ptr<AudioRegion> region, int x, int y)
2254 {
2255 double wx, wy;
2256 double cx, cy;
2257 TimeAxisView *tv;
2258 nframes64_t where;
2259 AudioTimeAxisView *atv = 0;
2260 boost::shared_ptr<Playlist> playlist;
2261
2262 track_canvas->window_to_world (x, y, wx, wy);
2263 //wx += horizontal_adjustment.get_value();
2264 //wy += vertical_adjustment.get_value();
2265
2266 GdkEvent event;
2267 event.type = GDK_BUTTON_RELEASE;
2268 event.button.x = wx;
2269 event.button.y = wy;
2270
2271 where = event_frame (&event, &cx, &cy);
2272
2273 if (where < leftmost_frame || where > leftmost_frame + current_page_frames()) {
2274 /* clearly outside canvas area */
2275 return;
2276 }
2277
2278 if ((tv = trackview_by_y_position (cy)) == 0) {
2279 return;
2280 }
2281
2282 if ((atv = dynamic_cast<AudioTimeAxisView*>(tv)) == 0) {
2283 return;
2284 }
2285
2286 if ((playlist = atv->playlist()) == 0) {
2287 return;
2288 }
2289
2290 snap_to (where);
2291
2292 begin_reversible_command (_("insert dragged region"));
2293 XMLNode &before = playlist->get_state();
2294 playlist->add_region (RegionFactory::create (region), where, 1.0);
2295 session->add_command(new MementoCommand<Playlist>(*playlist, &before, &playlist->get_state()));
2296 commit_reversible_command ();
2297 }
2298
2299 void
2300 Editor::insert_region_list_selection (float times)
2301 {
2302 RouteTimeAxisView *tv = 0;
2303 boost::shared_ptr<Playlist> playlist;
2304
2305 if (clicked_audio_trackview != 0) {
2306 tv = clicked_audio_trackview;
2307 } else if (!selection->tracks.empty()) {
2308 if ((tv = dynamic_cast<RouteTimeAxisView*>(selection->tracks.front())) == 0) {
2309 return;
2310 }
2311 } else if (entered_track != 0) {
2312 if ((tv = dynamic_cast<RouteTimeAxisView*>(entered_track)) == 0) {
2313 return;
2314 }
2315 } else {
2316 return;
2317 }
2318
2319 if ((playlist = tv->playlist()) == 0) {
2320 return;
2321 }
2322
2323 Glib::RefPtr<TreeSelection> selected = region_list_display.get_selection();
2324
2325 if (selected->count_selected_rows() != 1) {
2326 return;
2327 }
2328
2329 TreeView::Selection::ListHandle_Path rows = selected->get_selected_rows ();
2330
2331 /* only one row selected, so rows.begin() is it */
2332
2333 TreeIter iter;
2334
2335 if ((iter = region_list_model->get_iter (*rows.begin()))) {
2336
2337 boost::shared_ptr<Region> region = (*iter)[region_list_columns.region];
2338
2339 begin_reversible_command (_("insert region"));
2340 XMLNode &before = playlist->get_state();
2341 playlist->add_region ((RegionFactory::create (region)), get_preferred_edit_position(), times);
2342 session->add_command(new MementoCommand<Playlist>(*playlist, &before, &playlist->get_state()));
2343 commit_reversible_command ();
2344 }
2345 }
2346
2347 /* BUILT-IN EFFECTS */
2348
2349 void
2350 Editor::reverse_selection ()
2351 {
2352
2353 }
2354
2355 /* GAIN ENVELOPE EDITING */
2356
2357 void
2358 Editor::edit_envelope ()
2359 {
2360 }
2361
2362 /* PLAYBACK */
2363
2364 void
2365 Editor::transition_to_rolling (bool fwd)
2366 {
2367 if (!session) {
2368 return;
2369 }
2370
2371 switch (Config->get_slave_source()) {
2372 case None:
2373 case JACK:
2374 break;
2375 default:
2376 /* transport controlled by the master */
2377 return;
2378 }
2379
2380 if (session->is_auditioning()) {
2381 session->cancel_audition ();
2382 return;
2383 }
2384
2385 session->request_transport_speed (fwd ? 1.0f : -1.0f);
2386 }
2387
2388 void
2389 Editor::play_from_start ()
2390 {
2391 session->request_locate (session->current_start_frame(), true);
2392 }
2393
2394 void
2395 Editor::play_from_edit_point ()
2396 {
2397 session->request_locate (get_preferred_edit_position(), true);
2398 }
2399
2400 void
2401 Editor::play_from_edit_point_and_return ()
2402 {
2403 nframes64_t start_frame;
2404 nframes64_t return_frame;
2405
2406 start_frame = get_preferred_edit_position (true);
2407
2408 if (session->transport_rolling()) {
2409 session->request_locate (start_frame, false);
2410 return;
2411 }
2412
2413 /* don't reset the return frame if its already set */
2414
2415 if ((return_frame = session->requested_return_frame()) < 0) {
2416 return_frame = session->audible_frame();
2417 }
2418
2419 if (start_frame >= 0) {
2420 session->request_roll_at_and_return (start_frame, return_frame);
2421 }
2422 }
2423
2424 void
2425 Editor::play_selection ()
2426 {
2427 if (selection->time.empty()) {
2428 return;
2429 }
2430
2431 session->request_play_range (&selection->time, true);
2432 }
2433
2434 void
2435 Editor::loop_selected_region ()
2436 {
2437 RegionSelection rs;
2438
2439 get_regions_for_action (rs);
2440
2441 if (!rs.empty()) {
2442 RegionView *rv = *(rs.begin());
2443 Location* tll;
2444
2445 if ((tll = transport_loop_location()) != 0) {
2446
2447 tll->set (rv->region()->position(), rv->region()->last_frame());
2448
2449 // enable looping, reposition and start rolling
2450
2451 session->request_play_loop (true);
2452 session->request_locate (tll->start(), false);
2453 session->request_transport_speed (1.0f);
2454 }
2455 }
2456 }
2457
2458 void
2459 Editor::play_location (Location& location)
2460 {
2461 if (location.start() <= location.end()) {
2462 return;
2463 }
2464
2465 session->request_bounded_roll (location.start(), location.end());
2466 }
2467
2468 void
2469 Editor::loop_location (Location& location)
2470 {
2471 if (location.start() <= location.end()) {
2472 return;
2473 }
2474
2475 Location* tll;
2476
2477 if ((tll = transport_loop_location()) != 0) {
2478 tll->set (location.start(), location.end());
2479
2480 // enable looping, reposition and start rolling
2481 session->request_play_loop (true);
2482 session->request_locate (tll->start(), true);
2483 }
2484 }
2485
2486 void
2487 Editor::raise_region ()
2488 {
2489 selection->foreach_region (&Region::raise);
2490 }
2491
2492 void
2493 Editor::raise_region_to_top ()
2494 {
2495 selection->foreach_region (&Region::raise_to_top);
2496 }
2497
2498 void
2499 Editor::lower_region ()
2500 {
2501 selection->foreach_region (&Region::lower);
2502 }
2503
2504 void
2505 Editor::lower_region_to_bottom ()
2506 {
2507 selection->foreach_region (&Region::lower_to_bottom);
2508 }
2509
2510 void
2511 Editor::edit_region ()
2512 {
2513 if (clicked_regionview == 0) {
2514 return;
2515 }
2516
2517 clicked_regionview->show_region_editor ();
2518 }
2519
2520 void
2521 Editor::rename_region()
2522 {
2523 RegionSelection rs;
2524
2525 get_regions_for_action (rs);
2526
2527 if (rs.empty()) {
2528 return;
2529 }
2530
2531 ArdourDialog d (*this, _("Rename Region"), true, false);
2532 Entry entry;
2533 Label label (_("New name:"));
2534 HBox hbox;
2535
2536 hbox.set_spacing (6);
2537 hbox.pack_start (label, false, false);
2538 hbox.pack_start (entry, true, true);
2539
2540 d.get_vbox()->set_border_width (12);
2541 d.get_vbox()->pack_start (hbox, false, false);
2542
2543 d.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
2544 d.add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);
2545
2546 d.set_size_request (300, -1);
2547 d.set_position (Gtk::WIN_POS_MOUSE);
2548
2549 entry.set_text (rs.front()->region()->name());
2550 entry.select_region (0, -1);
2551
2552 entry.signal_activate().connect (bind (mem_fun (d, &Dialog::response), RESPONSE_OK));
2553
2554 d.show_all ();
2555
2556 entry.grab_focus();
2557
2558 int ret = d.run();
2559
2560 d.hide ();
2561
2562 if (ret == RESPONSE_OK) {
2563 std::string str = entry.get_text();
2564 strip_whitespace_edges (str);
2565 if (!str.empty()) {
2566 rs.front()->region()->set_name (str);
2567 redisplay_regions ();
2568 }
2569 }
2570 }
2571
2572 void
2573 Editor::audition_playlist_region_via_route (boost::shared_ptr<Region> region, Route& route)
2574 {
2575 if (session->is_auditioning()) {
2576 session->cancel_audition ();
2577 }
2578
2579 // note: some potential for creativity here, because region doesn't
2580 // have to belong to the playlist that Route is handling
2581
2582 // bool was_soloed = route.soloed();
2583
2584 route.set_solo (true, this);
2585
2586 session->request_bounded_roll (region->position(), region->position() + region->length());
2587
2588 /* XXX how to unset the solo state ? */
2589 }
2590
2591 void
2592 Editor::play_edit_range ()
2593 {
2594 nframes64_t start, end;
2595
2596 if (get_edit_op_range (start, end)) {
2597 session->request_bounded_roll (start, end);
2598 }
2599 }
2600
2601 void
2602 Editor::play_selected_region ()
2603 {
2604 nframes64_t start = max_frames;
2605 nframes64_t end = 0;
2606 RegionSelection rs;
2607
2608 get_regions_for_action (rs);
2609
2610 if (rs.empty()) {
2611 return;
2612 }
2613
2614 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
2615 if ((*i)->region()->position() < start) {
2616 start = (*i)->region()->position();
2617 }
2618 if ((*i)->region()->last_frame() + 1 > end) {
2619 end = (*i)->region()->last_frame() + 1;
2620 }
2621 }
2622
2623 session->request_bounded_roll (start, end);
2624 }
2625
2626 void
2627 Editor::audition_playlist_region_standalone (boost::shared_ptr<Region> region)
2628 {
2629 session->audition_region (region);
2630 }
2631
2632 void
2633 Editor::build_interthread_progress_window ()
2634 {
2635 interthread_progress_window = new ArdourDialog (X_("interthread progress"), true);
2636
2637 interthread_progress_bar.set_orientation (Gtk::PROGRESS_LEFT_TO_RIGHT);
2638
2639 interthread_progress_window->set_border_width (12);
2640 interthread_progress_window->get_vbox()->set_spacing (6);
2641
2642 interthread_progress_label.set_alignment (0.5, 0.5);
2643
2644 interthread_progress_window->get_vbox()->pack_start (interthread_progress_label, false, false);
2645 interthread_progress_window->get_vbox()->pack_start (interthread_progress_bar,false, false);
2646
2647 // GTK2FIX: this button needs a modifiable label
2648
2649 Button* b = interthread_progress_window->add_button (Stock::CANCEL, RESPONSE_CANCEL);
2650 b->signal_clicked().connect (mem_fun(*this, &Editor::interthread_cancel_clicked));
2651
2652 interthread_cancel_button.add (interthread_cancel_label);
2653
2654 interthread_progress_window->set_default_size (200, 100);
2655 }
2656
2657 void
2658 Editor::interthread_cancel_clicked ()
2659 {
2660 if (current_interthread_info) {
2661 current_interthread_info->cancel = true;
2662 }
2663 }
2664
2665 void
2666 Editor::region_from_selection ()
2667 {
2668 if (clicked_trackview == 0) {
2669 return;
2670 }
2671
2672 if (selection->time.empty()) {
2673 return;
2674 }
2675
2676 nframes64_t start = selection->time[clicked_selection].start;
2677 nframes64_t end = selection->time[clicked_selection].end;
2678
2679 nframes64_t selection_cnt = end - start + 1;
2680
2681 for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
2682 boost::shared_ptr<AudioRegion> current;
2683 boost::shared_ptr<Region> current_r;
2684 boost::shared_ptr<Playlist> pl;
2685
2686 nframes64_t internal_start;
2687 string new_name;
2688
2689 if ((pl = (*i)->playlist()) == 0) {
2690 continue;
2691 }
2692
2693 if ((current_r = pl->top_region_at (start)) == 0) {
2694 continue;
2695 }
2696
2697 current = boost::dynamic_pointer_cast<AudioRegion> (current_r);
2698 // FIXME: audio only
2699 if (current != 0) {
2700 internal_start = start - current->position();
2701 session->region_name (new_name, current->name(), true);
2702 boost::shared_ptr<Region> region (RegionFactory::create (current, internal_start, selection_cnt, new_name));
2703 }
2704 }
2705 }
2706
2707 void
2708 Editor::create_region_from_selection (vector<boost::shared_ptr<AudioRegion> >& new_regions)
2709 {
2710 if (selection->time.empty() || selection->tracks.empty()) {
2711 return;
2712 }
2713
2714 nframes64_t start = selection->time[clicked_selection].start;
2715 nframes64_t end = selection->time[clicked_selection].end;
2716
2717 sort_track_selection ();
2718
2719 for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
2720
2721 boost::shared_ptr<AudioRegion> current;
2722 boost::shared_ptr<Region> current_r;
2723 boost::shared_ptr<Playlist> playlist;
2724 nframes64_t internal_start;
2725 string new_name;
2726
2727 if ((playlist = (*i)->playlist()) == 0) {
2728 continue;
2729 }
2730
2731 if ((current_r = playlist->top_region_at(start)) == 0) {
2732 continue;
2733 }
2734
2735 if ((current = boost::dynamic_pointer_cast<AudioRegion>(current_r)) == 0) {
2736 continue;
2737 }
2738
2739 internal_start = start - current->position();
2740 session->region_name (new_name, current->name(), true);
2741
2742 new_regions.push_back (boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (current, internal_start, end - start + 1, new_name)));
2743 }
2744 }
2745
2746 void
2747 Editor::split_multichannel_region ()
2748 {
2749 RegionSelection rs;
2750
2751 get_regions_for_action (rs);
2752
2753 if (rs.empty()) {
2754 return;
2755 }
2756
2757 vector<boost::shared_ptr<AudioRegion> > v;
2758
2759 for (list<RegionView*>::iterator x = rs.begin(); x != rs.end(); ++x) {
2760
2761 AudioRegionView* arv = dynamic_cast<AudioRegionView*>(*x);
2762
2763 if (!arv || arv->audio_region()->n_channels() < 2) {
2764 continue;
2765 }
2766
2767 (arv)->audio_region()->separate_by_channel (*session, v);
2768 }
2769 }
2770
2771 void
2772 Editor::new_region_from_selection ()
2773 {
2774 region_from_selection ();
2775 cancel_selection ();
2776 }
2777
2778 static void
2779 add_if_covered (RegionView* rv, const AudioRange* ar, RegionSelection* rs)
2780 {
2781 switch (rv->region()->coverage (ar->start, ar->end - 1)) {
2782 case OverlapNone:
2783 break;
2784 default:
2785 rs->push_back (rv);
2786 }
2787 }
2788
2789 void
2790 Editor::separate_regions_between (const TimeSelection& ts)
2791 {
2792 bool in_command = false;
2793 boost::shared_ptr<Playlist> playlist;
2794 RegionSelection new_selection;
2795 TrackSelection tmptracks;
2796
2797 if (selection->tracks.empty()) {
2798
2799 /* use tracks with selected regions */
2800
2801 RegionSelection rs;
2802
2803 get_regions_for_action (rs);
2804
2805 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
2806 TimeAxisView* tv = &(*i)->get_time_axis_view();
2807
2808 if (find (tmptracks.begin(), tmptracks.end(), tv) == tmptracks.end()) {
2809 tmptracks.push_back (tv);
2810 }
2811 }
2812
2813 if (tmptracks.empty()) {
2814 /* no regions selected: do nothing */
2815 return;
2816 }
2817
2818 } else {
2819
2820 tmptracks = selection->tracks;
2821
2822 }
2823
2824 sort_track_selection (&tmptracks);
2825
2826 for (TrackSelection::iterator i = tmptracks.begin(); i != tmptracks.end(); ++i) {
2827
2828 AudioTimeAxisView* atv;
2829
2830 if ((atv = dynamic_cast<AudioTimeAxisView*> ((*i))) != 0) {
2831
2832 if (atv->is_audio_track()) {
2833
2834 /* no edits to destructive tracks */
2835
2836 if (atv->audio_track()->audio_diskstream()->destructive()) {
2837 continue;
2838 }
2839
2840 if ((playlist = atv->playlist()) != 0) {
2841
2842
2843 XMLNode *before;
2844 bool got_some;
2845
2846 before = &(playlist->get_state());
2847 got_some = false;
2848
2849 /* XXX need to consider musical time selections here at some point */
2850
2851 double speed = atv->get_diskstream()->speed();
2852
2853
2854 for (list<AudioRange>::const_iterator t = ts.begin(); t != ts.end(); ++t) {
2855
2856 sigc::connection c = atv->view()->RegionViewAdded.connect (mem_fun(*this, &Editor::collect_new_region_view));
2857 latest_regionviews.clear ();
2858
2859 playlist->partition ((nframes64_t)((*t).start * speed), (nframes64_t)((*t).end * speed), true);
2860
2861 c.disconnect ();
2862
2863 if (!latest_regionviews.empty()) {
2864
2865 got_some = true;
2866
2867 atv->view()->foreach_regionview (bind (sigc::ptr_fun (add_if_covered), &(*t), &new_selection));
2868
2869 if (!in_command) {
2870 begin_reversible_command (_("separate"));
2871 in_command = true;
2872 }
2873
2874 session->add_command(new MementoCommand<Playlist>(*playlist, before, &playlist->get_state()));
2875
2876 }
2877 }
2878
2879 if (!got_some) {
2880 delete before;
2881 }
2882 }
2883 }
2884 }
2885 }
2886
2887 if (in_command) {
2888 selection->set (new_selection);
2889 set_mouse_mode (MouseObject);
2890
2891 commit_reversible_command ();
2892 }
2893 }
2894
2895 void
2896 Editor::separate_region_from_selection ()
2897 {
2898 /* preferentially use *all* ranges in the time selection if we're in range mode
2899 to allow discontiguous operation, since get_edit_op_range() currently
2900 returns a single range.
2901 */
2902
2903 if (mouse_mode == MouseRange && !selection->time.empty()) {
2904
2905 separate_regions_between (selection->time);
2906
2907 } else {
2908
2909 nframes64_t start;
2910 nframes64_t end;
2911
2912 if (get_edit_op_range (start, end)) {
2913
2914 AudioRange ar (start, end, 1);
2915 TimeSelection ts;
2916 ts.push_back (ar);
2917
2918 separate_regions_between (ts);
2919 }
2920 }
2921 }
2922
2923 void
2924 Editor::separate_region_from_punch ()
2925 {
2926 Location* loc = session->locations()->auto_punch_location();
2927 if (loc) {
2928 separate_regions_using_location (*loc);
2929 }
2930 }
2931
2932 void
2933 Editor::separate_region_from_loop ()
2934 {
2935 Location* loc = session->locations()->auto_loop_location();
2936 if (loc) {
2937 separate_regions_using_location (*loc);
2938 }
2939 }
2940
2941 void
2942 Editor::separate_regions_using_location (Location& loc)
2943 {
2944 if (loc.is_mark()) {
2945 return;
2946 }
2947
2948 AudioRange ar (loc.start(), loc.end(), 1);
2949 TimeSelection ts;
2950
2951 ts.push_back (ar);
2952
2953 separate_regions_between (ts);
2954 }
2955
2956 void
2957 Editor::crop_region_to_selection ()
2958 {
2959 if (!selection->time.empty()) {
2960
2961 crop_region_to (selection->time.start(), selection->time.end_frame());
2962
2963 } else {
2964
2965 nframes64_t start;
2966 nframes64_t end;
2967
2968 if (get_edit_op_range (start, end)) {
2969 crop_region_to (start, end);
2970 }
2971 }
2972
2973 }
2974
2975 void
2976 Editor::crop_region_to (nframes64_t start, nframes64_t end)
2977 {
2978 vector<boost::shared_ptr<Playlist> > playlists;
2979 boost::shared_ptr<Playlist> playlist;
2980 TrackSelection* ts;
2981
2982 if (selection->tracks.empty()) {
2983 ts = &track_views;
2984 } else {
2985 sort_track_selection ();
2986 ts = &selection->tracks;
2987 }
2988
2989 for (TrackSelection::iterator i = ts->begin(); i != ts->end(); ++i) {
2990
2991 AudioTimeAxisView* atv;
2992
2993 if ((atv = dynamic_cast<AudioTimeAxisView*> ((*i))) != 0) {
2994
2995 if (atv->is_audio_track()) {
2996
2997 /* no edits to destructive tracks */
2998
2999 if (atv->audio_track()->audio_diskstream()->destructive()) {
3000 continue;
3001 }
3002
3003 if ((playlist = atv->playlist()) != 0) {
3004 playlists.push_back (playlist);
3005 }
3006 }
3007 }
3008 }
3009
3010 if (playlists.empty()) {
3011 return;
3012 }
3013
3014 nframes64_t the_start;
3015 nframes64_t the_end;
3016 nframes64_t cnt;
3017
3018 begin_reversible_command (_("trim to selection"));
3019
3020 for (vector<boost::shared_ptr<Playlist> >::iterator i = playlists.begin(); i != playlists.end(); ++i) {
3021
3022 boost::shared_ptr<Region> region;
3023
3024 the_start = start;
3025
3026 if ((region = (*i)->top_region_at(the_start)) == 0) {
3027 continue;
3028 }
3029
3030 /* now adjust lengths to that we do the right thing
3031 if the selection extends beyond the region
3032 */
3033
3034 the_start = max (the_start, (nframes64_t) region->position());
3035 if (max_frames - the_start < region->length()) {
3036 the_end = the_start + region->length() - 1;
3037 } else {
3038 the_end = max_frames;
3039 }
3040 the_end = min (end, the_end);
3041 cnt = the_end - the_start + 1;
3042
3043 XMLNode &before = (*i)->get_state();
3044 region->trim_to (the_start, cnt, this);
3045 XMLNode &after = (*i)->get_state();
3046 session->add_command (new MementoCommand<Playlist>(*(*i), &before, &after));
3047 }
3048
3049 commit_reversible_command ();
3050 }
3051
3052 void
3053 Editor::region_fill_track ()
3054 {
3055 nframes64_t end;
3056 RegionSelection rs;
3057
3058 get_regions_for_action (rs);
3059
3060 if (!session || rs.empty()) {
3061 return;
3062 }
3063
3064 end = session->current_end_frame ();
3065
3066 begin_reversible_command (_("region fill"));
3067
3068 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
3069
3070 boost::shared_ptr<Region> region ((*i)->region());
3071
3072 // FIXME
3073 boost::shared_ptr<AudioRegion> ar = boost::dynamic_pointer_cast<AudioRegion>(region);
3074 if (!ar)
3075 continue;
3076
3077 boost::shared_ptr<Playlist> pl = region->playlist();
3078
3079 if (end <= region->last_frame()) {
3080 return;
3081 }
3082
3083 double times = (double) (end - region->last_frame()) / (double) region->length();
3084
3085 if (times == 0) {
3086 return;
3087 }
3088
3089 XMLNode &before = pl->get_state();
3090 pl->add_region (RegionFactory::create (ar), ar->last_frame(), times);
3091 session->add_command (new MementoCommand<Playlist>(*pl, &before, &pl->get_state()));
3092 }
3093
3094 commit_reversible_command ();
3095 }
3096
3097 void
3098 Editor::region_fill_selection ()
3099 {
3100 if (clicked_audio_trackview == 0 || !clicked_audio_trackview->is_audio_track()) {
3101 return;
3102 }
3103
3104 if (selection->time.empty()) {
3105 return;
3106 }
3107
3108
3109 Glib::RefPtr<TreeSelection> selected = region_list_display.get_selection();
3110
3111 if (selected->count_selected_rows() != 1) {
3112 return;
3113 }
3114
3115 TreeModel::iterator i = region_list_display.get_selection()->get_selected();
3116 boost::shared_ptr<Region> region = (*i)[region_list_columns.region];
3117
3118 nframes64_t start = selection->time[clicked_selection].start;
3119 nframes64_t end = selection->time[clicked_selection].end;
3120
3121 boost::shared_ptr<Playlist> playlist;
3122
3123 if (selection->tracks.empty()) {
3124 return;
3125 }
3126
3127 nframes64_t selection_length = end - start;
3128 float times = (float)selection_length / region->length();
3129
3130 begin_reversible_command (_("fill selection"));
3131
3132 for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
3133
3134 if ((playlist = (*i)->playlist()) == 0) {
3135 continue;
3136 }
3137
3138 XMLNode &before = playlist->get_state();
3139 playlist->add_region (RegionFactory::create (region), start, times);
3140 session->add_command (new MementoCommand<Playlist>(*playlist, &before, &playlist->get_state()));
3141 }
3142
3143 commit_reversible_command ();
3144 }
3145
3146 void
3147 Editor::set_region_sync_from_edit_point ()
3148 {
3149 nframes64_t where = get_preferred_edit_position ();
3150 RegionSelection rs;
3151 get_regions_for_action (rs);
3152 set_sync_point (where, rs);
3153 }
3154
3155 void
3156 Editor::set_sync_point (nframes64_t where, const RegionSelection& rs)
3157 {
3158 bool in_command = false;
3159
3160 for (RegionSelection::const_iterator r = rs.begin(); r != rs.end(); ++r) {
3161
3162 if (!(*r)->region()->covers (where)) {
3163 continue;
3164 }
3165
3166 boost::shared_ptr<Region> region ((*r)->region());
3167
3168 if (!in_command) {
3169 begin_reversible_command (_("set sync point"));
3170 in_command = true;
3171 }
3172
3173 XMLNode &before = region->playlist()->get_state();
3174 region->set_sync_position (where);
3175 XMLNode &after = region->playlist()->get_state();
3176 session->add_command(new MementoCommand<Playlist>(*(region->playlist()), &before, &after));
3177 }
3178
3179 if (in_command) {
3180 commit_reversible_command ();
3181 }
3182 }
3183
3184 void
3185 Editor::remove_region_sync ()
3186 {
3187 RegionSelection rs;
3188
3189 get_regions_for_action (rs);
3190
3191 if (rs.empty()) {
3192 return;
3193 }
3194
3195 begin_reversible_command (_("remove sync"));
3196 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
3197
3198 XMLNode &before = (*i)->region()->playlist()->get_state();
3199 (*i)->region()->clear_sync_position ();
3200 XMLNode &after = (*i)->region()->playlist()->get_state();
3201 session->add_command(new MementoCommand<Playlist>(*((*i)->region()->playlist()), &before, &after));
3202 }
3203 commit_reversible_command ();
3204 }
3205
3206 void
3207 Editor::naturalize ()
3208 {
3209 RegionSelection rs;
3210
3211 get_regions_for_action (rs);
3212
3213 if (rs.empty()) {
3214 return;
3215 }
3216
3217 begin_reversible_command (_("naturalize"));
3218 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
3219 XMLNode &before = (*i)->region()->get_state();
3220 (*i)->region()->move_to_natural_position (this);
3221 XMLNode &after = (*i)->region()->get_state();
3222 session->add_command (new MementoCommand<Region>(*((*i)->region().get()), &before, &after));
3223 }
3224 commit_reversible_command ();
3225 }
3226
3227 void
3228 Editor::align (RegionPoint what)
3229 {
3230 RegionSelection rs;
3231
3232 get_regions_for_action (rs);
3233 nframes64_t where = get_preferred_edit_position();
3234
3235 if (!rs.empty()) {
3236 align_selection (what, where, rs);
3237 } else {
3238
3239 RegionSelection rs;
3240 get_regions_at (rs, where, selection->tracks);
3241 align_selection (what, where, rs);
3242 }
3243 }
3244
3245 void
3246 Editor::align_relative (RegionPoint what)
3247 {
3248 nframes64_t where = get_preferred_edit_position();
3249 RegionSelection rs;
3250
3251 get_regions_for_action (rs);
3252
3253 if (!rs.empty()) {
3254 align_selection_relative (what, where, rs);
3255 }
3256 }
3257
3258 struct RegionSortByTime {
3259 bool operator() (const AudioRegionView* a, const AudioRegionView* b) {
3260 return a->region()->position() < b->region()->position();
3261 }
3262 };
3263
3264 void
3265 Editor::align_selection_relative (RegionPoint point, nframes64_t position, const RegionSelection& rs)
3266 {
3267 if (rs.empty()) {
3268 return;
3269 }
3270
3271 nframes64_t distance = 0;
3272 nframes64_t pos = 0;
3273 int dir = 1;
3274
3275 list<RegionView*> sorted;
3276 rs.by_position (sorted);
3277
3278 boost::shared_ptr<Region> r ((*sorted.begin())->region());
3279
3280 switch (point) {
3281 case Start:
3282 pos = position;
3283 if (position > r->position()) {
3284 distance = position - r->position();
3285 } else {
3286 distance = r->position() - position;
3287 dir = -1;
3288 }
3289 break;
3290
3291 case End:
3292 if (position > r->last_frame()) {
3293 distance = position - r->last_frame();
3294 pos = r->position() + distance;
3295 } else {
3296 distance = r->last_frame() - position;
3297 pos = r->position() - distance;
3298 dir = -1;
3299 }
3300 break;
3301
3302 case SyncPoint:
3303 pos = r->adjust_to_sync (position);
3304 if (pos > r->position()) {
3305 distance = pos - r->position();
3306 } else {
3307 distance = r->position() - pos;
3308 dir = -1;
3309 }
3310 break;
3311 }
3312
3313 if (pos == r->position()) {
3314 return;
3315 }
3316
3317 begin_reversible_command (_("align selection (relative)"));
3318
3319 /* move first one specially */
3320
3321 XMLNode &before = r->playlist()->get_state();
3322 r->set_position (pos, this);
3323 XMLNode &after = r->playlist()->get_state();
3324 session->add_command(new MementoCommand<Playlist>(*(r->playlist()), &before, &after));
3325
3326 /* move rest by the same amount */
3327
3328 sorted.pop_front();
3329
3330 for (list<RegionView*>::iterator i = sorted.begin(); i != sorted.end(); ++i) {
3331
3332 boost::shared_ptr<Region> region ((*i)->region());
3333
3334 XMLNode &before = region->playlist()->get_state();
3335
3336 if (dir > 0) {
3337 region->set_position (region->position() + distance, this);
3338 } else {
3339 region->set_position (region->position() - distance, this);
3340 }
3341
3342 XMLNode &after = region->playlist()->get_state();
3343 session->add_command(new MementoCommand<Playlist>(*(region->playlist()), &before, &after));
3344
3345 }
3346
3347 commit_reversible_command ();
3348 }
3349
3350 void
3351 Editor::align_selection (RegionPoint point, nframes64_t position, const RegionSelection& rs)
3352 {
3353 if (rs.empty()) {
3354 return;
3355 }
3356
3357 begin_reversible_command (_("align selection"));
3358
3359 for (RegionSelection::const_iterator i = rs.begin(); i != rs.end(); ++i) {
3360 align_region_internal ((*i)->region(), point, position);
3361 }
3362
3363 commit_reversible_command ();
3364 }
3365
3366 void
3367 Editor::align_region (boost::shared_ptr<Region> region, RegionPoint point, nframes64_t position)
3368 {
3369 begin_reversible_command (_("align region"));
3370 align_region_internal (region, point, position);
3371 commit_reversible_command ();
3372 }
3373
3374 void
3375 Editor::align_region_internal (boost::shared_ptr<Region> region, RegionPoint point, nframes64_t position)
3376 {
3377 XMLNode &before = region->playlist()->get_state();
3378
3379 switch (point) {
3380 case SyncPoint:
3381 region->set_position (region->adjust_to_sync (position), this);
3382 break;
3383
3384 case End:
3385 if (position > region->length()) {
3386 region->set_position (position - region->length(), this);
3387 }
3388 break;
3389
3390 case Start:
3391 region->set_position (position, this);
3392 break;
3393 }
3394
3395 XMLNode &after = region->playlist()->get_state();
3396 session->add_command(new MementoCommand<Playlist>(*(region->playlist()), &before, &after));
3397 }
3398
3399 void
3400 Editor::trim_region_to_loop ()
3401 {
3402 Location* loc = session->locations()->auto_loop_location();
3403 if (!loc) {
3404 return;
3405 }
3406 trim_region_to_location (*loc, _("trim to loop"));
3407 }
3408
3409 void
3410 Editor::trim_region_to_punch ()
3411 {
3412 Location* loc = session->locations()->auto_punch_location();
3413 if (!loc) {
3414 return;
3415 }
3416 trim_region_to_location (*loc, _("trim to punch"));
3417 }
3418
3419 void
3420 Editor::trim_region_to_location (const Location& loc, const char* str)
3421 {
3422 RegionSelection rs;
3423
3424 get_regions_for_action (rs);
3425
3426 begin_reversible_command (str);
3427
3428 for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
3429 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (*x);
3430
3431 if (!arv) {
3432 continue;
3433 }
3434
3435 /* require region to span proposed trim */
3436
3437 switch (arv->region()->coverage (loc.start(), loc.end())) {
3438 case OverlapInternal:
3439 break;
3440 default:
3441 continue;
3442 }
3443
3444 AudioTimeAxisView* atav = dynamic_cast<AudioTimeAxisView*> (&arv->get_time_axis_view());
3445
3446 if (!atav) {
3447 return;
3448 }
3449
3450 float speed = 1.0;
3451 nframes64_t start;
3452 nframes64_t end;
3453
3454 if (atav->get_diskstream() != 0) {
3455 speed = atav->get_diskstream()->speed();
3456 }
3457
3458 start = session_frame_to_track_frame (loc.start(), speed);
3459 end = session_frame_to_track_frame (loc.end(), speed);
3460
3461 XMLNode &before = arv->region()->playlist()->get_state();
3462 arv->region()->trim_to (start, (end - start), this);
3463 XMLNode &after = arv->region()->playlist()->get_state();
3464 session->add_command(new MementoCommand<Playlist>(*(arv->region()->playlist()), &before, &after));
3465 }
3466
3467 commit_reversible_command ();
3468 }
3469
3470 void
3471 Editor::trim_region_to_edit_point ()
3472 {
3473 RegionSelection rs;
3474
3475 get_regions_for_action (rs);
3476
3477 nframes64_t where = get_preferred_edit_position();
3478
3479 begin_reversible_command (_("trim region start to edit point"));
3480
3481 for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
3482 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (*x);
3483
3484 if (!arv) {
3485 continue;
3486 }
3487
3488 /* require region to cover trim */
3489
3490 if (!arv->region()->covers (where)) {
3491 continue;
3492 }
3493
3494 AudioTimeAxisView* atav = dynamic_cast<AudioTimeAxisView*> (&arv->get_time_axis_view());
3495
3496 if (!atav) {
3497 return;
3498 }
3499
3500 float speed = 1.0;
3501
3502 if (atav->get_diskstream() != 0) {
3503 speed = atav->get_diskstream()->speed();
3504 }
3505
3506 XMLNode &before = arv->region()->playlist()->get_state();
3507 arv->region()->trim_end( session_frame_to_track_frame(where, speed), this);
3508 XMLNode &after = arv->region()->playlist()->get_state();
3509 session->add_command(new MementoCommand<Playlist>(*(arv->region()->playlist()), &before, &after));
3510 }
3511
3512 commit_reversible_command ();
3513 }
3514
3515 void
3516 Editor::trim_region_from_edit_point ()
3517 {
3518 RegionSelection rs;
3519
3520 get_regions_for_action (rs);
3521
3522 nframes64_t where = get_preferred_edit_position();
3523
3524 begin_reversible_command (_("trim region end to edit point"));
3525
3526 for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
3527 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (*x);
3528
3529 if (!arv) {
3530 continue;
3531 }
3532
3533 /* require region to cover trim */
3534
3535 if (!arv->region()->covers (where)) {
3536 continue;
3537 }
3538
3539 AudioTimeAxisView* atav = dynamic_cast<AudioTimeAxisView*> (&arv->get_time_axis_view());
3540
3541 if (!atav) {
3542 return;
3543 }
3544
3545 float speed = 1.0;
3546
3547 if (atav->get_diskstream() != 0) {
3548 speed = atav->get_diskstream()->speed();
3549 }
3550
3551 XMLNode &before = arv->region()->playlist()->get_state();
3552 arv->region()->trim_front ( session_frame_to_track_frame(where, speed), this);
3553 XMLNode &after = arv->region()->playlist()->get_state();
3554 session->add_command(new MementoCommand<Playlist>(*(arv->region()->playlist()), &before, &after));
3555 }
3556
3557 commit_reversible_command ();
3558 }
3559
3560 void
3561 Editor::unfreeze_route ()
3562 {
3563 if (clicked_audio_trackview == 0 || !clicked_audio_trackview->is_audio_track()) {
3564 return;
3565 }
3566
3567 clicked_audio_trackview->audio_track()->unfreeze ();
3568 }
3569
3570 void*
3571 Editor::_freeze_thread (void* arg)
3572 {
3573 PBD::notify_gui_about_thread_creation (pthread_self(), X_("Freeze"));
3574 return static_cast<Editor*>(arg)->freeze_thread ();
3575 }
3576
3577 void*
3578 Editor::freeze_thread ()
3579 {
3580 clicked_audio_trackview->audio_track()->freeze (*current_interthread_info);
3581 return 0;
3582 }
3583
3584 gint
3585 Editor::freeze_progress_timeout (void *arg)
3586 {
3587 interthread_progress_bar.set_fraction (current_interthread_info->progress);
3588 return !(current_interthread_info->done || current_interthread_info->cancel);
3589 }
3590
3591 void
3592 Editor::freeze_route ()
3593 {
3594 if (clicked_audio_trackview == 0 || !clicked_audio_trackview->is_audio_track()) {
3595 return;
3596 }
3597
3598 InterThreadInfo itt;
3599
3600 if (interthread_progress_window == 0) {
3601 build_interthread_progress_window ();
3602 }
3603
3604 interthread_progress_window->set_title (_("Freeze"));
3605 interthread_progress_window->set_position (Gtk::WIN_POS_MOUSE);
3606 interthread_progress_window->show_all ();
3607 interthread_progress_bar.set_fraction (0.0f);
3608 interthread_progress_label.set_text ("");
3609 interthread_cancel_label.set_text (_("Cancel Freeze"));
3610 current_interthread_info = &itt;
3611
3612 interthread_progress_connection =
3613 Glib::signal_timeout().connect (bind (mem_fun(*this, &Editor::freeze_progress_timeout), (gpointer) 0), 100);
3614
3615 itt.done = false;
3616 itt.cancel = false;
3617 itt.progress = 0.0f;
3618
3619 pthread_attr_t attr;
3620 pthread_attr_init(&attr);
3621 pthread_attr_setstacksize(&attr, 500000);
3622
3623 pthread_create_and_store (X_("freezer"), &itt.thread, &attr, _freeze_thread, this);
3624
3625 pthread_attr_destroy(&attr);
3626
3627 track_canvas->get_window()->set_cursor (Gdk::Cursor (Gdk::WATCH));
3628
3629 while (!itt.done && !itt.cancel) {
3630 gtk_main_iteration ();
3631 }
3632
3633 interthread_progress_connection.disconnect ();
3634 interthread_progress_window->hide_all ();
3635 current_interthread_info = 0;
3636 track_canvas->get_window()->set_cursor (*current_canvas_cursor);
3637 }
3638
3639 void
3640 Editor::bounce_range_selection (bool replace, bool enable_processing)
3641 {
3642 if (selection->time.empty()) {
3643 return;
3644 }
3645
3646 TrackSelection views = selection->tracks;
3647
3648 nframes64_t start = selection->time[clicked_selection].start;
3649 nframes64_t end = selection->time[clicked_selection].end;
3650 nframes64_t cnt = end - start + 1;
3651
3652 begin_reversible_command (_("bounce range"));
3653
3654 for (TrackViewList::iterator i = views.begin(); i != views.end(); ++i) {
3655
3656 AudioTimeAxisView* atv;
3657
3658 if ((atv = dynamic_cast<AudioTimeAxisView*> (*i)) == 0) {
3659 continue;
3660 }
3661
3662 boost::shared_ptr<Playlist> playlist;
3663
3664 if ((playlist = atv->playlist()) == 0) {
3665 return;
3666 }
3667
3668 InterThreadInfo itt;
3669
3670 itt.done = false;
3671 itt.cancel = false;
3672 itt.progress = false;
3673
3674 XMLNode &before = playlist->get_state();
3675 boost::shared_ptr<Region> r = atv->audio_track()->bounce_range (start, start+cnt, itt, enable_processing);
3676
3677 if (replace) {
3678 list<AudioRange> ranges;
3679 ranges.push_back (AudioRange (start, start+cnt, 0));
3680 playlist->cut (ranges); // discard result
3681 playlist->add_region (r, start);
3682 }
3683
3684 XMLNode &after = playlist->get_state();
3685 session->add_command (new MementoCommand<Playlist> (*playlist, &before, &after));
3686 }
3687
3688 commit_reversible_command ();
3689 }
3690
3691 void
3692 Editor::cut ()
3693 {
3694 cut_copy (Cut);
3695 }
3696
3697 void
3698 Editor::copy ()
3699 {
3700 cut_copy (Copy);
3701 }
3702
3703 void
3704 Editor::cut_copy (CutCopyOp op)
3705 {
3706 /* only cancel selection if cut/copy is successful.*/
3707
3708 string opname;
3709
3710 switch (op) {
3711 case Cut:
3712 opname = _("cut");
3713 break;
3714 case Copy:
3715 opname = _("copy");
3716 break;
3717 case Clear:
3718 opname = _("clear");
3719 break;
3720 }
3721
3722 /* if we're deleting something, and the mouse is still pressed,
3723 the thing we started a drag for will be gone when we release
3724 the mouse button(s). avoid this. see part 2 at the end of
3725 this function.
3726 */
3727
3728 if (op == Cut || op == Clear) {
3729 if (drag_info.item) {
3730 drag_info.item->ungrab (0);
3731 drag_info.item = 0;
3732 }
3733 }
3734
3735 cut_buffer->clear ();
3736
3737 if (entered_marker) {
3738
3739 /* cut/delete op while pointing at a marker */
3740
3741 bool ignored;
3742 Location* loc = find_location_from_marker (entered_marker, ignored);
3743
3744 if (session && loc) {
3745 Glib::signal_idle().connect (bind (mem_fun(*this, &Editor::really_remove_marker), loc));
3746 }
3747
3748 break_drag ();
3749
3750 return;
3751 }
3752
3753 RegionSelection rs;
3754
3755 /* we only want to cut regions if some are selected */
3756
3757 if (!selection->regions.empty()) {
3758 get_regions_for_action (rs);
3759 }
3760
3761 switch (current_mouse_mode()) {
3762 case MouseObject:
3763 if (!rs.empty() || !selection->points.empty()) {
3764
3765 begin_reversible_command (opname + _(" objects"));
3766
3767 if (!rs.empty()) {
3768 cut_copy_regions (op, rs);
3769
3770 if (op == Cut) {
3771 selection->clear_regions ();
3772 }
3773 }
3774
3775 if (!selection->points.empty()) {
3776 cut_copy_points (op);
3777
3778 if (op == Cut) {
3779 selection->clear_points ();
3780 }
3781 }
3782
3783 commit_reversible_command ();
3784 break; // terminate case statement here
3785 }
3786 if (!selection->time.empty()) {
3787 /* don't cause suprises */
3788 break;
3789 }
3790 // fall thru if there was nothing selected
3791
3792 case MouseRange:
3793 if (selection->time.empty()) {
3794 nframes64_t start, end;
3795 if (!get_edit_op_range (start, end)) {
3796 return;
3797 }
3798 selection->set ((TimeAxisView*) 0, start, end);
3799 }
3800
3801 begin_reversible_command (opname + _(" range"));
3802 cut_copy_ranges (op);
3803 commit_reversible_command ();
3804
3805 if (op == Cut) {
3806 selection->clear_time ();
3807 }
3808
3809 break;
3810
3811 default:
3812 break;
3813 }
3814
3815
3816 if (op == Cut || op == Clear) {
3817 break_drag ();
3818 }
3819 }
3820
3821 void
3822 Editor::cut_copy_points (CutCopyOp op)
3823 {
3824 for (PointSelection::iterator i = selection->points.begin(); i != selection->points.end(); ++i) {
3825
3826 AutomationTimeAxisView* atv = dynamic_cast<AutomationTimeAxisView*>(&(*i).track);
3827
3828 if (atv) {
3829 atv->cut_copy_clear_objects (selection->points, op);
3830 }
3831 }
3832 }
3833
3834 struct PlaylistState {
3835 boost::shared_ptr<Playlist> playlist;
3836 XMLNode* before;
3837 };
3838
3839 struct lt_playlist {
3840 bool operator () (const PlaylistState& a, const PlaylistState& b) {
3841 return a.playlist < b.playlist;
3842 }
3843 };
3844
3845 struct PlaylistMapping {
3846 TimeAxisView* tv;
3847 boost::shared_ptr<AudioPlaylist> pl;
3848
3849 PlaylistMapping (TimeAxisView* tvp) : tv (tvp) {}
3850 };
3851
3852 void
3853 Editor::cut_copy_regions (CutCopyOp op, RegionSelection& rs)
3854 {
3855 /* we can't use a std::map here because the ordering is important, and we can't trivially sort
3856 a map when we want ordered access to both elements. i think.
3857 */
3858
3859 vector<PlaylistMapping> pmap;
3860
3861 nframes64_t first_position = max_frames;
3862
3863 set<PlaylistState, lt_playlist> freezelist;
3864 pair<set<PlaylistState, lt_playlist>::iterator,bool> insert_result;
3865
3866 /* get ordering correct before we cut/copy */
3867
3868 rs.sort_by_position_and_track ();
3869
3870 for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
3871
3872 first_position = min ((nframes64_t) (*x)->region()->position(), first_position);
3873
3874 if (op == Cut || op == Clear) {
3875 boost::shared_ptr<AudioPlaylist> pl = boost::dynamic_pointer_cast<AudioPlaylist>((*x)->region()->playlist());
3876
3877 if (pl) {
3878
3879 PlaylistState before;
3880 before.playlist = pl;
3881 before.before = &pl->get_state();
3882
3883 insert_result = freezelist.insert (before);
3884
3885 if (insert_result.second) {
3886 pl->freeze ();
3887 }
3888 }
3889 }
3890
3891 TimeAxisView* tv = &(*x)->get_trackview();
3892 vector<PlaylistMapping>::iterator z;
3893
3894 for (z = pmap.begin(); z != pmap.end(); ++z) {
3895 if ((*z).tv == tv) {
3896 break;
3897 }
3898 }
3899
3900 if (z == pmap.end()) {
3901 pmap.push_back (PlaylistMapping (tv));
3902 }
3903 }
3904
3905 for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ) {
3906
3907 boost::shared_ptr<AudioPlaylist> pl = boost::dynamic_pointer_cast<AudioPlaylist>((*x)->region()->playlist());
3908
3909 if (!pl) {
3910 /* impossible, but this handles it for the future */
3911 continue;
3912 }
3913
3914 TimeAxisView& tv = (*x)->get_trackview();
3915 boost::shared_ptr<AudioPlaylist> npl;
3916 RegionSelection::iterator tmp;
3917
3918 tmp = x;
3919 ++tmp;
3920
3921 vector<PlaylistMapping>::iterator z;
3922
3923 for (z = pmap.begin(); z != pmap.end(); ++z) {
3924 if ((*z).tv == &tv) {
3925 break;
3926 }
3927 }
3928
3929 assert (z != pmap.end());
3930
3931 if (!(*z).pl) {
3932 npl = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (*session, "cutlist", true));
3933 npl->freeze();
3934 (*z).pl = npl;
3935 } else {
3936 npl = (*z).pl;
3937 }
3938
3939 boost::shared_ptr<AudioRegion> ar = boost::dynamic_pointer_cast<AudioRegion>((*x)->region());
3940 boost::shared_ptr<Region> _xx;
3941
3942 switch (op) {
3943 case Cut:
3944 if (!ar) break;
3945
3946 _xx = RegionFactory::create ((*x)->region());
3947 npl->add_region (_xx, (*x)->region()->position() - first_position);
3948 pl->remove_region (((*x)->region()));
3949 break;
3950
3951 case Copy:
3952 if (!ar) break;
3953
3954 /* copy region before adding, so we're not putting same object into two different playlists */
3955 npl->add_region (RegionFactory::create ((*x)->region()), (*x)->region()->position() - first_position);
3956 break;
3957
3958 case Clear:
3959 pl->remove_region (((*x)->region()));
3960 break;
3961 }
3962
3963 x = tmp;
3964 }
3965
3966 list<boost::shared_ptr<Playlist> > foo;
3967
3968 /* the pmap is in the same order as the tracks in which selected regions occured */
3969
3970 for (vector<PlaylistMapping>::iterator i = pmap.begin(); i != pmap.end(); ++i) {
3971 (*i).pl->thaw();
3972 foo.push_back ((*i).pl);
3973 }
3974
3975
3976 if (!foo.empty()) {
3977 cut_buffer->set (foo);
3978 }
3979
3980 for (set<PlaylistState, lt_playlist>::iterator pl = freezelist.begin(); pl != freezelist.end(); ++pl) {
3981 (*pl).playlist->thaw ();
3982 session->add_command (new MementoCommand<Playlist>(*(*pl).playlist, (*pl).before, &(*pl).playlist->get_state()));
3983 }
3984 }
3985
3986 void
3987 Editor::cut_copy_ranges (CutCopyOp op)
3988 {
3989 TrackSelection* ts;
3990 TrackSelection entered;
3991
3992 if (selection->tracks.empty()) {
3993 if (!entered_track) {
3994 return;
3995 }
3996 entered.push_back (entered_track);
3997 ts = &entered;
3998 } else {
3999 ts = &selection->tracks;
4000 }
4001
4002 for (TrackSelection::iterator i = ts->begin(); i != ts->end(); ++i) {
4003 (*i)->cut_copy_clear (*selection, op);
4004 }
4005 }
4006
4007 void
4008 Editor::paste (float times)
4009 {
4010 paste_internal (get_preferred_edit_position(), times);
4011 }
4012
4013 void
4014 Editor::mouse_paste ()
4015 {
4016 nframes64_t where;
4017 bool ignored;
4018
4019 if (!mouse_frame (where, ignored)) {
4020 return;
4021 }
4022
4023 snap_to (where);
4024 paste_internal (where, 1);
4025 }
4026
4027 void
4028 Editor::paste_internal (nframes64_t position, float times)
4029 {
4030 bool commit = false;
4031
4032 if (cut_buffer->empty()) {
4033 return;
4034 }
4035
4036 if (position == max_frames) {
4037 position = get_preferred_edit_position();
4038 }
4039
4040 begin_reversible_command (_("paste"));
4041
4042 TrackSelection ts;
4043 TrackSelection::iterator i;
4044 size_t nth;
4045
4046 /* get everything in the correct order */
4047
4048
4049 if (!selection->tracks.empty()) {
4050 sort_track_selection ();
4051 ts = selection->tracks;
4052 } else if (entered_track) {
4053 ts.push_back (entered_track);
4054 }
4055
4056 for (nth = 0, i = ts.begin(); i != ts.end(); ++i, ++nth) {
4057
4058 /* undo/redo is handled by individual tracks */
4059
4060 if ((*i)->paste (position, times, *cut_buffer, nth)) {
4061 commit = true;
4062 }
4063 }
4064
4065 if (commit) {
4066 commit_reversible_command ();
4067 }
4068 }
4069
4070 void
4071 Editor::paste_named_selection (float times)
4072 {
4073 TrackSelection::iterator t;
4074
4075 Glib::RefPtr<TreeSelection> selected = named_selection_display.get_selection();
4076
4077 if (selected->count_selected_rows() != 1 || selection->tracks.empty()) {
4078 return;
4079 }
4080
4081 TreeModel::iterator i = selected->get_selected();
4082 NamedSelection* ns = (*i)[named_selection_columns.selection];
4083
4084 list<boost::shared_ptr<Playlist> >::iterator chunk;
4085 list<boost::shared_ptr<Playlist> >::iterator tmp;
4086
4087 chunk = ns->playlists.begin();
4088
4089 begin_reversible_command (_("paste chunk"));
4090
4091 sort_track_selection ();
4092
4093 for (t = selection->tracks.begin(); t != selection->tracks.end(); ++t) {
4094
4095 AudioTimeAxisView* atv;
4096 boost::shared_ptr<Playlist> pl;
4097 boost::shared_ptr<AudioPlaylist> apl;
4098
4099 if ((atv = dynamic_cast<AudioTimeAxisView*> (*t)) == 0) {
4100 continue;
4101 }
4102
4103 if ((pl = atv->playlist()) == 0) {
4104 continue;
4105 }
4106
4107 if ((apl = boost::dynamic_pointer_cast<AudioPlaylist> (pl)) == 0) {
4108 continue;
4109 }
4110
4111 tmp = chunk;
4112 ++tmp;
4113
4114 XMLNode &before = apl->get_state();
4115 apl->paste (*chunk, get_preferred_edit_position(), times);
4116 session->add_command(new MementoCommand<AudioPlaylist>(*apl, &before, &apl->get_state()));
4117
4118 if (tmp != ns->playlists.end()) {
4119 chunk = tmp;
4120 }
4121 }
4122
4123 commit_reversible_command();
4124 }
4125
4126 void
4127 Editor::duplicate_some_regions (RegionSelection& regions, float times)
4128 {
4129 boost::shared_ptr<Playlist> playlist;
4130 RegionSelection sel = regions; // clear (below) may clear the argument list if its the current region selection
4131 RegionSelection foo;
4132
4133 begin_reversible_command (_("duplicate region"));
4134
4135 selection->clear_regions ();
4136
4137 for (RegionSelection::iterator i = sel.begin(); i != sel.end(); ++i) {
4138
4139 boost::shared_ptr<Region> r ((*i)->region());
4140
4141 TimeAxisView& tv = (*i)->get_time_axis_view();
4142 AudioTimeAxisView* atv = dynamic_cast<AudioTimeAxisView*> (&tv);
4143
4144 latest_regionviews.clear ();
4145 sigc::connection c = atv->view()->RegionViewAdded.connect (mem_fun(*this, &Editor::collect_new_region_view));
4146
4147 playlist = (*i)->region()->playlist();
4148 XMLNode &before = playlist->get_state();
4149 playlist->duplicate (r, r->last_frame() + 1, times);
4150 session->add_command(new MementoCommand<Playlist>(*playlist, &before, &playlist->get_state()));
4151
4152 c.disconnect ();
4153
4154 foo.insert (foo.end(), latest_regionviews.begin(), latest_regionviews.end());
4155 }
4156
4157 commit_reversible_command ();
4158
4159 if (!foo.empty()) {
4160 selection->set (foo);
4161 }
4162 }
4163
4164 void
4165 Editor::duplicate_selection (float times)
4166 {
4167 if (selection->time.empty() || selection->tracks.empty()) {
4168 return;
4169 }
4170
4171 boost::shared_ptr<Playlist> playlist;
4172 vector<boost::shared_ptr<AudioRegion> > new_regions;
4173 vector<boost::shared_ptr<AudioRegion> >::iterator ri;
4174
4175 create_region_from_selection (new_regions);
4176
4177 if (new_regions.empty()) {
4178 return;
4179 }
4180
4181 begin_reversible_command (_("duplicate selection"));
4182
4183 ri = new_regions.begin();
4184
4185 for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
4186 if ((playlist = (*i)->playlist()) == 0) {
4187 continue;
4188 }
4189 XMLNode &before = playlist->get_state();
4190 playlist->duplicate (*ri, selection->time[clicked_selection].end, times);
4191 XMLNode &after = playlist->get_state();
4192 session->add_command (new MementoCommand<Playlist>(*playlist, &before, &after));
4193
4194 ++ri;
4195 if (ri == new_regions.end()) {
4196 --ri;
4197 }
4198 }
4199
4200 commit_reversible_command ();
4201 }
4202
4203 void
4204 Editor::reset_point_selection ()
4205 {
4206 /* reset all selected points to the relevant default value */
4207
4208 for (PointSelection::iterator i = selection->points.begin(); i != selection->points.end(); ++i) {
4209
4210 AutomationTimeAxisView* atv = dynamic_cast<AutomationTimeAxisView*>(&(*i).track);
4211
4212 if (atv) {
4213 atv->reset_objects (selection->points);
4214 }
4215 }
4216 }
4217
4218 void
4219 Editor::center_playhead ()
4220 {
4221 float page = canvas_width * frames_per_unit;
4222 center_screen_internal (playhead_cursor->current_frame, page);
4223 }
4224
4225 void
4226 Editor::center_edit_point ()
4227 {
4228 float page = canvas_width * frames_per_unit;
4229 center_screen_internal (get_preferred_edit_position(), page);
4230 }
4231
4232 void
4233 Editor::clear_playlist (boost::shared_ptr<Playlist> playlist)
4234 {
4235 begin_reversible_command (_("clear playlist"));
4236 XMLNode &before = playlist->get_state();
4237 playlist->clear ();
4238 XMLNode &after = playlist->get_state();
4239 session->add_command (new MementoCommand<Playlist>(*playlist.get(), &before, &after));
4240 commit_reversible_command ();
4241 }
4242
4243 void
4244 Editor::nudge_track (bool use_edit, bool forwards)
4245 {
4246 boost::shared_ptr<Playlist> playlist;
4247 nframes64_t distance;
4248 nframes64_t next_distance;
4249 nframes64_t start;
4250
4251 if (use_edit) {
4252 start = get_preferred_edit_position();
4253 } else {
4254 start = 0;
4255 }
4256
4257 if ((distance = get_nudge_distance (start, next_distance)) == 0) {
4258 return;
4259 }
4260
4261 if (selection->tracks.empty()) {
4262 return;
4263 }
4264
4265 begin_reversible_command (_("nudge track"));
4266
4267 for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
4268
4269 if ((playlist = (*i)->playlist()) == 0) {
4270 continue;
4271 }
4272
4273 XMLNode &before = playlist->get_state();
4274 playlist->nudge_after (start, distance, forwards);
4275 XMLNode &after = playlist->get_state();
4276 session->add_command (new MementoCommand<Playlist>(*playlist, &before, &after));
4277 }
4278
4279 commit_reversible_command ();
4280 }
4281
4282 void
4283 Editor::remove_last_capture ()
4284 {
4285 vector<string> choices;
4286 string prompt;
4287
4288 if (!session) {
4289 return;
4290 }
4291
4292 if (Config->get_verify_remove_last_capture()) {
4293 prompt = _("Do you really want to destroy the last capture?"
4294 "\n(This is destructive and cannot be undone)");
4295
4296 choices.push_back (_("No, do nothing."));
4297 choices.push_back (_("Yes, destroy it."));
4298
4299 Gtkmm2ext::Choice prompter (prompt, choices);
4300
4301 if (prompter.run () == 1) {
4302 session->remove_last_capture ();
4303 }
4304
4305 } else {
4306 session->remove_last_capture();
4307 }
4308 }
4309
4310 void
4311 Editor::normalize_region ()
4312 {
4313 RegionSelection rs;
4314
4315 get_regions_for_action (rs);
4316
4317 if (!session) {
4318 return;
4319 }
4320
4321 if (rs.empty()) {
4322 return;
4323 }
4324
4325 begin_reversible_command (_("normalize"));
4326
4327 track_canvas->get_window()->set_cursor (*wait_cursor);
4328 gdk_flush ();
4329
4330 for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ++r) {
4331 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*r);
4332 if (!arv)
4333 continue;
4334 XMLNode &before = arv->region()->get_state();
4335 arv->audio_region()->normalize_to (0.0f);
4336 session->add_command (new MementoCommand<Region>(*(arv->region().get()), &before, &arv->region()->get_state()));
4337 }
4338
4339 commit_reversible_command ();
4340 track_canvas->get_window()->set_cursor (*current_canvas_cursor);
4341 }
4342
4343
4344 void
4345 Editor::denormalize_region ()
4346 {
4347 if (!session) {
4348 return;
4349 }
4350
4351 RegionSelection rs;
4352
4353 get_regions_for_action (rs);
4354
4355 if (rs.empty()) {
4356 return;
4357 }
4358
4359 begin_reversible_command ("denormalize");
4360
4361 for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ++r) {
4362 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*r);
4363 if (!arv)
4364 continue;
4365 XMLNode &before = arv->region()->get_state();
4366 arv->audio_region()->set_scale_amplitude (1.0f);
4367 session->add_command (new MementoCommand<Region>(*(arv->region().get()), &before, &arv->region()->get_state()));
4368 }
4369
4370 commit_reversible_command ();
4371 }
4372
4373 void
4374 Editor::adjust_region_scale_amplitude (bool up)
4375 {
4376 if (!session) {
4377 return;
4378 }
4379
4380 RegionSelection rs;
4381
4382 get_regions_for_action (rs);
4383
4384 if (rs.empty()) {
4385 return;
4386 }
4387
4388 begin_reversible_command ("denormalize");
4389
4390 for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ++r) {
4391 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*r);
4392 if (!arv)
4393 continue;
4394 XMLNode &before = arv->region()->get_state();
4395
4396 double fraction = gain_to_slider_position (arv->audio_region()->scale_amplitude ());
4397
4398 if (up) {
4399 fraction += 0.05;
4400 fraction = min (fraction, 1.0);
4401 } else {
4402 fraction -= 0.05;
4403 fraction = max (fraction, 0.0);
4404 }
4405
4406 if (!up && fraction <= 0) {
4407 continue;
4408 }
4409
4410 fraction = slider_position_to_gain (fraction);
4411
4412 if (up && fraction >= 2.0) {
4413 continue;
4414 }
4415
4416 arv->audio_region()->set_scale_amplitude (fraction);
4417 session->add_command (new MementoCommand<Region>(*(arv->region().get()), &before, &arv->region()->get_state()));
4418 }
4419
4420 commit_reversible_command ();
4421 }
4422
4423
4424 void
4425 Editor::reverse_region ()
4426 {
4427 if (!session) {
4428 return;
4429 }
4430
4431 Reverse rev (*session);
4432 apply_filter (rev, _("reverse regions"));
4433 }
4434
4435 void
4436 Editor::apply_filter (AudioFilter& filter, string command)
4437 {
4438 RegionSelection rs;
4439
4440 get_regions_for_action (rs);
4441
4442 if (rs.empty()) {
4443 return;
4444 }
4445
4446 begin_reversible_command (command);
4447
4448 track_canvas->get_window()->set_cursor (*wait_cursor);
4449 gdk_flush ();
4450
4451 for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ) {
4452 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*r);
4453 if (!arv)
4454 continue;
4455
4456 boost::shared_ptr<Playlist> playlist = arv->region()->playlist();
4457
4458 RegionSelection::iterator tmp;
4459
4460 tmp = r;
4461 ++tmp;
4462
4463 if (arv->audio_region()->apply (filter) == 0) {
4464
4465 XMLNode &before = playlist->get_state();
4466 playlist->replace_region (arv->region(), filter.results.front(), arv->region()->position());
4467 XMLNode &after = playlist->get_state();
4468 session->add_command(new MementoCommand<Playlist>(*playlist, &before, &after));
4469 } else {
4470 goto out;
4471 }
4472
4473 r = tmp;
4474 }
4475
4476 commit_reversible_command ();
4477 rs.clear ();
4478
4479 out:
4480 track_canvas->get_window()->set_cursor (*current_canvas_cursor);
4481 }
4482
4483 void
4484 Editor::region_selection_op (void (Region::*pmf)(void))
4485 {
4486 for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
4487 Region* region = (*i)->region().get();
4488 (region->*pmf)();
4489 }
4490 }
4491
4492
4493 void
4494 Editor::region_selection_op (void (Region::*pmf)(void*), void *arg)
4495 {
4496 for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
4497 Region* region = (*i)->region().get();
4498 (region->*pmf)(arg);
4499 }
4500 }
4501
4502 void
4503 Editor::region_selection_op (void (Region::*pmf)(bool), bool yn)
4504 {
4505 for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
4506 Region* region = (*i)->region().get();
4507 (region->*pmf)(yn);
4508 }
4509 }
4510
4511 void
4512 Editor::external_edit_region ()
4513 {
4514 // XXX shouldn't this use get_regions_for_action(rs) too?
4515 if (!clicked_regionview) {
4516 return;
4517 }
4518
4519 /* more to come */
4520 }
4521
4522 void
4523 Editor::brush (nframes64_t pos)
4524 {
4525 RegionSelection sel;
4526 RegionSelection rs;
4527
4528 get_regions_for_action (rs);
4529
4530 snap_to (pos);
4531
4532 if (rs.empty()) {
4533 return;
4534 }
4535
4536 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
4537 mouse_brush_insert_region ((*i), pos);
4538 }
4539 }
4540
4541 void
4542 Editor::reset_region_gain_envelopes ()
4543 {
4544 RegionSelection rs;
4545
4546 get_regions_for_action (rs);
4547
4548 if (!session || rs.empty()) {
4549 return;
4550 }
4551
4552 session->begin_reversible_command (_("reset region gain"));
4553
4554 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
4555 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
4556 if (arv) {
4557 AutomationList& alist (arv->audio_region()->envelope());
4558 XMLNode& before (alist.get_state());
4559
4560 arv->audio_region()->set_default_envelope ();
4561 session->add_command (new MementoCommand<AutomationList>(arv->audio_region()->envelope(), &before, &alist.get_state()));
4562 }
4563 }
4564
4565 session->commit_reversible_command ();
4566 }
4567
4568 void
4569 Editor::toggle_gain_envelope_visibility ()
4570 {
4571 RegionSelection rs;
4572
4573 get_regions_for_action (rs);
4574
4575 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
4576 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
4577 if (arv) {
4578 arv->set_envelope_visible (!arv->envelope_visible());
4579 }
4580 }
4581 }
4582
4583 void
4584 Editor::toggle_gain_envelope_active ()
4585 {
4586 RegionSelection rs;
4587
4588 get_regions_for_action (rs);
4589
4590 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
4591 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
4592 if (arv) {
4593 arv->audio_region()->set_envelope_active (!arv->audio_region()->envelope_active());
4594 }
4595 }
4596 }
4597
4598 void
4599 Editor::toggle_region_lock ()
4600 {
4601 RegionSelection rs;
4602
4603 get_regions_for_action (rs);
4604
4605 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
4606 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
4607 if (arv) {
4608 arv->audio_region()->set_locked (!arv->audio_region()->locked());
4609 }
4610 }
4611 }
4612
4613 void
4614 Editor::set_region_lock_style (Region::PositionLockStyle ps)
4615 {
4616 RegionSelection rs;
4617
4618 get_regions_for_action (rs);
4619
4620 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
4621 (*i)->region()->set_position_lock_style (ps);
4622 }
4623 }
4624
4625
4626 void
4627 Editor::toggle_region_mute ()
4628 {
4629 RegionSelection rs;
4630
4631 get_regions_for_action (rs);
4632
4633 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
4634 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
4635 if (arv) {
4636 arv->audio_region()->set_muted (!arv->audio_region()->muted());
4637 }
4638 }
4639 }
4640
4641 void
4642 Editor::toggle_region_opaque ()
4643 {
4644 RegionSelection rs;
4645
4646 get_regions_for_action (rs);
4647
4648 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
4649 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
4650 if (arv) {
4651 arv->audio_region()->set_opaque (!arv->audio_region()->opaque());
4652 }
4653 }
4654 }
4655
4656 void
4657 Editor::toggle_record_enable ()
4658 {
4659 bool new_state = false;
4660 bool first = true;
4661 for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
4662 RouteTimeAxisView *rtav = dynamic_cast<RouteTimeAxisView *>(*i);
4663 if (!rtav)
4664 continue;
4665 if (!rtav->is_track())
4666 continue;
4667
4668 if (first) {
4669 new_state = !rtav->track()->record_enabled();
4670 first = false;
4671 }
4672
4673 rtav->track()->set_record_enable(new_state, this);
4674 }
4675 }
4676
4677
4678 void
4679 Editor::set_fade_length (bool in)
4680 {
4681 RegionSelection rs;
4682
4683 get_regions_for_action (rs);
4684
4685 /* we need a region to measure the offset from the start */
4686
4687 RegionView* rv;
4688
4689 if (!rs.empty()) {
4690 rv = rs.front();
4691 } else if (entered_regionview) {
4692 rv = entered_regionview;
4693 } else {
4694 return;
4695 }
4696
4697 nframes64_t pos = get_preferred_edit_position();
4698 nframes64_t len;
4699 char* cmd;
4700
4701 if (pos > rv->region()->last_frame() || pos < rv->region()->first_frame()) {
4702 /* edit point is outside the relevant region */
4703 return;
4704 }
4705
4706 if (in) {
4707 if (pos <= rv->region()->position()) {
4708 /* can't do it */
4709 return;
4710 }
4711 len = pos - rv->region()->position();
4712 cmd = _("set fade in length");
4713 } else {
4714 if (pos >= rv->region()->last_frame()) {
4715 /* can't do it */
4716 return;
4717 }
4718 len = rv->region()->last_frame() - pos;
4719 cmd = _("set fade out length");
4720 }
4721
4722 begin_reversible_command (cmd);
4723
4724 for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
4725 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*x);
4726
4727 if (!tmp) {
4728 return;
4729 }
4730
4731 AutomationList* alist;
4732 if (in) {
4733 alist = &tmp->audio_region()->fade_in();
4734 } else {
4735 alist = &tmp->audio_region()->fade_out();
4736 }
4737
4738 XMLNode &before = alist->get_state();
4739
4740 if (in) {
4741 tmp->audio_region()->set_fade_in_length (len);
4742 tmp->audio_region()->set_fade_in_active (true);
4743 } else {
4744 tmp->audio_region()->set_fade_out_length (len);
4745 tmp->audio_region()->set_fade_out_active (true);
4746 }
4747
4748 XMLNode &after = alist->get_state();
4749 session->add_command(new MementoCommand<AutomationList>(*alist, &before, &after));
4750 }
4751
4752 commit_reversible_command ();
4753 }
4754
4755
4756 void
4757 Editor::toggle_fade_active (bool in)
4758 {
4759 RegionSelection rs;
4760
4761 get_regions_for_action (rs);
4762
4763 if (rs.empty()) {
4764 return;
4765 }
4766
4767 const char* cmd = (in ? _("toggle fade in active") : _("toggle fade out active"));
4768 bool have_switch = false;
4769 bool yn = false;
4770
4771 begin_reversible_command (cmd);
4772
4773 for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
4774 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*x);
4775
4776 if (!tmp) {
4777 return;
4778 }
4779
4780 boost::shared_ptr<AudioRegion> region (tmp->audio_region());
4781
4782 /* make the behaviour consistent across all regions */
4783
4784 if (!have_switch) {
4785 if (in) {
4786 yn = region->fade_in_active();
4787 } else {
4788 yn = region->fade_out_active();
4789 }
4790 have_switch = true;
4791 }
4792
4793 XMLNode &before = region->get_state();
4794 if (in) {
4795 region->set_fade_in_active (!yn);
4796 } else {
4797 region->set_fade_out_active (!yn);
4798 }
4799 XMLNode &after = region->get_state();
4800 session->add_command(new MementoCommand<AudioRegion>(*region.get(), &before, &after));
4801 }
4802
4803 commit_reversible_command ();
4804 }
4805
4806 void
4807 Editor::set_fade_in_shape (AudioRegion::FadeShape shape)
4808 {
4809 RegionSelection rs;
4810
4811 get_regions_for_action (rs);
4812
4813 if (rs.empty()) {
4814 return;
4815 }
4816
4817 begin_reversible_command (_("set fade in shape"));
4818
4819 for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
4820 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*x);
4821
4822 if (!tmp) {
4823 return;
4824 }
4825
4826 AutomationList& alist = tmp->audio_region()->fade_in();
4827 XMLNode &before = alist.get_state();
4828
4829 tmp->audio_region()->set_fade_in_shape (shape);
4830
4831 XMLNode &after = alist.get_state();
4832 session->add_command(new MementoCommand<AutomationList>(alist, &before, &after));
4833 }
4834
4835 commit_reversible_command ();
4836
4837 }
4838
4839 void
4840 Editor::set_fade_out_shape (AudioRegion::FadeShape shape)
4841 {
4842 RegionSelection rs;
4843
4844 get_regions_for_action (rs);
4845
4846 if (rs.empty()) {
4847 return;
4848 }
4849
4850 begin_reversible_command (_("set fade out shape"));
4851
4852 for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
4853 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*x);
4854
4855 if (!tmp) {
4856 return;
4857 }
4858
4859 AutomationList& alist = tmp->audio_region()->fade_out();
4860 XMLNode &before = alist.get_state();
4861
4862 tmp->audio_region()->set_fade_out_shape (shape);
4863
4864 XMLNode &after = alist.get_state();
4865 session->add_command(new MementoCommand<AutomationList>(alist, &before, &after));
4866 }
4867
4868 commit_reversible_command ();
4869 }
4870
4871 void
4872 Editor::set_fade_in_active (bool yn)
4873 {
4874 RegionSelection rs;
4875
4876 get_regions_for_action (rs);
4877
4878 if (rs.empty()) {
4879 return;
4880 }
4881
4882 begin_reversible_command (_("set fade in active"));
4883
4884 for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
4885 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*x);
4886
4887 if (!tmp) {
4888 return;
4889 }
4890
4891
4892 boost::shared_ptr<AudioRegion> ar (tmp->audio_region());
4893
4894 XMLNode &before = ar->get_state();
4895
4896 ar->set_fade_in_active (yn);
4897
4898 XMLNode &after = ar->get_state();
4899 session->add_command(new MementoCommand<AudioRegion>(*ar, &before, &after));
4900 }
4901
4902 commit_reversible_command ();
4903 }
4904
4905 void
4906 Editor::set_fade_out_active (bool yn)
4907 {
4908 RegionSelection rs;
4909
4910 get_regions_for_action (rs);
4911
4912 if (rs.empty()) {
4913 return;
4914 }
4915
4916 begin_reversible_command (_("set fade out active"));
4917
4918 for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
4919 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*x);
4920
4921 if (!tmp) {
4922 return;
4923 }
4924
4925 boost::shared_ptr<AudioRegion> ar (tmp->audio_region());
4926
4927 XMLNode &before = ar->get_state();
4928
4929 ar->set_fade_out_active (yn);
4930
4931 XMLNode &after = ar->get_state();
4932 session->add_command(new MementoCommand<AudioRegion>(*ar, &before, &after));
4933 }
4934
4935 commit_reversible_command ();
4936 }
4937
4938 void
4939 Editor::toggle_selected_region_fades (int dir)
4940 {
4941 RegionSelection rs;
4942 RegionSelection::iterator i;
4943 boost::shared_ptr<AudioRegion> ar;
4944 bool yn;
4945
4946 get_regions_for_action (rs);
4947
4948 if (rs.empty()) {
4949 return;
4950 }
4951
4952 for (i = rs.begin(); i != rs.end(); ++i) {
4953 if ((ar = boost::dynamic_pointer_cast<AudioRegion>((*i)->region())) != 0) {
4954 if (dir == -1) {
4955 yn = ar->fade_out_active ();
4956 } else {
4957 yn = ar->fade_in_active ();
4958 }
4959 break;
4960 }
4961 }
4962
4963 if (i == rs.end()) {
4964 return;
4965 }
4966
4967 /* XXX should this undo-able? */
4968
4969 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
4970 if ((ar = boost::dynamic_pointer_cast<AudioRegion>((*i)->region())) == 0) {
4971 continue;
4972 }
4973 if (dir == 1 || dir == 0) {
4974 ar->set_fade_in_active (!yn);
4975 }
4976
4977 if (dir == -1 || dir == 0) {
4978 ar->set_fade_out_active (!yn);
4979 }
4980 }
4981 }
4982
4983
4984 /** Update region fade visibility after its configuration has been changed */
4985 void
4986 Editor::update_region_fade_visibility ()
4987 {
4988 bool _fade_visibility = Config->get_show_region_fades ();
4989
4990 for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
4991 AudioTimeAxisView* v = dynamic_cast<AudioTimeAxisView*>(*i);
4992 if (v) {
4993 if (_fade_visibility) {
4994 v->audio_view()->show_all_fades ();
4995 } else {
4996 v->audio_view()->hide_all_fades ();
4997 }
4998 }
4999 }
5000 }
5001
5002 /** Update crossfade visibility after its configuration has been changed */
5003 void
5004 Editor::update_xfade_visibility ()
5005 {
5006 _xfade_visibility = Config->get_xfades_visible ();
5007
5008 for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
5009 AudioTimeAxisView* v = dynamic_cast<AudioTimeAxisView*>(*i);
5010 if (v) {
5011 if (_xfade_visibility) {
5012 v->show_all_xfades ();
5013 } else {
5014 v->hide_all_xfades ();
5015 }
5016 }
5017 }
5018 }
5019
5020 void
5021 Editor::set_edit_point ()
5022 {
5023 nframes64_t where;
5024 bool ignored;
5025
5026 if (!mouse_frame (where, ignored)) {
5027 return;
5028 }
5029
5030 snap_to (where);
5031
5032 if (selection->markers.empty()) {
5033
5034 mouse_add_new_marker (where);
5035
5036 } else {
5037 bool ignored;
5038
5039 Location* loc = find_location_from_marker (selection->markers.front(), ignored);
5040
5041 if (loc) {
5042 loc->move_to (where);
5043 }
5044 }
5045 }
5046
5047 void
5048 Editor::set_playhead_cursor ()
5049 {
5050 if (entered_marker) {
5051 session->request_locate (entered_marker->position(), session->transport_rolling());
5052 } else {
5053 nframes64_t where;
5054 bool ignored;
5055
5056 if (!mouse_frame (where, ignored)) {
5057 return;
5058 }
5059
5060 snap_to (where);
5061
5062 if (session) {
5063 session->request_locate (where, session->transport_rolling());
5064 }
5065 }
5066 }
5067
5068 void
5069 Editor::split ()
5070 {
5071 RegionSelection rs;
5072
5073 get_regions_for_action (rs);
5074
5075 nframes64_t where = get_preferred_edit_position();
5076
5077 if (rs.empty()) {
5078 return;
5079 }
5080
5081 split_regions_at (where, rs);
5082 }
5083
5084 void
5085 Editor::ensure_entered_track_selected (bool op_really_wants_one_track_if_none_are_selected)
5086 {
5087 if (entered_track && mouse_mode == MouseObject) {
5088 if (!selection->tracks.empty()) {
5089 if (!selection->selected (entered_track)) {
5090 selection->add (entered_track);
5091 }
5092 } else {
5093 /* there is no selection, but this operation requires/prefers selected objects */
5094
5095 if (op_really_wants_one_track_if_none_are_selected) {
5096 selection->set (entered_track);
5097 }
5098 }
5099 }
5100 }
5101
5102 void
5103 Editor::trim_region_front ()
5104 {
5105 trim_region (true);
5106 }
5107
5108 void
5109 Editor::trim_region_back ()
5110 {
5111 trim_region (false);
5112 }
5113
5114 void
5115 Editor::trim_region (bool front)
5116 {
5117 nframes64_t where = get_preferred_edit_position();
5118 RegionSelection rs;
5119
5120 get_regions_for_action (rs);
5121
5122 if (rs.empty()) {
5123 return;
5124 }
5125
5126 begin_reversible_command (front ? _("trim front") : _("trim back"));
5127
5128 for (list<RegionView*>::const_iterator i = rs.by_layer().begin(); i != rs.by_layer().end(); ++i) {
5129 if (!(*i)->region()->locked()) {
5130 boost::shared_ptr<Playlist> pl = (*i)->region()->playlist();
5131 XMLNode &before = pl->get_state();
5132 if (front) {
5133 (*i)->region()->trim_front (where, this);
5134 } else {
5135 (*i)->region()->trim_end (where, this);
5136 }
5137 XMLNode &after = pl->get_state();
5138 session->add_command(new MementoCommand<Playlist>(*pl.get(), &before, &after));
5139 }
5140 }
5141
5142 commit_reversible_command ();
5143 }
5144
5145 struct EditorOrderRouteSorter {
5146 bool operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b) {
5147 /* use of ">" forces the correct sort order */
5148 return a->order_key ("editor") < b->order_key ("editor");
5149 }
5150 };
5151
5152 void
5153 Editor::select_next_route()
5154 {
5155 if (selection->tracks.empty()) {
5156 selection->set (track_views.front());
5157 return;
5158 }
5159
5160 TimeAxisView* current = selection->tracks.front();
5161
5162 RouteUI *rui;
5163 do {
5164 for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
5165 if (*i == current) {
5166 ++i;
5167 if (i != track_views.end()) {
5168 current = (*i);
5169 } else {
5170 current = (*(track_views.begin()));
5171 //selection->set (*(track_views.begin()));
5172 }
5173 break;
5174 }
5175 }
5176 rui = dynamic_cast<RouteUI *>(current);
5177 } while ( current->hidden() || (rui != NULL && !rui->route()->active()));
5178
5179 selection->set(current);
5180
5181 ensure_track_visible(current);
5182 }
5183
5184 void
5185 Editor::select_prev_route()
5186 {
5187 if (selection->tracks.empty()) {
5188 selection->set (track_views.front());
5189 return;
5190 }
5191
5192 TimeAxisView* current = selection->tracks.front();
5193
5194 RouteUI *rui;
5195 do {
5196 for (TrackViewList::reverse_iterator i = track_views.rbegin(); i != track_views.rend(); ++i) {
5197 if (*i == current) {
5198 ++i;
5199 if (i != track_views.rend()) {
5200 current = (*i);
5201 } else {
5202 current = *(track_views.rbegin());
5203 }
5204 break;
5205 }
5206 }
5207 rui = dynamic_cast<RouteUI *>(current);
5208 } while ( current->hidden() || (rui != NULL && !rui->route()->active()));
5209
5210 selection->set (current);
5211
5212 ensure_track_visible(current);
5213 }
5214
5215 void
5216 Editor::ensure_track_visible(TimeAxisView *track)
5217 {
5218 if (track->hidden())
5219 return;
5220
5221 double current_view_min_y = vertical_adjustment.get_value();
5222 double current_view_max_y = vertical_adjustment.get_value() + vertical_adjustment.get_page_size() - canvas_timebars_vsize;
5223
5224 double track_min_y = track->y_position;
5225 double track_max_y = track->y_position + (double)track->effective_height;
5226
5227 if (track_min_y >= current_view_min_y &&
5228 track_max_y <= current_view_max_y) {
5229 return;
5230 }
5231
5232 double new_value;
5233
5234 if (track_min_y < current_view_min_y) {
5235 // Track is above the current view
5236 new_value = track_min_y;
5237 } else {
5238 // Track is below the current view
5239 new_value = track->y_position + (double)track->effective_height + canvas_timebars_vsize - vertical_adjustment.get_page_size();
5240 }
5241
5242 vertical_adjustment.set_value(new_value);
5243 }
5244
5245 void
5246 Editor::set_loop_from_selection (bool play)
5247 {
5248 if (session == 0 || selection->time.empty()) {
5249 return;
5250 }
5251
5252 nframes64_t start = selection->time[clicked_selection].start;
5253 nframes64_t end = selection->time[clicked_selection].end;
5254
5255 set_loop_range (start, end, _("set loop range from selection"));
5256
5257 if (play) {
5258 session->request_play_loop (true);
5259 session->request_locate (start, true);
5260 }
5261 }
5262
5263 void
5264 Editor::set_loop_from_edit_range (bool play)
5265 {
5266 if (session == 0) {
5267 return;
5268 }
5269
5270 nframes64_t start;
5271 nframes64_t end;
5272
5273 if (!get_edit_op_range (start, end)) {
5274 return;
5275 }
5276
5277 set_loop_range (start, end, _("set loop range from edit range"));
5278
5279 if (play) {
5280 session->request_play_loop (true);
5281 session->request_locate (start, true);
5282 }
5283 }
5284
5285 void
5286 Editor::set_loop_from_region (bool play)
5287 {
5288 nframes64_t start = max_frames;
5289 nframes64_t end = 0;
5290
5291 RegionSelection rs;
5292
5293 get_regions_for_action (rs);
5294
5295 if (rs.empty()) {
5296 return;
5297 }
5298
5299 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
5300 if ((*i)->region()->position() < start) {
5301 start = (*i)->region()->position();
5302 }
5303 if ((*i)->region()->last_frame() + 1 > end) {
5304 end = (*i)->region()->last_frame() + 1;
5305 }
5306 }
5307
5308 set_loop_range (start, end, _("set loop range from region"));
5309
5310 if (play) {
5311 session->request_play_loop (true);
5312 session->request_locate (start, true);
5313 }
5314 }
5315
5316 void
5317 Editor::set_punch_from_selection ()
5318 {
5319 if (session == 0 || selection->time.empty()) {
5320 return;
5321 }
5322
5323 nframes64_t start = selection->time[clicked_selection].start;
5324 nframes64_t end = selection->time[clicked_selection].end;
5325
5326 set_punch_range (start, end, _("set punch range from selection"));
5327 }
5328
5329 void
5330 Editor::set_punch_from_edit_range ()
5331 {
5332 if (session == 0) {
5333 return;
5334 }
5335
5336 nframes64_t start;
5337 nframes64_t end;
5338
5339 if (!get_edit_op_range (start, end)) {
5340 return;
5341 }
5342
5343 set_punch_range (start, end, _("set punch range from edit range"));
5344 }
5345
5346 void
5347 Editor::set_punch_from_region ()
5348 {
5349 nframes64_t start = max_frames;
5350 nframes64_t end = 0;
5351
5352 RegionSelection rs;
5353
5354 get_regions_for_action (rs);
5355
5356 if (rs.empty()) {
5357 return;
5358 }
5359
5360 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
5361 if ((*i)->region()->position() < start) {
5362 start = (*i)->region()->position();
5363 }
5364 if ((*i)->region()->last_frame() + 1 > end) {
5365 end = (*i)->region()->last_frame() + 1;
5366 }
5367 }
5368
5369 set_punch_range (start, end, _("set punch range from region"));
5370 }
5371
5372 void
5373 Editor::pitch_shift_regions ()
5374 {
5375 RegionSelection rs;
5376
5377 get_regions_for_action (rs);
5378
5379 if (rs.empty()) {
5380 return;
5381 }
5382
5383 pitch_shift (rs, 1.2);
5384 }
5385
5386 void
5387 Editor::use_region_as_bar ()
5388 {
5389 if (!session) {
5390 return;
5391 }
5392
5393 RegionSelection rs;
5394
5395 get_regions_for_action (rs);
5396
5397 if (rs.empty()) {
5398 return;
5399 }
5400
5401 RegionView* rv = rs.front();
5402
5403 define_one_bar (rv->region()->position(), rv->region()->last_frame() + 1);
5404 }
5405
5406 void
5407 Editor::use_range_as_bar ()
5408 {
5409 nframes64_t start, end;
5410 if (get_edit_op_range (start, end)) {
5411 define_one_bar (start, end);
5412 }
5413 }
5414
5415 void
5416 Editor::define_one_bar (nframes64_t start, nframes64_t end)
5417 {
5418 nframes64_t length = end - start;
5419
5420 const Meter& m (session->tempo_map().meter_at (start));
5421
5422 /* length = 1 bar */
5423
5424 /* now we want frames per beat.
5425 we have frames per bar, and beats per bar, so ...
5426 */
5427
5428 double frames_per_beat = length / m.beats_per_bar();
5429
5430 /* beats per minute = */
5431
5432 double beats_per_minute = (session->frame_rate() * 60.0) / frames_per_beat;
5433
5434 /* now decide whether to:
5435
5436 (a) set global tempo
5437 (b) add a new tempo marker
5438
5439 */
5440
5441 const TempoSection& t (session->tempo_map().tempo_section_at (start));
5442
5443 bool do_global = false;
5444
5445 if ((session->tempo_map().n_tempos() == 1) && (session->tempo_map().n_meters() == 1)) {
5446
5447 /* only 1 tempo & 1 meter: ask if the user wants to set the tempo
5448 at the start, or create a new marker
5449 */
5450
5451 vector<string> options;
5452 options.push_back (_("Cancel"));
5453 options.push_back (_("Add new marker"));
5454 options.push_back (_("Set global tempo"));
5455 Choice c (_("Do you want to set the global tempo or add new tempo marker?"),
5456 options);
5457 c.set_default_response (2);
5458
5459 switch (c.run()) {
5460 case 0:
5461 return;
5462
5463 case 2:
5464 do_global = true;
5465 break;
5466
5467 default:
5468 do_global = false;
5469 }
5470
5471 } else {
5472
5473 /* more than 1 tempo and/or meter section already, go ahead do the "usual":
5474 if the marker is at the region starter, change it, otherwise add
5475 a new tempo marker
5476 */
5477 }
5478
5479 begin_reversible_command (_("set tempo from region"));
5480 XMLNode& before (session->tempo_map().get_state());
5481
5482 if (do_global) {
5483 session->tempo_map().change_initial_tempo (beats_per_minute, t.note_type());
5484 } else if (t.frame() == start) {
5485 session->tempo_map().change_existing_tempo_at (start, beats_per_minute, t.note_type());
5486 } else {
5487 session->tempo_map().add_tempo (Tempo (beats_per_minute, t.note_type()), start);
5488 }
5489
5490 XMLNode& after (session->tempo_map().get_state());
5491
5492 session->add_command (new MementoCommand<TempoMap>(session->tempo_map(), &before, &after));
5493 commit_reversible_command ();
5494 }
5495
5496 void
5497 Editor::split_region_at_transients ()
5498 {
5499 AnalysisFeatureList positions;
5500
5501 if (!session) {
5502 return;
5503 }
5504
5505 RegionSelection rs;
5506
5507 get_regions_for_action (rs);
5508
5509 if (rs.empty()) {
5510 return;
5511 }
5512
5513 session->begin_reversible_command (_("split regions"));
5514
5515 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ) {
5516
5517 RegionSelection::iterator tmp;
5518
5519 tmp = i;
5520 ++tmp;
5521
5522 boost::shared_ptr<AudioRegion> ar = boost::dynamic_pointer_cast<AudioRegion> ((*i)->region());
5523
5524 if (ar && (ar->get_transients (positions) == 0)) {
5525 split_region_at_points ((*i)->region(), positions, true);
5526 positions.clear ();
5527 }
5528
5529 i = tmp;
5530 }
5531
5532 session->commit_reversible_command ();
5533
5534 }
5535
5536 void
5537 Editor::split_region_at_points (boost::shared_ptr<Region> r, AnalysisFeatureList& positions, bool can_ferret)
5538 {
5539 boost::shared_ptr<AudioRegion> ar = boost::dynamic_pointer_cast<AudioRegion> (r);
5540 bool use_rhythmic_rodent = false;
5541
5542 if (!ar) {
5543 return;
5544 }
5545
5546 boost::shared_ptr<Playlist> pl = ar->playlist();
5547
5548 if (!pl) {
5549 return;
5550 }
5551
5552 if (positions.empty()) {
5553 return;
5554 }
5555
5556
5557 if (positions.size() > 20) {
5558 Glib::ustring msgstr = string_compose (_("You are about to split\n%1\ninto %2 pieces.\nThis could take a long time."), ar->name(), positions.size() + 1);
5559 MessageDialog msg (msgstr,
5560 false,
5561 Gtk::MESSAGE_INFO,
5562 Gtk::BUTTONS_OK_CANCEL);
5563
5564 if (can_ferret) {
5565 msg.add_button (_("Call for the Ferret!"), RESPONSE_APPLY);
5566 msg.set_secondary_text (_("Press OK to continue with this split operation\nor ask the Ferret dialog to tune the analysis"));
5567 } else {
5568 msg.set_secondary_text (_("Press OK to continue with this split operation"));
5569 }
5570
5571 msg.set_title (_("Excessive split?"));
5572 msg.present ();
5573
5574 int response = msg.run();
5575 msg.hide ();
5576 switch (response) {
5577 case RESPONSE_OK:
5578 break;
5579 case RESPONSE_APPLY:
5580 use_rhythmic_rodent = true;
5581 break;
5582 default:
5583 return;
5584 }
5585 }
5586
5587 if (use_rhythmic_rodent) {
5588 show_rhythm_ferret ();
5589 return;
5590 }
5591
5592 AnalysisFeatureList::const_iterator x;
5593
5594 nframes64_t pos = ar->position();
5595
5596 XMLNode& before (pl->get_state());
5597
5598 x = positions.begin();
5599
5600 while (x != positions.end()) {
5601 if ((*x) > pos) {
5602 break;
5603 }
5604 ++x;
5605 }
5606
5607 if (x == positions.end()) {
5608 return;
5609 }
5610
5611 pl->freeze ();
5612 pl->remove_region (ar);
5613
5614 while (x != positions.end()) {
5615
5616 /* file start = original start + how far we from the initial position ?
5617 */
5618
5619 nframes64_t file_start = ar->start() + (pos - ar->position());
5620
5621 /* length = next position - current position
5622 */
5623
5624 nframes64_t len = (*x) - pos;
5625
5626 /* XXX we do we really want to allow even single-sample regions?
5627 shouldn't we have some kind of lower limit on region size?
5628 */
5629
5630 if (len <= 0) {
5631 break;
5632 }
5633
5634 string new_name;
5635
5636 if (session->region_name (new_name, ar->name())) {
5637 break;
5638 }
5639
5640 /* do NOT announce new regions 1 by one, just wait till they are all done */
5641
5642 boost::shared_ptr<Region> r = RegionFactory::create (ar->get_sources(), file_start, len, new_name, 0, Region::DefaultFlags, false);
5643 pl->add_region (r, pos);
5644
5645 pos += len;
5646 ++x;
5647
5648 if (*x > ar->last_frame()) {
5649
5650 /* add final fragment */
5651
5652 file_start = ar->start() + (pos - ar->position());
5653 len = ar->last_frame() - pos;
5654
5655 boost::shared_ptr<Region> r = RegionFactory::create (ar->get_sources(), file_start, len, new_name, 0, Region::DefaultFlags);
5656 pl->add_region (r, pos);
5657
5658 break;
5659 }
5660 }
5661
5662 pl->thaw ();
5663
5664 XMLNode& after (pl->get_state());
5665
5666 session->add_command (new MementoCommand<Playlist>(*pl, &before, &after));
5667 }
5668
5669 void
5670 Editor::tab_to_transient (bool forward)
5671 {
5672 AnalysisFeatureList positions;
5673
5674 if (!session) {
5675 return;
5676 }
5677
5678 nframes64_t pos = session->audible_frame ();
5679
5680 if (!selection->tracks.empty()) {
5681
5682 for (TrackSelection::iterator t = selection->tracks.begin(); t != selection->tracks.end(); ++t) {
5683
5684 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*t);
5685
5686 if (rtv) {
5687 boost::shared_ptr<Diskstream> ds = rtv->get_diskstream();
5688 if (ds) {
5689 boost::shared_ptr<Playlist> pl = rtv->get_diskstream()->playlist ();
5690 if (pl) {
5691 nframes64_t result = pl->find_next_transient (pos, forward ? 1 : -1);
5692
5693 if (result >= 0) {
5694 positions.push_back (result);
5695 }
5696 }
5697 }
5698 }
5699 }
5700
5701 } else {
5702
5703 RegionSelection rs;
5704
5705 get_regions_for_action (rs);
5706
5707 if (rs.empty()) {
5708 return;
5709 }
5710
5711 for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ++r) {
5712 (*r)->region()->get_transients (positions);
5713 }
5714 }
5715
5716 TransientDetector::cleanup_transients (positions, session->frame_rate(), 3.0);
5717
5718 if (forward) {
5719 AnalysisFeatureList::iterator x;
5720
5721 for (x = positions.begin(); x != positions.end(); ++x) {
5722 if ((*x) > pos) {
5723 break;
5724 }
5725 }
5726
5727 if (x != positions.end ()) {
5728 session->request_locate (*x);
5729 }
5730
5731 } else {
5732 AnalysisFeatureList::reverse_iterator x;
5733
5734 for (x = positions.rbegin(); x != positions.rend(); ++x) {
5735 if ((*x) < pos) {
5736 break;
5737 }
5738 }
5739
5740 if (x != positions.rend ()) {
5741 session->request_locate (*x);
5742 }
5743 }
5744 }
5745
5746 void
5747 Editor::playhead_forward_to_grid ()
5748 {
5749 if (!session) return;
5750 nframes64_t pos = playhead_cursor->current_frame;
5751 if (pos < max_frames - 1) {
5752 pos += 2;
5753 snap_to_internal (pos, 1, false);
5754 session->request_locate (pos);
5755 }
5756 }
5757
5758
5759 void
5760 Editor::playhead_backward_to_grid ()
5761 {
5762 if (!session) return;
5763 nframes64_t pos = playhead_cursor->current_frame;
5764 if (pos > 2) {
5765 pos -= 2;
5766 snap_to_internal (pos, -1, false);
5767 session->request_locate (pos);
5768 }
5769 }
5770
5771 void
5772 Editor::set_track_height (uint32_t h)
5773 {
5774 TrackSelection& ts (selection->tracks);
5775
5776 if (ts.empty()) {
5777 return;
5778 }
5779
5780 for (TrackSelection::iterator x = ts.begin(); x != ts.end(); ++x) {
5781 (*x)->set_height (h);
5782 }
5783 }
5784
5785 void
5786 Editor::set_track_height_largest ()
5787 {
5788 set_track_height (TimeAxisView::hLargest);
5789 }
5790 void
5791 Editor::set_track_height_large ()
5792 {
5793 set_track_height (TimeAxisView::hLarge);
5794 }
5795 void
5796 Editor::set_track_height_larger ()
5797 {
5798 set_track_height (TimeAxisView::hLarger);
5799 }
5800 void
5801 Editor::set_track_height_normal ()
5802 {
5803 set_track_height (TimeAxisView::hNormal);
5804 }
5805 void
5806 Editor::set_track_height_smaller ()
5807 {
5808 set_track_height (TimeAxisView::hSmaller);
5809 }
5810 void
5811 Editor::set_track_height_small ()
5812 {
5813 set_track_height (TimeAxisView::hSmall);
5814 }
5815
5816 void
5817 Editor::toggle_tracks_active ()
5818 {
5819 TrackSelection& ts (selection->tracks);
5820 bool first = true;
5821 bool target = false;
5822
5823 if (ts.empty()) {
5824 return;
5825 }
5826
5827 for (TrackSelection::iterator x = ts.begin(); x != ts.end(); ++x) {
5828 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*>(*x);
5829
5830 if (rtv) {
5831 if (first) {
5832 target = !rtv->_route->active();
5833 first = false;
5834 }
5835 rtv->_route->set_active (target);
5836 }
5837 }
5838 }
5839
5840 void
5841 Editor::remove_tracks ()
5842 {
5843 TrackSelection& ts (selection->tracks);
5844
5845 if (ts.empty()) {
5846 return;
5847 }
5848
5849 vector<string> choices;
5850 string prompt;
5851 int ntracks = 0;
5852 int nbusses = 0;
5853 const char* trackstr;
5854 const char* busstr;
5855 vector<boost::shared_ptr<Route> > routes;
5856
5857 for (TrackSelection::iterator x = ts.begin(); x != ts.end(); ++x) {
5858 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*x);
5859 if (rtv) {
5860 if (rtv->is_track()) {
5861 ntracks++;
5862 } else {
5863 nbusses++;
5864 }
5865 }
5866 routes.push_back (rtv->_route);
5867 }
5868
5869 if (ntracks + nbusses == 0) {
5870 return;
5871 }
5872
5873 if (ntracks > 1) {
5874 trackstr = _("tracks");
5875 } else {
5876 trackstr = _("track");
5877 }
5878
5879 if (nbusses > 1) {
5880 busstr = _("busses");
5881 } else {
5882 busstr = _("bus");
5883 }
5884
5885 if (ntracks) {
5886 if (nbusses) {
5887 prompt = string_compose (_("Do you really want to remove %1 %2 and %3 %4?\n"
5888 "(You may also lose the playlists associated with the %2)\n\n"
5889 "This action cannot be undone!"),
5890 ntracks, trackstr, nbusses, busstr);
5891 } else {
5892 prompt = string_compose (_("Do you really want to remove %1 %2?\n"
5893 "(You may also lose the playlists associated with the %2)\n\n"
5894 "This action cannot be undone!"),
5895 ntracks, trackstr);
5896 }
5897 } else if (nbusses) {
5898 prompt = string_compose (_("Do you really want to remove %1 %2?"),
5899 nbusses, busstr);
5900 }
5901
5902 choices.push_back (_("No, do nothing."));
5903 if (ntracks + nbusses > 1) {
5904 choices.push_back (_("Yes, remove them."));
5905 } else {
5906 choices.push_back (_("Yes, remove it."));
5907 }
5908
5909 Choice prompter (prompt, choices);
5910
5911 if (prompter.run () != 1) {
5912 return;
5913 }
5914
5915 for (vector<boost::shared_ptr<Route> >::iterator x = routes.begin(); x != routes.end(); ++x) {
5916 session->remove_route (*x);
5917 }
5918 }
5919
5920 void
5921 Editor::set_waveform_scale (WaveformScale ws)
5922 {
5923 TrackSelection& ts (selection->tracks);
5924
5925 if (ts.empty()) {
5926 return;
5927 }
5928
5929 for (TrackSelection::iterator x = ts.begin(); x != ts.end(); ++x) {
5930 AudioTimeAxisView* atv = dynamic_cast<AudioTimeAxisView*> (*x);
5931 if (atv) {
5932 atv->set_waveform_scale (ws);
5933 }
5934 }
5935 }
5936
5937 void
5938 Editor::do_insert_time ()
5939 {
5940 if (selection->tracks.empty()) {
5941 return;
5942 }
5943
5944 nframes64_t pos = get_preferred_edit_position ();
5945 ArdourDialog d (*this, _("Insert Time"));
5946 VButtonBox button_box;
5947 VBox option_box;
5948 RadioButtonGroup group;
5949 RadioButton leave_button (group, _("Stay in position"));
5950 RadioButton move_button (group, _("Move"));
5951 RadioButton split_button (group, _("Split & Later Section Moves"));
5952 Label intersect_option_label (_("Intersected regions should:"));
5953 CheckButton glue_button (_("Move Glued Regions"));
5954 CheckButton marker_button (_("Move Markers"));
5955 CheckButton tempo_button (_("Move Tempo & Meters"));
5956 AudioClock clock ("insertTimeClock", true, X_("InsertTimeClock"), true, true, true);
5957 HBox clock_box;
5958
5959 clock.set (0);
5960 clock.set_session (session);
5961 clock.set_bbt_reference (pos);
5962
5963 clock_box.pack_start (clock, false, true);
5964
5965 option_box.set_spacing (6);
5966 option_box.pack_start (intersect_option_label, false, false);
5967 option_box.pack_start (button_box, false, false);
5968 option_box.pack_start (glue_button, false, false);
5969 option_box.pack_start (marker_button, false, false);
5970 option_box.pack_start (tempo_button, false, false);
5971
5972 button_box.pack_start (leave_button, false, false);
5973 button_box.pack_start (move_button, false, false);
5974 button_box.pack_start (split_button, false, false);
5975
5976 d.get_vbox()->set_border_width (12);
5977 d.get_vbox()->pack_start (clock_box, false, false);
5978 d.get_vbox()->pack_start (option_box, false, false);
5979
5980 leave_button.show ();
5981 move_button.show ();
5982 split_button.show ();
5983 intersect_option_label.show ();
5984 option_box.show ();
5985 button_box.show ();
5986 glue_button.show ();
5987 clock.show_all();
5988 clock_box.show ();
5989 marker_button.show ();
5990 tempo_button.show ();
5991
5992 d.add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
5993 d.add_button (Gtk::Stock::OK, Gtk::RESPONSE_OK);
5994 d.show ();
5995
5996 int response = d.run ();
5997
5998 if (response != RESPONSE_OK) {
5999 return;
6000 }
6001
6002 nframes64_t distance = clock.current_duration (pos);
6003
6004 if (distance == 0) {
6005 return;
6006 }
6007
6008 InsertTimeOption opt;
6009
6010 if (leave_button.get_active()) {
6011 opt = LeaveIntersected;
6012 } else if (move_button.get_active()) {
6013 opt = MoveIntersected;
6014 } else {
6015 opt = SplitIntersected;
6016 }
6017
6018 insert_time (pos, distance, opt, glue_button.get_active(), marker_button.get_active(), tempo_button.get_active());
6019 }
6020
6021 void
6022 Editor::insert_time (nframes64_t pos, nframes64_t frames, InsertTimeOption opt,
6023 bool ignore_music_glue, bool markers_too, bool tempo_too)
6024 {
6025 bool commit = false;
6026
6027 if (Config->get_edit_mode() == Lock) {
6028 return;
6029 }
6030
6031 begin_reversible_command (_("insert time"));
6032
6033 for (TrackSelection::iterator x = selection->tracks.begin(); x != selection->tracks.end(); ++x) {
6034 /* regions */
6035 boost::shared_ptr<Playlist> pl = (*x)->playlist();
6036
6037 if (pl) {
6038
6039 XMLNode &before = pl->get_state();
6040
6041 if (opt == SplitIntersected) {
6042 pl->split (pos);
6043 }
6044
6045 pl->shift (pos, frames, (opt == MoveIntersected), ignore_music_glue);
6046
6047 XMLNode &after = pl->get_state();
6048
6049 session->add_command (new MementoCommand<Playlist> (*pl, &before, &after));
6050 commit = true;
6051 }
6052
6053 /* automation */
6054 RouteTimeAxisView* rtav = dynamic_cast<RouteTimeAxisView*> (*x);
6055 if (rtav) {
6056 rtav->route ()->shift (pos, frames);
6057 commit = true;
6058 }
6059 }
6060
6061 /* markers */
6062 if (markers_too) {
6063 bool moved = false;
6064 XMLNode& before (session->locations()->get_state());
6065 Locations::LocationList copy (session->locations()->list());
6066
6067 for (Locations::LocationList::iterator i = copy.begin(); i != copy.end(); ++i) {
6068
6069 Locations::LocationList::const_iterator tmp;
6070
6071 if ((*i)->start() >= pos) {
6072 (*i)->set_start ((*i)->start() + frames);
6073 if (!(*i)->is_mark()) {
6074 (*i)->set_end ((*i)->end() + frames);
6075 }
6076 moved = true;
6077 }
6078 }
6079
6080 if (moved) {
6081 XMLNode& after (session->locations()->get_state());
6082 session->add_command (new MementoCommand<Locations>(*session->locations(), &before, &after));
6083 }
6084 }
6085
6086 if (tempo_too)
6087 session->tempo_map().insert_time (pos, frames);
6088
6089 if (commit) {
6090 commit_reversible_command ();
6091 }
6092 }
6093
6094 void
6095 Editor::fit_tracks ()
6096 {
6097 if (selection->tracks.empty()) {
6098 return;
6099 }
6100
6101 uint32_t child_heights = 0;
6102
6103 for (TrackSelection::iterator t = selection->tracks.begin(); t != selection->tracks.end(); ++t) {
6104
6105 if (!(*t)->marked_for_display()) {
6106 continue;
6107 }
6108
6109 child_heights += ((*t)->effective_height - (*t)->current_height());
6110 }
6111
6112 uint32_t h = (uint32_t) floor ((canvas_height - child_heights - canvas_timebars_vsize)/selection->tracks.size());
6113 double first_y_pos = DBL_MAX;
6114
6115 if (h < TimeAxisView::hSmall) {
6116 MessageDialog msg (*this, _("There are too many selected tracks to fit in the current window"));
6117 /* too small to be displayed */
6118 return;
6119 }
6120
6121 undo_visual_stack.push_back (current_visual_state());
6122
6123 /* operate on all tracks, hide unselected ones that are in the middle of selected ones */
6124
6125 bool prev_was_selected = false;
6126 bool is_selected = selection->selected (track_views.front());
6127 bool next_is_selected;
6128
6129 for (TrackViewList::iterator t = track_views.begin(); t != track_views.end(); ++t) {
6130
6131 TrackViewList::iterator next;
6132
6133 next = t;
6134 ++next;
6135
6136 if (next != track_views.end()) {
6137 next_is_selected = selection->selected (*next);
6138 } else {
6139 next_is_selected = false;
6140 }
6141
6142 if (is_selected) {
6143 (*t)->set_height (h);
6144 first_y_pos = std::min ((*t)->y_position, first_y_pos);
6145 } else {
6146 if (prev_was_selected && next_is_selected) {
6147 hide_track_in_display (**t);
6148 }
6149 }
6150
6151 prev_was_selected = is_selected;
6152 is_selected = next_is_selected;
6153 }
6154
6155 /*
6156 set the controls_layout height now, because waiting for its size
6157 request signal handler will cause the vertical adjustment setting to fail
6158 */
6159
6160 controls_layout.property_height () = full_canvas_height - canvas_timebars_vsize;
6161 vertical_adjustment.set_value (first_y_pos);
6162
6163 redo_visual_stack.push_back (current_visual_state());
6164 }
6165
6166 void
6167 Editor::save_visual_state (uint32_t n)
6168 {
6169 while (visual_states.size() <= n) {
6170 visual_states.push_back (0);
6171 }
6172
6173 if (visual_states[n] != 0) {
6174 delete visual_states[n];
6175 }
6176
6177 visual_states[n] = current_visual_state (true);
6178 gdk_beep ();
6179 }
6180
6181 void
6182 Editor::goto_visual_state (uint32_t n)
6183 {
6184 if (visual_states.size() <= n) {
6185 return;
6186 }
6187
6188 if (visual_states[n] == 0) {
6189 return;
6190 }
6191
6192 use_visual_state (*visual_states[n]);
6193 }
6194
6195 void
6196 Editor::start_visual_state_op (uint32_t n)
6197 {
6198 if (visual_state_op_connection.empty()) {
6199 visual_state_op_connection = Glib::signal_timeout().connect (bind (mem_fun (*this, &Editor::end_visual_state_op), n), 1000);
6200 }
6201 }
6202
6203 void
6204 Editor::cancel_visual_state_op (uint32_t n)
6205 {
6206 if (!visual_state_op_connection.empty()) {
6207 visual_state_op_connection.disconnect();
6208 goto_visual_state (n);
6209 } else {
6210 //we land here if called from the menu OR if end_visual_state_op has been called
6211 //so check if we are already in visual state n
6212 // XXX not yet checking it at all, but redoing does not hurt
6213 goto_visual_state (n);
6214 }
6215 }
6216
6217 bool
6218 Editor::end_visual_state_op (uint32_t n)
6219 {
6220 visual_state_op_connection.disconnect();
6221 save_visual_state (n);
6222
6223 PopUp* pup = new PopUp (WIN_POS_MOUSE, 1000, true);
6224 char buf[32];
6225 snprintf (buf, sizeof (buf), _("Saved view %u"), n+1);
6226 pup->set_text (buf);
6227 pup->touch();
6228
6229 return false; // do not call again
6230 }
6231
Digital Audio Workstation