61 #include "canvas/canvas.h"
119 if (_drags->active ()) {
125 if (_session->undo_depth() == 0) {
126 undo_action->set_sensitive(
false);
128 redo_action->set_sensitive(
true);
129 begin_selection_op_history ();
136 if (_drags->active ()) {
142 if (_session->redo_depth() == 0) {
143 redo_action->set_sensitive(
false);
145 undo_action->set_sensitive(
true);
146 begin_selection_op_history ();
156 bool working_on_selection = !pre_selected_regions.empty();
158 list<boost::shared_ptr<Playlist> > used_playlists;
159 list<RouteTimeAxisView*> used_trackviews;
161 if (regions.empty()) {
165 begin_reversible_command (
_(
"split"));
170 if (regions.size() == 1) {
171 switch (_snap_type) {
172 case SnapToRegionStart:
173 case SnapToRegionSync:
174 case SnapToRegionEnd:
186 for (RegionSelection::iterator a = regions.begin(); a != regions.end(); ) {
188 RegionSelection::iterator tmp;
194 if (!(*a)->region()->covers (where)) {
213 used_playlists.push_back(pl);
218 used_trackviews.push_back (rtv);
233 latest_regionviews.clear ();
235 vector<sigc::connection> region_added_connections;
237 for (list<RouteTimeAxisView*>::iterator i = used_trackviews.begin(); i != used_trackviews.end(); ++i) {
241 while (used_playlists.size() > 0) {
242 list <boost::shared_ptr<Playlist > >::iterator i = used_playlists.begin();
244 used_playlists.pop_front();
247 for (vector<sigc::connection>::iterator c = region_added_connections.begin(); c != region_added_connections.end(); ++c) {
255 if (working_on_selection) {
258 _ignore_follow_edits =
true;
269 selection->add ( pre_selected_regions );
272 for (RegionSelection::iterator ri = latest_regionviews.begin(); ri != latest_regionviews.end(); ri++) {
273 if ((*ri)->region()->position() < where) {
276 selection->add (*ri);
281 selection->add (*ri);
285 _ignore_follow_edits =
false;
287 _ignore_follow_edits =
true;
288 if( working_on_selection ) {
289 selection->add (latest_regionviews);
291 _ignore_follow_edits =
false;
294 commit_reversible_command ();
308 if (selection->time.start() == selection->time.end_frame()) {
313 framepos_t end = selection->time.end_frame ();
317 int dir = next ? 1 : -1;
320 if (dir > 0 || pos > 0) {
324 framepos_t const target = get_region_boundary (pos, dir,
true,
false);
339 begin_reversible_command (
_(
"alter selection"));
340 selection->set_preserving_all_ranges (start, end);
341 commit_reversible_command ();
347 if (ev->state & Keyboard::PrimaryModifier) {
348 nudge_forward (
false,
true);
350 nudge_forward (
false,
false);
358 if (ev->state & Keyboard::PrimaryModifier) {
359 nudge_backward (
false,
true);
361 nudge_backward (
false,
false);
379 if (!force_playhead && !rs.empty()) {
381 begin_reversible_command (
_(
"nudge regions forward"));
383 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
386 distance = get_nudge_distance (r->position(), next_distance);
389 distance = next_distance;
393 r->set_position (r->position() + distance);
397 commit_reversible_command ();
400 }
else if (!force_playhead && !selection->markers.empty()) {
404 begin_reversible_command (
_(
"nudge location forward"));
406 for (MarkerSelection::iterator i = selection->markers.begin(); i != selection->markers.end(); ++i) {
408 Location* loc = find_location_from_marker ((*i), is_start);
415 distance = get_nudge_distance (loc->
start(), next_distance);
417 distance = next_distance;
425 distance = get_nudge_distance (loc->
end(), next_distance);
427 distance = next_distance;
440 commit_reversible_command ();
443 distance = get_nudge_distance (playhead_cursor->current_frame (), next_distance);
444 _session->request_locate (playhead_cursor->current_frame () + distance);
460 if (!force_playhead && !rs.empty()) {
462 begin_reversible_command (
_(
"nudge regions backward"));
464 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
467 distance = get_nudge_distance (r->position(), next_distance);
470 distance = next_distance;
475 if (r->position() > distance) {
476 r->set_position (r->position() - distance);
483 commit_reversible_command ();
485 }
else if (!force_playhead && !selection->markers.empty()) {
489 begin_reversible_command (
_(
"nudge location forward"));
491 for (MarkerSelection::iterator i = selection->markers.begin(); i != selection->markers.end(); ++i) {
493 Location* loc = find_location_from_marker ((*i), is_start);
500 distance = get_nudge_distance (loc->
start(), next_distance);
502 distance = next_distance;
504 if (distance < loc->
start()) {
510 distance = get_nudge_distance (loc->
end(), next_distance);
513 distance = next_distance;
516 if (distance < loc->end() - loc->
length()) {
528 commit_reversible_command ();
532 distance = get_nudge_distance (playhead_cursor->current_frame (), next_distance);
534 if (playhead_cursor->current_frame () > distance) {
535 _session->request_locate (playhead_cursor->current_frame () - distance);
537 _session->goto_start();
547 if (!_session || rs.empty()) {
551 begin_reversible_command (
_(
"nudge forward"));
553 framepos_t const distance = _session->worst_output_latency();
555 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
559 r->set_position (r->position() + distance);
563 commit_reversible_command ();
571 if (!_session || rs.empty()) {
575 begin_reversible_command (
_(
"nudge backward"));
577 framepos_t const distance = _session->worst_output_latency();
579 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
584 if (r->position() > distance) {
585 r->set_position (r->position() - distance);
592 commit_reversible_command ();
618 begin_reversible_command (
_(
"sequence regions"));
619 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
628 if(r->position_locked())
635 r->set_position(r_end_prev);
640 r_end=r->position() + r->length();
644 commit_reversible_command ();
654 _session->goto_start ();
661 _session->request_locate (_session->current_end_frame());
668 vector<RegionPoint> interesting_points;
673 region_boundary_cache.clear ();
679 switch (_snap_type) {
680 case SnapToRegionStart:
681 interesting_points.push_back (
Start);
683 case SnapToRegionEnd:
684 interesting_points.push_back (
End);
686 case SnapToRegionSync:
687 interesting_points.push_back (
SyncPoint);
689 case SnapToRegionBoundary:
690 interesting_points.push_back (
Start);
691 interesting_points.push_back (
End);
702 if (!selection->tracks.empty()) {
708 while (pos < _session->current_end_frame() && !at_end) {
713 for (vector<RegionPoint>::iterator p = interesting_points.begin(); p != interesting_points.end(); ++p) {
715 if ((r = find_next_region (pos, *p, 1, tlist, &ontrack)) == 0) {
716 if (*p == interesting_points.back()) {
743 if (ontrack != 0 && (rtav = dynamic_cast<RouteTimeAxisView*>(ontrack)) != 0 ) {
744 if (rtav->
track() != 0) {
759 vector<framepos_t>::iterator ri;
761 for (ri = region_boundary_cache.begin(); ri != region_boundary_cache.end(); ++ri) {
767 if (ri == region_boundary_cache.end()) {
768 region_boundary_cache.push_back (rpos);
777 sort (region_boundary_cache.begin(), region_boundary_cache.end());
783 TrackViewList::iterator i;
792 for (i = tracks.begin(); i != tracks.end(); ++i) {
798 if ( (rtav = dynamic_cast<RouteTimeAxisView*>(*i)) != 0 ) {
799 if (rtav->
track()!=0)
805 if ((r = (*i)->find_next_region (track_frame, point, dir)) == 0) {
827 distance = rpos - frame;
829 distance = frame - rpos;
832 if (distance < closest) {
849 for (TrackViewList::const_iterator i = tracks.begin(); i != tracks.end(); ++i) {
863 d = ::llabs (pos - contender);
866 current_nearest = contender;
871 return current_nearest;
880 if (with_selection &&
Config->get_region_boundaries_from_selected_tracks()) {
882 if (!selection->tracks.empty()) {
884 target = find_next_region_boundary (pos, dir, selection->tracks);
888 if (only_onscreen ||
Config->get_region_boundaries_from_onscreen_tracks()) {
889 get_onscreen_tracks (tvl);
890 target = find_next_region_boundary (pos, dir, tvl);
892 target = find_next_region_boundary (pos, dir, track_views);
898 if (only_onscreen ||
Config->get_region_boundaries_from_onscreen_tracks()) {
899 get_onscreen_tracks (tvl);
900 target = find_next_region_boundary (pos, dir, tvl);
902 target = find_next_region_boundary (pos, dir, track_views);
912 framepos_t pos = playhead_cursor->current_frame ();
920 if (dir > 0 || pos > 0) {
924 if ((target = get_region_boundary (pos, dir, with_selection,
false)) < 0) {
928 _session->request_locate (target);
934 cursor_to_region_boundary (with_selection, 1);
940 cursor_to_region_boundary (with_selection, -1);
959 if (!selection->tracks.empty()) {
961 r = find_next_region (pos, point, dir, selection->tracks, &ontrack);
963 }
else if (clicked_axisview) {
966 t.push_back (clicked_axisview);
968 r = find_next_region (pos, point, dir, t, &ontrack);
972 r = find_next_region (pos, point, dir, track_views, &ontrack);
996 if ( ontrack != 0 && (rtav = dynamic_cast<RouteTimeAxisView*>(ontrack)) != 0 ) {
997 if (rtav->
track() != 0) {
1004 if (cursor == playhead_cursor) {
1005 _session->request_locate (pos);
1014 cursor_to_region_point (cursor, point, 1);
1020 cursor_to_region_point (cursor, point, -1);
1028 switch (mouse_mode) {
1030 if (!selection->regions.empty()) {
1031 pos = selection->regions.start();
1036 if (!selection->time.empty()) {
1037 pos = selection->time.start ();
1045 if (cursor == playhead_cursor) {
1046 _session->request_locate (pos);
1057 switch (mouse_mode) {
1059 if (!selection->regions.empty()) {
1060 pos = selection->regions.end_frame();
1065 if (!selection->time.empty()) {
1066 pos = selection->time.end_frame ();
1074 if (cursor == playhead_cursor) {
1075 _session->request_locate (pos);
1092 if (selection->markers.empty()) {
1096 if (!mouse_frame (mouse, ignored)) {
1100 add_location_mark (mouse);
1103 if ((loc = find_location_from_marker (selection->markers.front(), ignored)) == 0) {
1110 if (dir > 0 || pos > 0) {
1114 if ((target = get_region_boundary (pos, dir, with_selection,
false)) < 0) {
1124 selected_marker_to_region_boundary (with_selection, 1);
1130 selected_marker_to_region_boundary (with_selection, -1);
1141 if (!_session || selection->markers.empty()) {
1145 if ((loc = find_location_from_marker (selection->markers.front(), ignored)) == 0) {
1157 if (!selection->tracks.empty()) {
1159 r = find_next_region (pos, point, dir, selection->tracks, &ontrack);
1163 r = find_next_region (pos, point, dir, track_views, &ontrack);
1187 if (ontrack != 0 && (rtav = dynamic_cast<RouteTimeAxisView*>(ontrack)) != 0) {
1188 if (rtav->
track() != 0) {
1201 selected_marker_to_region_point (point, 1);
1207 selected_marker_to_region_point (point, -1);
1217 if (!_session || selection->markers.empty()) {
1221 if ((loc = find_location_from_marker (selection->markers.front(), ignored)) == 0) {
1225 switch (mouse_mode) {
1227 if (!selection->regions.empty()) {
1228 pos = selection->regions.
start();
1233 if (!selection->time.empty()) {
1234 pos = selection->time.start ();
1252 if (!_session || selection->markers.empty()) {
1256 if ((loc = find_location_from_marker (selection->markers.front(), ignored)) == 0) {
1260 switch (mouse_mode) {
1262 if (!selection->regions.empty()) {
1263 pos = selection->regions.end_frame();
1268 if (!selection->time.empty()) {
1269 pos = selection->time.end_frame ();
1283 framepos_t pos = playhead_cursor->current_frame ();
1310 _session->request_locate (pos);
1320 if (playhead_to_edit) {
1322 if (selection->markers.empty()) {
1326 _session->request_locate (selection->markers.front()->position(), _session->transport_rolling());
1331 for (MarkerSelection::iterator i = selection->markers.begin(); i != selection->markers.end(); ++i) {
1334 Location* loc = find_location_from_marker (*i, ignored);
1337 loc->
set_start (playhead_cursor->current_frame ());
1339 loc->
set (playhead_cursor->current_frame (),
1340 playhead_cursor->current_frame () + loc->
length());
1353 if (leftmost_frame < cnt) {
1356 frame = leftmost_frame - cnt;
1359 reset_x_origin (frame);
1372 frame = leftmost_frame + cnt;
1375 reset_x_origin (frame);
1381 double vert_value = vertical_adjustment.get_value() + vertical_adjustment.get_page_size();
1382 if (vert_value > vertical_adjustment.get_upper() - _visible_canvas_height) {
1383 vert_value = vertical_adjustment.get_upper() - _visible_canvas_height;
1386 vertical_adjustment.set_value (vert_value);
1392 vertical_adjustment.set_value (vertical_adjustment.get_value() - vertical_adjustment.get_page_size());
1398 double vert_value = vertical_adjustment.get_value() + 60;
1400 if (vert_value > vertical_adjustment.get_upper() - _visible_canvas_height) {
1401 vert_value = vertical_adjustment.get_upper() - _visible_canvas_height;
1404 vertical_adjustment.set_value (vert_value);
1410 reset_y_origin (vertical_adjustment.get_value() - 60);
1416 TrackViewList::reverse_iterator next = track_views.rend();
1417 const double top_of_trackviews = vertical_adjustment.get_value();
1419 for (TrackViewList::reverse_iterator t = track_views.rbegin(); t != track_views.rend(); ++t) {
1420 if ((*t)->hidden()) {
1429 std::pair<TimeAxisView*,double> res = (*t)->covers_y_position (top_of_trackviews);
1432 if (skip_child_views) {
1443 TimeAxisView::Children::reverse_iterator nkid = kids.rend();
1445 for (TimeAxisView::Children::reverse_iterator ci = kids.rbegin(); ci != kids.rend(); ++ci) {
1446 if ((*ci)->hidden()) {
1450 std::pair<TimeAxisView*,double> dev;
1451 dev = (*ci)->covers_y_position (top_of_trackviews);
1454 if (ci == kids.rbegin()) {
1465 if (nkid != kids.rend()) {
1466 ensure_time_axis_view_is_visible (**nkid,
true);
1476 if (next != track_views.rend()) {
1477 ensure_time_axis_view_is_visible (**next,
true);
1487 TrackViewList::iterator prev = track_views.end();
1488 double top_of_trackviews = vertical_adjustment.get_value ();
1490 for (TrackViewList::iterator t = track_views.begin(); t != track_views.end(); ++t) {
1492 if ((*t)->hidden()) {
1500 std::pair<TimeAxisView*,double> res = (*t)->covers_y_position (top_of_trackviews);
1503 if (skip_child_views) {
1515 TimeAxisView::Children::iterator pkid = kids.end();
1517 for (TimeAxisView::Children::iterator ci = kids.begin(); ci != kids.end(); ++ci) {
1518 if ((*ci)->hidden()) {
1522 std::pair<TimeAxisView*,double> dev;
1523 dev = (*ci)->covers_y_position (top_of_trackviews);
1526 if (ci == kids.begin()) {
1530 ensure_time_axis_view_is_visible (**t,
true);
1533 else if (pkid != kids.end()) {
1537 ensure_time_axis_view_is_visible (**pkid,
true);
1551 if (prev != track_views.end()) {
1554 TimeAxisView::Children::reverse_iterator pkid = kids.rend();
1555 if (!skip_child_views) {
1557 for (TimeAxisView::Children::reverse_iterator ci = kids.rbegin(); ci != kids.rend(); ++ci) {
1558 if (!(*ci)->hidden()) {
1564 if (pkid != kids.rend()) {
1565 ensure_time_axis_view_is_visible (**pkid,
true);
1567 ensure_time_axis_view_is_visible (**prev,
true);
1584 if (selection->tracks.empty()) {
1587 ts = &selection->tracks;
1590 for (TrackViewList::iterator i = ts->begin(); i != ts->end(); ++i) {
1603 if (selection->tracks.empty() || force_all) {
1606 ts = &selection->tracks;
1609 for (TrackViewList::iterator i = ts->begin(); i != ts->end(); ++i) {
1640 temporal_zoom (nspp);
1650 framepos_t current_page = current_page_samples();
1651 framepos_t current_leftmost = leftmost_frame;
1658 bool in_track_canvas;
1662 if (fpp == samples_per_pixel) {
1677 new_page_size = (
framepos_t) floor (_visible_canvas_width * nfpp);
1678 half_page_size = new_page_size / 2;
1680 switch (zoom_focus) {
1682 leftmost_after_zoom = current_leftmost;
1685 case ZoomFocusRight:
1686 current_rightmost = leftmost_frame + current_page;
1687 if (current_rightmost < new_page_size) {
1688 leftmost_after_zoom = 0;
1690 leftmost_after_zoom = current_rightmost - new_page_size;
1694 case ZoomFocusCenter:
1695 current_center = current_leftmost + (current_page/2);
1696 if (current_center < half_page_size) {
1697 leftmost_after_zoom = 0;
1699 leftmost_after_zoom = current_center - half_page_size;
1703 case ZoomFocusPlayhead:
1705 l = playhead_cursor->current_frame () - (new_page_size * 0.5);
1708 leftmost_after_zoom = 0;
1716 case ZoomFocusMouse:
1719 if (!mouse_frame (where, in_track_canvas)) {
1721 where = playhead_cursor->current_frame ();
1723 if (where < half_page_size) {
1724 leftmost_after_zoom = 0;
1726 leftmost_after_zoom = where - half_page_size;
1731 l = - ((new_page_size * ((where - current_leftmost)/(
double)current_page)) - where);
1734 leftmost_after_zoom = 0;
1746 where = get_preferred_edit_position ();
1750 double l = - ((new_page_size * ((where - current_leftmost)/(
double)current_page)) - where);
1753 leftmost_after_zoom = 0;
1770 reposition_and_zoom (leftmost_after_zoom, nfpp);
1781 GdkScreen* screen = gdk_screen_get_default ();
1782 const gint pixwidth = gdk_screen_get_width (screen);
1783 const gint mmwidth = gdk_screen_get_width_mm (screen);
1784 const double pix_per_mm = (double) pixwidth/ (
double) mmwidth;
1785 const double one_centimeter_in_pixels = pix_per_mm * 10.0;
1788 const framecnt_t new_fpp = (
framecnt_t) ceil ((
double) range / (double) _visible_canvas_width);
1791 if (start > extra_samples) {
1792 start -= extra_samples;
1798 end += extra_samples;
1809 set<TimeAxisView*> tracks;
1811 if ( !get_selection_extents(start, end) )
1814 calc_extra_zoom_edges (start, end);
1819 undo_visual_stack.push_back (current_visual_state (both_axes));
1823 temporal_zoom_by_frame (start, end);
1826 uint32_t per_track_height = (uint32_t) floor ((_visible_canvas_height - 10.0) / tracks.size());
1830 for (set<TimeAxisView*>::iterator t = tracks.begin(); t != tracks.end(); ++t) {
1831 (*t)->set_height (per_track_height);
1838 for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
1839 if (find (tracks.begin(), tracks.end(), (*i)) == tracks.end()) {
1840 hide_track_in_display (*i);
1844 vertical_adjustment.set_value (0.0);
1847 redo_visual_stack.push_back (current_visual_state (both_axes));
1862 if ( !selection->regions.empty() ) {
1865 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
1867 if ((*i)->region()->position() <
start) {
1868 start = (*i)->region()->position();
1871 if ((*i)->region()->last_frame() + 1 > end) {
1872 end = (*i)->region()->last_frame() + 1;
1876 }
else if (!selection->time.empty()) {
1877 start = selection->time.start();
1878 end = selection->time.end_frame();
1883 if ((start == 0 && end == 0) || end < start) {
1894 if (!selection)
return;
1901 if ( !selection->regions.empty() )
1902 temporal_zoom_region (both_axes);
1905 if (!selection->time.empty()) {
1908 if (get_selection_extents (start, end)) {
1909 calc_extra_zoom_edges(start, end);
1910 temporal_zoom_by_frame (start, end);
1926 framecnt_t end = _session->current_end_frame();
1928 if (_session->actively_recording () ) {
1929 framepos_t cur = playhead_cursor->current_frame ();
1936 end = cur + _session->frame_rate() * 5;
1940 if ((start == 0 && end == 0) || end < start) {
1944 calc_extra_zoom_edges(start, end);
1946 temporal_zoom_by_frame (start, end);
1953 if (!_session)
return;
1955 if ((start == 0 && end == 0) || end < start) {
1961 const framecnt_t new_fpp = (
framecnt_t) ceil ((
double) range / (double) _visible_canvas_width);
1967 if (new_leftmost > middle) {
1971 if (new_leftmost < 0) {
1975 reposition_and_zoom (new_leftmost, new_fpp);
1985 framecnt_t range_before = frame - leftmost_frame;
1989 if (samples_per_pixel <= 1) {
1992 new_spp = samples_per_pixel + (samples_per_pixel/2);
1994 range_before += range_before/2;
1996 if (samples_per_pixel >= 1) {
1997 new_spp = samples_per_pixel - (samples_per_pixel/2);
2002 new_spp = samples_per_pixel;
2005 range_before -= range_before/2;
2008 if (new_spp == samples_per_pixel) {
2018 if (new_leftmost > frame) {
2022 if (new_leftmost < 0) {
2026 reposition_and_zoom (new_leftmost, new_spp);
2042 dialog.set_title (
_(
"New Location Marker"));
2044 dialog.set_name (
"MarkNameWindow");
2045 dialog.set_size_request (250, -1);
2046 dialog.set_position (Gtk::WIN_POS_MOUSE);
2048 dialog.add_button (Stock::OK, RESPONSE_ACCEPT);
2053 switch (dialog.run ()) {
2054 case RESPONSE_ACCEPT:
2071 if (selection->time.empty()) {
2075 if (_session == 0 || clicked_axisview == 0) {
2080 framepos_t end = selection->time[clicked_selection].end;
2082 _session->locations()->next_available_name(rangename,
"selection");
2083 Location *location =
new Location (*_session, start, end, rangename, Location::IsRangeMarker);
2085 begin_reversible_command (
_(
"add marker"));
2087 XMLNode &before = _session->locations()->get_state();
2088 _session->locations()->add (location,
true);
2089 XMLNode &after = _session->locations()->get_state();
2092 commit_reversible_command ();
2100 select_new_marker =
true;
2102 _session->locations()->next_available_name(markername,
"mark");
2103 if (!choose_new_marker_name(markername)) {
2106 Location *location =
new Location (*_session, where, where, markername, Location::IsMark);
2107 begin_reversible_command (
_(
"add marker"));
2109 XMLNode &before = _session->locations()->get_state();
2110 _session->locations()->add (location,
true);
2111 XMLNode &after = _session->locations()->get_state();
2114 commit_reversible_command ();
2124 if ((loc = _session->locations()->session_range_location()) == 0) {
2125 _session->set_session_extents ( _session->audible_frame(), _session->audible_frame() );
2129 _session->set_session_extents ( _session->audible_frame(), loc->
end() );
2133 begin_reversible_command (
_(
"Set session start"));
2137 commit_reversible_command ();
2148 if ((loc = _session->locations()->session_range_location()) == 0) {
2149 _session->set_session_extents ( _session->audible_frame(), _session->audible_frame() );
2153 _session->set_session_extents ( loc->
start(), _session->audible_frame() );
2157 begin_reversible_command (
_(
"Set session start"));
2161 commit_reversible_command ();
2168 add_location_mark (_session->audible_frame());
2177 begin_reversible_command (
_(
"remove marker"));
2179 XMLNode &before = _session->locations()->get_state();
2180 bool removed =
false;
2184 _session->locations()->find_all_between (_session->audible_frame(), _session->audible_frame()+1, locs,
Location::Flags(0));
2185 for (Locations::LocationList::iterator i = locs.begin(); i != locs.end(); ++i) {
2186 if ((*i)->is_mark()) {
2187 _session->locations()->remove (*i);
2194 XMLNode &after = _session->locations()->get_state();
2197 commit_reversible_command ();
2212 begin_reversible_command (selection->regions.size () > 1 ?
_(
"add markers") :
_(
"add marker"));
2214 XMLNode &before = _session->locations()->get_state();
2216 for (RegionSelection::iterator i = rs.begin (); i != rs.end (); ++i) {
2222 _session->locations()->add (location,
true);
2225 XMLNode &after = _session->locations()->get_state();
2228 commit_reversible_command ();
2241 begin_reversible_command (
_(
"add marker"));
2243 XMLNode &before = _session->locations()->get_state();
2247 if (rs.size() > 1) {
2248 _session->locations()->next_available_name(markername,
"regions");
2252 markername = region->
name();
2255 if (!choose_new_marker_name(markername)) {
2260 Location *location =
new Location (*_session, selection->regions.start(), selection->regions.end_frame(), markername, Location::IsRangeMarker);
2261 _session->locations()->add (location,
true);
2263 XMLNode &after = _session->locations()->get_state();
2266 commit_reversible_command ();
2278 framepos_t pos = _session->locations()->first_mark_after (playhead_cursor->current_frame());
2284 _session->request_locate (pos, _session->transport_rolling());
2294 framepos_t pos = _session->locations()->first_mark_before (playhead_cursor->current_frame());
2300 _session->request_locate (pos, _session->transport_rolling());
2306 framepos_t const pos = _session->audible_frame ();
2309 _session->locations()->next_available_name (markername,
"mark");
2311 if (!choose_new_marker_name (markername)) {
2315 _session->locations()->add (
new Location (*_session, pos, 0, markername, Location::IsMark),
true);
2322 begin_reversible_command (
_(
"clear markers"));
2324 XMLNode &before = _session->locations()->get_state();
2325 _session->locations()->clear_markers ();
2326 XMLNode &after = _session->locations()->get_state();
2329 commit_reversible_command ();
2337 begin_reversible_command (
_(
"clear ranges"));
2339 XMLNode &before = _session->locations()->get_state();
2341 _session->locations()->clear_ranges ();
2343 XMLNode &after = _session->locations()->get_state();
2346 commit_reversible_command ();
2353 begin_reversible_command (
_(
"clear locations"));
2355 XMLNode &before = _session->locations()->get_state();
2356 _session->locations()->clear ();
2357 XMLNode &after = _session->locations()->get_state();
2360 commit_reversible_command ();
2366 for (LocationMarkerMap::iterator i = location_markers.begin(); i != location_markers.end(); ++i) {
2377 for (LocationMarkerMap::iterator i = location_markers.begin(); i != location_markers.end(); ++i) {
2393 if (clicked_routeview != 0) {
2394 tv = clicked_routeview;
2395 }
else if (!selection->tracks.empty()) {
2396 if ((tv = dynamic_cast<RouteTimeAxisView*>(selection->tracks.front())) == 0) {
2399 }
else if (entered_track != 0) {
2400 if ((tv = dynamic_cast<RouteTimeAxisView*>(entered_track)) == 0) {
2407 if ((playlist = tv->
playlist()) == 0) {
2416 begin_reversible_command (
_(
"insert region"));
2418 playlist->
add_region ((RegionFactory::create (region,
true)), get_preferred_edit_position(), times);
2423 commit_reversible_command ();
2450 if (_session->config.get_external_sync()) {
2451 switch (
Config->get_sync_source()) {
2460 if (_session->is_auditioning()) {
2461 _session->cancel_audition ();
2465 _session->request_transport_speed (fwd ? 1.0
f : -1.0
f);
2471 _session->request_locate (_session->current_start_frame(),
true);
2477 _session->request_locate (get_preferred_edit_position(),
true);
2488 if (_session->transport_rolling()) {
2489 _session->request_locate (start_frame,
false);
2495 if ((return_frame = _session->requested_return_frame()) < 0) {
2496 return_frame = _session->audible_frame();
2499 if (start_frame >= 0) {
2500 _session->request_roll_at_and_return (start_frame, return_frame);
2508 if (!get_selection_extents ( start, end))
2512 list<AudioRange> lar;
2515 _session->request_play_range (&lar,
true);
2521 return 1.0 * _session->frame_rate();
2528 if ( _session->transport_rolling() || !
ARDOUR_UI::config()->get_follow_edits() || _ignore_follow_edits )
2531 location -= get_preroll();
2538 if ( _follow_playhead )
2539 if ( location < leftmost_frame )
2540 location = leftmost_frame;
2542 _session->request_locate( location );
2552 if (!get_selection_extents ( start, end))
2555 if (start > preroll)
2556 start = start - preroll;
2558 end = end + preroll;
2561 list<AudioRange> lar;
2564 _session->request_play_range (&lar,
true);
2571 if (location.
start() <= location.
end()) {
2575 _session->request_bounded_roll (location.
start(), location.
end());
2581 if (location.
start() <= location.
end()) {
2587 if ((tll = transport_loop_location()) != 0) {
2591 _session->request_locate (tll->
start(),
true);
2592 _session->request_play_loop (
true);
2599 if (selection->regions.empty ()) {
2603 bool const multiple = selection->regions.size() > 1;
2607 begin_reversible_command (
_(
"raise regions"));
2609 begin_reversible_command (
_(
"raise region"));
2615 begin_reversible_command (
_(
"raise regions to top"));
2617 begin_reversible_command (
_(
"raise region to top"));
2623 begin_reversible_command (
_(
"lower regions"));
2625 begin_reversible_command (
_(
"lower region"));
2631 begin_reversible_command (
_(
"lower regions to bottom"));
2633 begin_reversible_command (
_(
"lower region"));
2638 set<boost::shared_ptr<Playlist> > playlists = selection->regions.playlists ();
2640 (*i)->clear_owned_changes ();
2643 for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
2661 vector<Command*> cmds;
2663 _session->add_commands (cmds);
2666 commit_reversible_command ();
2672 do_layer_operation (Raise);
2678 do_layer_operation (RaiseToTop);
2684 do_layer_operation (Lower);
2690 do_layer_operation (LowerToBottom);
2718 Label label (
_(
"New name:"));
2721 hbox.set_spacing (6);
2722 hbox.pack_start (label,
false,
false);
2723 hbox.pack_start (entry,
true,
true);
2725 d.get_vbox()->set_border_width (12);
2726 d.get_vbox()->pack_start (hbox,
false,
false);
2728 d.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
2729 d.add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);
2731 d.set_size_request (300, -1);
2733 entry.set_text (rs.front()->region()->name());
2734 entry.select_region (0, -1);
2736 entry.signal_activate().connect (sigc::bind (sigc::mem_fun (d, &Dialog::response), RESPONSE_OK));
2742 int const ret = d.run();
2746 if (ret != RESPONSE_OK) {
2750 std::string str = entry.get_text();
2753 rs.front()->region()->set_name (str);
2754 _regions->redisplay ();
2761 if (_session->is_auditioning()) {
2762 _session->cancel_audition ();
2783 if (get_edit_op_range (start, end)) {
2784 _session->request_bounded_roll (start, end);
2800 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
2801 if ((*i)->region()->position() <
start) {
2802 start = (*i)->region()->position();
2804 if ((*i)->region()->last_frame() + 1 > end) {
2805 end = (*i)->region()->last_frame() + 1;
2809 _session->request_bounded_roll (start, end);
2815 _session->audition_region (region);
2821 if (clicked_axisview == 0) {
2825 if (selection->time.empty()) {
2830 framepos_t end = selection->time[clicked_selection].end;
2836 for (TrackSelection::iterator i = tracks.begin(); i != tracks.end(); ++i) {
2842 if ((pl = (*i)->playlist()) == 0) {
2850 internal_start = start - current->
position();
2851 RegionFactory::region_name (new_name, current->
name(),
true);
2867 if (selection->time.empty() || selection->tracks.empty()) {
2872 if (clicked_selection) {
2873 start = selection->time[clicked_selection].start;
2874 end = selection->time[clicked_selection].end;
2876 start = selection->time.start();
2877 end = selection->time.end_frame();
2881 sort_track_selection (ts);
2883 for (TrackSelection::iterator i = ts.begin(); i != ts.end(); ++i) {
2889 if ((playlist = (*i)->playlist()) == 0) {
2897 internal_start = start - current->
position();
2898 RegionFactory::region_name (new_name, current->
name(),
true);
2906 new_regions.push_back (RegionFactory::create (current, plist));
2919 vector< boost::shared_ptr<Region> > v;
2921 for (list<RegionView*>::iterator x = rs.begin(); x != rs.end(); ++x) {
2922 (*x)->region()->separate_by_channel (*_session, v);
2929 region_from_selection ();
2930 cancel_selection ();
2956 if (selection->tracks.empty()) {
2962 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
2977 t = selection->tracks;
2986 bool in_command =
false;
2991 sort_track_selection (tmptracks);
2993 for (TrackSelection::iterator i = tmptracks.begin(); i != tmptracks.end(); ++i) {
2997 if ((rtv = dynamic_cast<RouteTimeAxisView*> ((*i))) != 0) {
3007 if ((playlist = rtv->
playlist()) != 0) {
3016 for (list<AudioRange>::const_iterator t = ts.begin(); t != ts.end(); ++t) {
3021 latest_regionviews.clear ();
3028 if (!latest_regionviews.empty()) {
3032 &(*t), &new_selection));
3035 begin_reversible_command (
_(
"separate"));
3041 vector<Command*> cmds;
3042 playlist->
rdiff (cmds);
3043 _session->add_commands (cmds);
3059 commit_reversible_command ();
3080 if (!selection->time.empty()) {
3082 separate_regions_between (selection->time);
3089 if (get_edit_op_range (start, end)) {
3095 separate_regions_between (ts);
3103 Location* loc = _session->locations()->auto_punch_location();
3105 separate_regions_using_location (*loc);
3112 Location* loc = _session->locations()->auto_loop_location();
3114 separate_regions_using_location (*loc);
3130 separate_regions_between (ts);
3137 vector<PlaylistState> playlists;
3141 rs = get_regions_from_selection_and_entered();
3143 if (!_session || rs.empty()) {
3147 begin_reversible_command (
_(
"separate region under"));
3149 list<boost::shared_ptr<Region> > regions_to_remove;
3151 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
3161 regions_to_remove.push_back ((*i)->region());
3173 vector<PlaylistState>::iterator i;
3176 for (i = playlists.begin(); i != playlists.end(); ++i) {
3177 if ((*i).playlist == playlist) {
3182 if (i == playlists.end()) {
3189 playlists.push_back(before);
3193 playlist->
partition ((*rl)->first_frame() - 1, (*rl)->last_frame() + 1,
true);
3196 playlist->
add_region( (*rl), (*rl)->first_frame() );
3199 vector<PlaylistState>::iterator pl;
3201 for (pl = playlists.begin(); pl != playlists.end(); ++pl) {
3202 (*pl).playlist->thaw ();
3206 commit_reversible_command ();
3212 if (!selection->time.empty()) {
3214 crop_region_to (selection->time.start(), selection->time.end_frame());
3221 if (get_edit_op_range (start, end)) {
3222 crop_region_to (start, end);
3231 vector<boost::shared_ptr<Playlist> > playlists;
3235 if (selection->tracks.empty()) {
3241 sort_track_selection (ts);
3243 for (TrackSelection::iterator i = ts.begin(); i != ts.end(); ++i) {
3247 if ((rtv = dynamic_cast<RouteTimeAxisView*> ((*i))) != 0) {
3253 if ((playlist = rtv->
playlist()) != 0) {
3254 playlists.push_back (playlist);
3260 if (playlists.empty()) {
3268 begin_reversible_command (
_(
"trim to selection"));
3276 if ((region = (*i)->top_region_at(the_start)) == 0) {
3286 the_end = the_start + region->
length() - 1;
3290 the_end = min (end, the_end);
3291 cnt = the_end - the_start + 1;
3294 region->
trim_to (the_start, cnt);
3298 commit_reversible_command ();
3306 if (!_session || rs.empty()) {
3310 framepos_t const end = _session->current_end_frame ();
3314 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
3320 if (end <= region->last_frame()) {
3324 double times = (double) (end - region->last_frame()) / (
double) region->length();
3331 pl->add_region (RegionFactory::create (region,
true), region->last_frame(), times);
3335 commit_reversible_command ();
3341 if (clicked_routeview == 0 || !clicked_routeview->is_audio_track()) {
3345 if (selection->time.empty()) {
3355 framepos_t end = selection->time[clicked_selection].end;
3359 if (selection->tracks.empty()) {
3364 float times = (float)selection_length / region->
length();
3370 for (TrackViewList::iterator i = ts.begin(); i != ts.end(); ++i) {
3372 if ((playlist = (*i)->playlist()) == 0) {
3377 playlist->
add_region (RegionFactory::create (region,
true), start, times);
3381 commit_reversible_command ();
3387 set_sync_point (get_preferred_edit_position (), get_regions_from_selection_and_edit_point ());
3393 bool in_command =
false;
3395 for (RegionSelection::const_iterator r = rs.begin(); r != rs.end(); ++r) {
3397 if (!(*r)->region()->covers (where)) {
3404 begin_reversible_command (
_(
"set sync point"));
3408 region->clear_changes ();
3409 region->set_sync_position (where);
3414 commit_reversible_command ();
3428 begin_reversible_command (
_(
"remove region sync"));
3430 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
3432 (*i)->region()->clear_changes ();
3433 (*i)->region()->clear_sync_position ();
3437 commit_reversible_command ();
3449 if (rs.size() > 1) {
3450 begin_reversible_command (
_(
"move regions to original position"));
3452 begin_reversible_command (
_(
"move region to original position"));
3455 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
3456 (*i)->region()->clear_changes ();
3457 (*i)->region()->move_to_natural_position ();
3461 commit_reversible_command ();
3467 RegionSelection const rs = get_regions_from_selection_and_edit_point ();
3473 begin_reversible_command (
_(
"align selection"));
3477 for (RegionSelection::const_iterator i = rs.begin(); i != rs.end(); ++i) {
3478 align_region_internal ((*i)->region(), what,
position);
3481 commit_reversible_command ();
3493 RegionSelection const rs = get_regions_from_selection_and_edit_point ();
3505 list<RegionView*> sorted;
3513 if (position > r->position()) {
3514 distance = position - r->position();
3516 distance = r->position() -
position;
3522 if (position > r->last_frame()) {
3523 distance = position - r->last_frame();
3524 pos = r->position() + distance;
3526 distance = r->last_frame() -
position;
3527 pos = r->position() - distance;
3533 pos = r->adjust_to_sync (position);
3534 if (pos > r->position()) {
3535 distance = pos - r->position();
3537 distance = r->position() - pos;
3543 if (pos == r->position()) {
3547 begin_reversible_command (
_(
"align selection (relative)"));
3551 r->clear_changes ();
3552 r->set_position (pos);
3559 for (list<RegionView*>::iterator i = sorted.begin(); i != sorted.end(); ++i) {
3566 region->set_position (region->position() + distance);
3568 region->set_position (region->position() - distance);
3575 commit_reversible_command ();
3581 begin_reversible_command (
_(
"align region"));
3582 align_region_internal (region, point, position);
3583 commit_reversible_command ();
3597 if (position > region->
length()) {
3619 trim_region (
false);
3625 framepos_t where = get_preferred_edit_position();
3632 begin_reversible_command (front ?
_(
"trim front") :
_(
"trim back"));
3634 for (list<RegionView*>::const_iterator i = rs.
by_layer().begin(); i != rs.
by_layer().end(); ++i) {
3635 if (!(*i)->region()->locked()) {
3637 (*i)->region()->clear_changes ();
3640 (*i)->region()->trim_front (where);
3641 maybe_locate_with_edit_preroll ( where );
3643 (*i)->region()->trim_end (where);
3644 maybe_locate_with_edit_preroll ( where );
3651 commit_reversible_command ();
3658 Location* loc = _session->locations()->auto_loop_location();
3662 trim_region_to_location (*loc,
_(
"trim to loop"));
3668 Location* loc = _session->locations()->auto_punch_location();
3672 trim_region_to_location (*loc,
_(
"trim to punch"));
3680 begin_reversible_command (str);
3682 for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
3702 if (tav->
track() != 0) {
3714 commit_reversible_command ();
3720 return trim_to_region(
false);
3726 return trim_to_region(
true);
3734 begin_reversible_command (
_(
"trim to region"));
3738 for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
3754 if (atav->
track() != 0) {
3766 next_region = playlist->find_next_region (region->
first_frame(),
Start, 1);
3777 next_region = playlist->find_next_region (region->
first_frame(),
Start, 0);
3791 commit_reversible_command ();
3797 if (clicked_routeview == 0 || !clicked_routeview->is_track()) {
3801 clicked_routeview->track()->unfreeze ();
3807 return static_cast<Editor*
>(arg)->freeze_thread ();
3814 SessionEvent::create_per_thread_pool (
"freeze events", 64);
3816 clicked_routeview->audio_track()->freeze_me (*current_interthread_info);
3817 current_interthread_info->done =
true;
3830 _session->request_transport_speed (0.0);
3834 Glib::usleep (250000);
3836 if (clicked_routeview == 0 || !clicked_routeview->is_audio_track()) {
3840 if (!clicked_routeview->track()->bounceable (clicked_routeview->track()->main_outs(),
true)) {
3842 _(
"This track/bus cannot be frozen because the signal adds or loses channels before reaching the outputs.\n"
3843 "This is typically caused by plugins that generate stereo output from mono input or vice versa.")
3845 d.set_title (
_(
"Cannot freeze"));
3850 if (clicked_routeview->track()->has_external_redirects()) {
3851 MessageDialog d (
string_compose (
_(
"<b>%1</b>\n\nThis track has at least one send/insert/return as part of its signal flow.\n\n"
3852 "Freezing will only process the signal as far as the first send/insert/return."),
3853 clicked_routeview->track()->name()),
true, MESSAGE_INFO, BUTTONS_NONE,
true);
3855 d.add_button (
_(
"Freeze anyway"), Gtk::RESPONSE_OK);
3856 d.add_button (
_(
"Don't freeze"), Gtk::RESPONSE_CANCEL);
3857 d.set_title (
_(
"Freeze Limits"));
3859 int response = d.run ();
3862 case Gtk::RESPONSE_CANCEL:
3870 current_interthread_info = &itt;
3879 gtk_main_iteration ();
3882 current_interthread_info = 0;
3888 if (selection->time.empty()) {
3894 for (TrackViewList::iterator i = views.begin(); i != views.end(); ++i) {
3896 if (enable_processing) {
3902 _(
"You can't perform this operation because the processing of the signal "
3903 "will cause one or more of the tracks to end up with a region with more channels than this track has inputs.\n\n"
3904 "You can do this without processing, which is a different operation.")
3906 d.set_title (
_(
"Cannot bounce"));
3914 framepos_t end = selection->time[clicked_selection].end;
3917 begin_reversible_command (
_(
"bounce range"));
3919 for (TrackViewList::iterator i = views.begin(); i != views.end(); ++i) {
3923 if ((rtv = dynamic_cast<RouteTimeAxisView*> (*i)) == 0) {
3929 if ((playlist = rtv->
playlist()) == 0) {
3940 if (enable_processing) {
3951 list<AudioRange> ranges;
3952 ranges.push_back (
AudioRange (start, start+cnt, 0));
3953 playlist->
cut (ranges);
3957 vector<Command*> cmds;
3958 playlist->
rdiff (cmds);
3959 _session->add_commands (cmds);
3964 commit_reversible_command ();
3973 bool deleted =
false;
3975 deleted = current_mixer_strip->delete_processors ();
4000 if (!selection->time.empty() || !selection->regions.empty() || !selection->points.empty())
4019 opname =
_(
"delete");
4028 opname =
_(
"clear");
4039 if (_drags->active ()) {
4045 cut_buffer->clear ();
4047 if (entered_marker) {
4052 Location* loc = find_location_from_marker (entered_marker, ignored);
4054 if (_session && loc) {
4062 switch (mouse_mode) {
4065 begin_reversible_command (opname +
' ' +
X_(
"MIDI"));
4067 commit_reversible_command ();
4073 bool did_edit =
false;
4075 if (!selection->regions.empty() || !selection->points.empty()) {
4076 begin_reversible_command (opname +
' ' +
_(
"objects"));
4079 if (!selection->regions.empty()) {
4080 cut_copy_regions (op, selection->regions);
4083 selection->clear_regions ();
4087 if (!selection->points.empty()) {
4088 cut_copy_points (op);
4091 selection->clear_points ();
4094 }
else if (selection->time.empty()) {
4099 if (get_edit_op_range (start, end)) {
4100 selection->set (start, end);
4102 }
else if (!selection->time.empty()) {
4103 begin_reversible_command (opname +
' ' +
_(
"range"));
4106 cut_copy_ranges (op);
4109 selection->clear_time ();
4117 commit_reversible_command ();
4140 if (selection->points.empty ()) {
4145 _last_cut_copy_source_track = &selection->points.front()->line().trackview;
4148 typedef std::map<boost::shared_ptr<AutomationList>,
AutomationRecord> Lists;
4152 for (PointSelection::iterator i = selection->points.begin(); i != selection->points.end(); ++i) {
4155 if (lists.find (al) == lists.end ()) {
4163 if (op ==
Cut || op ==
Copy) {
4167 for (Lists::iterator i = lists.begin(); i != lists.end(); ++i) {
4168 i->second.
copy = i->first->
create (i->first->parameter (), i->first->descriptor());
4173 for (PointSelection::iterator i = selection->points.begin(); i != selection->points.end(); ++i) {
4175 AutomationList::const_iterator j = (*i)->model();
4177 lists[al].
copy->fast_simple_add ((*j)->when, (*j)->value);
4183 start = std::min(start, (*i)->line().session_position(j));
4194 if (start == std::numeric_limits<double>::max()) {
4201 for (Lists::iterator i = lists.begin(); i != lists.end(); ++i) {
4206 for (AutomationList::iterator j = i->second.copy->begin(); j != i->second.copy->end(); ++j) {
4207 (*j)->when -= line_offset;
4211 cut_buffer->add (i->second.copy);
4218 for (Lists::iterator i = lists.begin(); i != lists.end(); ++i) {
4219 i->first->freeze ();
4223 for (PointSelection::iterator i = selection->points.begin(); i != selection->points.end(); ++i) {
4225 al->
erase ((*i)->model ());
4229 for (Lists::iterator i = lists.begin(); i != lists.end(); ++i) {
4244 for (MidiRegionSelection::iterator i = selection->midi_regions.begin(); i != selection->midi_regions.end(); ++i) {
4248 earliest = std::min(earliest, (*mrv->
selection().begin())->note()->time());
4257 if (!selection->points.empty()) {
4258 cut_copy_points (op, earliest,
true);
4260 selection->clear_points ();
4282 if (clicked_routeview == 0 || clicked_regionview == 0) {
4286 begin_reversible_command (
_(
"remove region"));
4299 vector<Command*> cmds;
4300 playlist->
rdiff (cmds);
4301 _session->add_commands (cmds);
4304 commit_reversible_command ();
4314 if (!_session || rs.empty()) {
4318 begin_reversible_command (
_(
"remove region"));
4320 list<boost::shared_ptr<Region> > regions_to_remove;
4322 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
4332 regions_to_remove.push_back ((*i)->region());
4335 vector<boost::shared_ptr<Playlist> > playlists;
4351 playlists.push_back (playlist);
4362 vector<boost::shared_ptr<Playlist> >::iterator pl;
4364 for (pl = playlists.begin(); pl != playlists.end(); ++pl) {
4370 vector<Command*> cmds;
4371 (*pl)->rdiff (cmds);
4372 _session->add_commands (cmds);
4377 commit_reversible_command ();
4390 vector<PlaylistMapping> pmap;
4394 typedef set<boost::shared_ptr<Playlist> > FreezeList;
4395 FreezeList freezelist;
4401 for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
4403 first_position = min ((
framepos_t) (*x)->region()->position(), first_position);
4409 FreezeList::iterator fl;
4412 for (fl = freezelist.begin(); fl != freezelist.end(); ++fl) {
4418 if (fl == freezelist.end()) {
4422 freezelist.insert (pl);
4428 vector<PlaylistMapping>::iterator z;
4430 for (z = pmap.begin(); z != pmap.end(); ++z) {
4431 if ((*z).tv == tv) {
4436 if (z == pmap.end()) {
4441 for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ) {
4455 RegionSelection::iterator tmp;
4462 vector<PlaylistMapping>::iterator z;
4464 for (z = pmap.begin(); z != pmap.end(); ++z) {
4465 if ((*z).tv == &tv) {
4470 assert (z != pmap.end());
4473 npl = PlaylistFactory::create (pl->
data_type(), *_session,
"cutlist",
true);
4494 _xx = RegionFactory::create (r);
4518 list<boost::shared_ptr<Playlist> > foo;
4522 for (vector<PlaylistMapping>::iterator i = pmap.begin(); i != pmap.end(); ++i) {
4525 foo.push_back ((*i).pl);
4530 cut_buffer->set (foo);
4534 _last_cut_copy_source_track = 0;
4536 _last_cut_copy_source_track = pmap.front().tv;
4540 for (FreezeList::iterator pl = freezelist.begin(); pl != freezelist.end(); ++pl) {
4546 vector<Command*> cmds;
4547 (*pl)->rdiff (cmds);
4548 _session->add_commands (cmds);
4565 sort_track_selection (ts);
4568 if (!entered_track) {
4571 ts.push_back (entered_track);
4574 for (TrackViewList::iterator i = ts.begin(); i != ts.end(); ++i) {
4575 (*i)->cut_copy_clear (*selection, op);
4584 paste_internal (get_preferred_edit_position (
EDIT_IGNORE_NONE, from_context), times);
4593 if (!mouse_frame (where, ignored)) {
4598 paste_internal (where, 1);
4606 if (cut_buffer->empty(internal_editing())) {
4611 position = get_preferred_edit_position();
4615 if (position == last_paste_pos) {
4627 if (!selection->tracks.empty()) {
4632 sort_track_selection (ts);
4636 if (_edit_point == Editing::EditAtMouse && entered_track) {
4638 base_track = entered_track;
4639 }
else if (_edit_point == Editing::EditAtMouse && entered_regionview) {
4641 base_track = &entered_regionview->get_time_axis_view();
4642 }
else if (_last_cut_copy_source_track) {
4644 base_track = _last_cut_copy_source_track;
4657 for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
4658 if ((*i)->order() >= base_track->
order()) {
4664 sort_track_selection (ts);
4667 for (TrackViewList::iterator i = ts.begin(); i != ts.end();) {
4676 for (ATracks::const_iterator a = atracks.begin(); a != atracks.end(); ++a) {
4677 i = ts.insert(i, a->second.get());
4689 if (ts.size() == 1 && cut_buffer->lines.size() == 1 &&
4695 ts.front()->paste (position, *cut_buffer, ctx);
4702 for (TrackViewList::iterator i = ts.begin(); i != ts.end(); ++i) {
4703 (*i)->paste (position, *cut_buffer, ctx);
4707 commit_reversible_command ();
4722 selection->clear_regions ();
4724 for (RegionSelection::iterator i = sel.begin(); i != sel.end(); ++i) {
4730 latest_regionviews.clear ();
4733 playlist = (*i)->region()->playlist();
4735 playlist->
duplicate (r, end_frame + (r->first_frame() - start_frame), times);
4740 foo.insert (foo.end(), latest_regionviews.begin(), latest_regionviews.end());
4744 selection->set (foo);
4747 commit_reversible_command ();
4753 if (selection->time.empty() || selection->tracks.empty()) {
4758 vector<boost::shared_ptr<Region> > new_regions;
4759 vector<boost::shared_ptr<Region> >::iterator ri;
4761 create_region_from_selection (new_regions);
4763 if (new_regions.empty()) {
4767 begin_reversible_command (
_(
"duplicate selection"));
4769 ri = new_regions.begin();
4773 for (TrackViewList::iterator i = ts.begin(); i != ts.end(); ++i) {
4774 if ((playlist = (*i)->playlist()) == 0) {
4779 if (clicked_selection) {
4780 end = selection->time[clicked_selection].end;
4782 end = selection->time.end_frame();
4788 if (ri == new_regions.end()) {
4793 commit_reversible_command ();
4800 for (PointSelection::iterator i = selection->points.begin(); i != selection->points.end(); ++i) {
4802 (*j)->value = (*i)->line().the_list()->default_value ();
4809 float const page = _visible_canvas_width * samples_per_pixel;
4810 center_screen_internal (playhead_cursor->current_frame (), page);
4816 float const page = _visible_canvas_width * samples_per_pixel;
4817 center_screen_internal (get_preferred_edit_position(), page);
4838 start = get_preferred_edit_position();
4843 if ((distance = get_nudge_distance (start, next_distance)) == 0) {
4847 if (selection->tracks.empty()) {
4851 begin_reversible_command (
_(
"nudge track"));
4855 for (TrackViewList::iterator i = ts.begin(); i != ts.end(); ++i) {
4857 if ((playlist = (*i)->playlist()) == 0) {
4864 playlist->
nudge_after (start, distance, forwards);
4866 vector<Command*> cmds;
4868 playlist->
rdiff (cmds);
4869 _session->add_commands (cmds);
4874 commit_reversible_command ();
4880 vector<string> choices;
4887 if (
Config->get_verify_remove_last_capture()) {
4888 prompt =
_(
"Do you really want to destroy the last capture?"
4889 "\n(This is destructive and cannot be undone)");
4891 choices.push_back (
_(
"No, do nothing."));
4892 choices.push_back (
_(
"Yes, destroy it."));
4896 if (prompter.run () == 1) {
4897 _session->remove_last_capture ();
4898 _regions->redisplay ();
4902 _session->remove_last_capture();
4903 _regions->redisplay ();
4922 if (dialog.run () == RESPONSE_CANCEL) {
4930 int const regions = rs.size ();
4935 list<double> max_amps;
4937 for (RegionSelection::const_iterator i = rs.begin(); i != rs.end(); ++i) {
4940 dialog.descend (1.0 / regions);
4948 max_amps.push_back (a);
4949 max_amp = max (max_amp, a);
4954 begin_reversible_command (
_(
"normalize"));
4956 list<double>::const_iterator a = max_amps.begin ();
4958 for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ++r) {
4966 double const amp = dialog.normalize_individually() ? *a : max_amp;
4974 commit_reversible_command ();
4991 begin_reversible_command (
"reset gain");
4993 for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ++r) {
5002 commit_reversible_command ();
5010 if (!_session || rs.empty()) {
5014 begin_reversible_command (
"adjust region gain");
5016 for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ++r) {
5036 commit_reversible_command ();
5048 apply_filter (rev,
_(
"reverse regions"));
5064 std::list<RegionView*> audio_only;
5066 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
5069 audio_only.push_back (arv);
5074 int const r = d.run ();
5078 if (r == Gtk::RESPONSE_OK) {
5082 apply_filter (s,
_(
"strip silence"), &d);
5092 vector<Evoral::Sequence<Evoral::Beats>::Notes> v;
5093 v.push_back (selected);
5096 Evoral::Beats pos_beats = _session->tempo_map().framewalk_to_beats(0, pos_frames);
5108 begin_reversible_command (op.
name ());
5110 for (RegionSelection::const_iterator r = rs.begin(); r != rs.end(); ) {
5111 RegionSelection::const_iterator tmp = r;
5117 Command* cmd = apply_midi_note_edit_op_to_region (op, *mrv);
5120 _session->add_command (cmd);
5127 commit_reversible_command ();
5139 begin_reversible_command (
_(
"Fork Region(s)"));
5144 for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ) {
5145 RegionSelection::iterator tmp = r;
5167 commit_reversible_command ();
5174 quantize_regions(get_regions_from_selection_and_entered ());
5188 const int r = qd->run ();
5191 if (r == Gtk::RESPONSE_OK) {
5196 apply_midi_note_edit_op (quant, rs);
5204 legatize_regions(get_regions_from_selection_and_entered (), shrink_only);
5216 apply_midi_note_edit_op (legatize, rs);
5223 transform_regions(get_regions_from_selection_and_entered ());
5237 const int r = td->run();
5240 if (r == Gtk::RESPONSE_OK) {
5242 apply_midi_note_edit_op(transform, rs);
5266 if (d.run() == RESPONSE_CANCEL) {
5270 for (RegionSelection::iterator i = rs.begin (); i != rs.end(); ++i) {
5289 begin_reversible_command (command);
5295 int const N = rs.size ();
5297 for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ) {
5298 RegionSelection::iterator tmp = r;
5314 if (filter.
results.empty ()) {
5321 std::vector<boost::shared_ptr<Region> >::iterator res = filter.
results.begin ();
5328 while (res != filter.
results.end()) {
5329 playlist->
add_region (*res, (*res)->position());
5338 vector<Command*> cmds;
5339 playlist->
rdiff (cmds);
5340 _session->add_commands (cmds);
5356 commit_reversible_command ();
5370 if (!_session || rs.empty()) {
5374 begin_reversible_command (
_(
"reset region gain"));
5376 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
5380 XMLNode& before (alist->get_state());
5387 commit_reversible_command ();
5406 for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
5417 if (_ignore_region_action) {
5423 if (!_session || rs.empty()) {
5427 begin_reversible_command (
_(
"region gain envelope active"));
5429 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
5438 commit_reversible_command ();
5444 if (_ignore_region_action) {
5450 if (!_session || rs.empty()) {
5454 begin_reversible_command (
_(
"toggle region lock"));
5456 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
5457 (*i)->region()->clear_changes ();
5458 (*i)->region()->set_locked (!(*i)->region()->locked());
5462 commit_reversible_command ();
5468 if (_ignore_region_action) {
5474 if (!_session || rs.empty()) {
5478 begin_reversible_command (
_(
"Toggle Video Lock"));
5480 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
5481 (*i)->region()->clear_changes ();
5482 (*i)->region()->set_video_locked (!(*i)->region()->video_locked());
5486 commit_reversible_command ();
5492 if (_ignore_region_action) {
5498 if (!_session || rs.empty()) {
5502 begin_reversible_command (
_(
"region lock style"));
5504 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
5505 (*i)->region()->clear_changes ();
5507 (*i)->region()->set_position_lock_style (ns);
5511 commit_reversible_command ();
5517 if (_ignore_region_action) {
5523 if (!_session || rs.empty()) {
5527 begin_reversible_command (
_(
"change region opacity"));
5529 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
5530 (*i)->region()->clear_changes ();
5531 (*i)->region()->set_opaque (!(*i)->region()->opaque());
5535 commit_reversible_command ();
5541 bool new_state =
false;
5543 for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
5562 bool new_state =
false;
5566 for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
5578 rl->push_back (rtav->
route());
5581 _session->set_solo (rl, new_state, Session::rt_cleanup,
true);
5587 bool new_state =
false;
5591 for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
5603 rl->push_back (rtav->
route());
5606 _session->set_mute (rl, new_state, Session::rt_cleanup,
true);
5620 begin_reversible_command (
_(
"fade range"));
5622 for (TrackViewList::iterator i = ts.begin(); i != ts.end(); ++i) {
5623 (*i)->fade_range (selection->time);
5626 commit_reversible_command ();
5643 framepos_t pos = get_preferred_edit_position();
5653 if (pos <= rv->region()->position()) {
5658 cmd =
_(
"set fade in length");
5665 cmd =
_(
"set fade out length");
5668 begin_reversible_command (cmd);
5670 for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
5698 commit_reversible_command ();
5710 begin_reversible_command (
_(
"set fade in shape"));
5712 for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
5728 commit_reversible_command ();
5741 begin_reversible_command (
_(
"set fade out shape"));
5743 for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
5759 commit_reversible_command ();
5771 begin_reversible_command (
_(
"set fade in active"));
5773 for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
5784 ar->set_fade_in_active (yn);
5788 commit_reversible_command ();
5800 begin_reversible_command (
_(
"set fade out active"));
5802 for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
5812 ar->set_fade_out_active (yn);
5816 commit_reversible_command ();
5822 if (_ignore_region_action) {
5835 RegionSelection::iterator i;
5836 for (i = rs.begin(); i != rs.end(); ++i) {
5837 if ((ar = boost::dynamic_pointer_cast<AudioRegion>((*i)->region())) != 0) {
5847 if (i == rs.end()) {
5853 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
5854 if ((ar = boost::dynamic_pointer_cast<AudioRegion>((*i)->region())) == 0) {
5857 if (dir == 1 || dir == 0) {
5861 if (dir == -1 || dir == 0) {
5872 bool _fade_visibility = _session->config.get_show_region_fades ();
5874 for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
5877 if (_fade_visibility) {
5892 if (!mouse_frame (where, ignored)) {
5898 if (selection->markers.empty()) {
5900 mouse_add_new_marker (where);
5905 Location* loc = find_location_from_marker (selection->markers.front(), ignored);
5916 if (entered_marker) {
5917 _session->request_locate (entered_marker->position(), _session->transport_rolling());
5922 if (!mouse_frame (where, ignored)) {
5929 _session->request_locate (where, _session->transport_rolling());
5934 cancel_time_selection();
5942 if ( !selection->time.empty()) {
5943 separate_regions_between (selection->time);
5948 if (current_mouse_mode() == MouseObject) {
5952 framepos_t where = get_preferred_edit_position ();
5958 split_regions_at (where, rs);
5971 if (selection->tracks.empty()) {
5972 selection->set (track_views.front());
5980 for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
5981 if (*i == current) {
5983 if (i != track_views.end()) {
5986 current = (*(track_views.begin()));
5992 rui =
dynamic_cast<RouteUI *
>(current);
5995 selection->set(current);
5997 ensure_time_axis_view_is_visible (*current,
false);
6003 if (selection->tracks.empty()) {
6004 selection->set (track_views.front());
6012 for (TrackViewList::reverse_iterator i = track_views.rbegin(); i != track_views.rend(); ++i) {
6013 if (*i == current) {
6015 if (i != track_views.rend()) {
6018 current = *(track_views.rbegin());
6023 rui =
dynamic_cast<RouteUI *
>(current);
6026 selection->set (current);
6028 ensure_time_axis_view_is_visible (*current,
false);
6034 if (_session == 0) {
6039 if (!get_selection_extents ( start, end))
6042 set_loop_range (start, end,
_(
"set loop range from selection"));
6045 _session->request_play_loop (
true,
true);
6053 if (!get_selection_extents ( start, end))
6056 set_loop_range (start, end,
_(
"set loop range from region"));
6059 _session->request_locate (start,
true);
6060 _session->request_play_loop (
true);
6067 if (_session == 0) {
6072 if (!get_selection_extents ( start, end))
6075 set_punch_range (start, end,
_(
"set punch range from selection"));
6081 if (_session == 0) {
6086 if (!get_selection_extents ( start, end))
6090 if ((loc = _session->locations()->session_range_location()) == 0) {
6091 _session->set_session_extents ( start, end );
6095 _session->set_session_extents ( start, end );
6099 begin_reversible_command (
_(
"set session start/end from selection"));
6103 commit_reversible_command ();
6111 if (!get_selection_extents ( start, end))
6114 set_punch_range (start, end,
_(
"set punch range from region"));
6123 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
6124 if (dynamic_cast<AudioRegionView*> (*i)) {
6125 audio_rs.push_back (*i);
6129 if (audio_rs.empty()) {
6133 pitch_shift (audio_rs, 1.2);
6141 list<MidiRegionView*> midi_region_views;
6142 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
6145 midi_region_views.push_back (mrv);
6150 int const r = d.run ();
6151 if (r != RESPONSE_ACCEPT) {
6155 for (list<MidiRegionView*>::iterator i = midi_region_views.begin(); i != midi_region_views.end(); ++i) {
6156 (*i)->midi_region()->transpose (d.
semitones ());
6165 if (!_session || rs.empty()) {
6178 if (get_edit_op_range (start, end)) {
6179 define_one_bar (start, end);
6188 const Meter& m (_session->tempo_map().meter_at (start));
6202 double beats_per_minute = (_session->frame_rate() * 60.0) / frames_per_beat;
6211 const TempoSection& t (_session->tempo_map().tempo_section_at (start));
6213 bool do_global =
false;
6215 if ((_session->tempo_map().n_tempos() == 1) && (_session->tempo_map().n_meters() == 1)) {
6221 vector<string> options;
6222 options.push_back (
_(
"Cancel"));
6223 options.push_back (
_(
"Add new marker"));
6224 options.push_back (
_(
"Set global tempo"));
6227 _(
"Define one bar"),
6228 _(
"Do you want to set the global tempo or add a new tempo marker?"),
6232 c.set_default_response (2);
6254 begin_reversible_command (
_(
"set tempo from region"));
6255 XMLNode& before (_session->tempo_map().get_state());
6258 _session->tempo_map().change_initial_tempo (beats_per_minute, t.note_type());
6259 }
else if (t.frame() ==
start) {
6260 _session->tempo_map().change_existing_tempo_at (start, beats_per_minute, t.note_type());
6262 Timecode::BBT_Time bbt;
6263 _session->tempo_map().bbt_time (start, bbt);
6264 _session->tempo_map().add_tempo (
Tempo (beats_per_minute, t.note_type()), bbt);
6267 XMLNode& after (_session->tempo_map().get_state());
6270 commit_reversible_command ();
6280 if (!_session || rs.empty()) {
6284 begin_reversible_command (
_(
"split regions"));
6286 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ) {
6288 RegionSelection::iterator tmp;
6296 split_region_at_points ((*i)->region(), positions,
true);
6303 commit_reversible_command ();
6310 bool use_rhythmic_rodent =
false;
6314 list<boost::shared_ptr<Region> > new_regions;
6320 if (positions.empty()) {
6325 if (positions.size() > 20 && can_ferret) {
6326 std::string msgstr =
string_compose (
_(
"You are about to split\n%1\ninto %2 pieces.\nThis could take a long time."), r->
name(), positions.size() + 1);
6327 MessageDialog msg (msgstr,
6330 Gtk::BUTTONS_OK_CANCEL);
6333 msg.add_button (
_(
"Call for the Ferret!"), RESPONSE_APPLY);
6334 msg.set_secondary_text (
_(
"Press OK to continue with this split operation\nor ask the Ferret dialog to tune the analysis"));
6336 msg.set_secondary_text (
_(
"Press OK to continue with this split operation"));
6339 msg.set_title (
_(
"Excessive split?"));
6342 int response = msg.run();
6348 case RESPONSE_APPLY:
6349 use_rhythmic_rodent =
true;
6356 if (use_rhythmic_rodent) {
6357 show_rhythm_ferret ();
6361 AnalysisFeatureList::const_iterator x;
6366 x = positions.begin();
6368 if (x == positions.end()) {
6377 while (x != positions.end()) {
6380 if (*x <= 0 || *x > r->
length()) {
6405 if (RegionFactory::region_name (new_name, r->
name())) {
6422 RegionFactory::map_add (nr);
6427 new_regions.push_front(nr);
6436 RegionFactory::region_name (new_name, r->
name());
6450 RegionFactory::map_add (nr);
6454 new_regions.push_front(nr);
6462 vector<Command*> cmds;
6464 _session->add_commands (cmds);
6489 framepos_t where = get_preferred_edit_position();
6491 begin_reversible_command (
_(
"place transient"));
6493 for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ++r) {
6495 (*r)->region()->add_transient(where - position);
6498 commit_reversible_command ();
6508 ArdourCanvas::Line* _line =
reinterpret_cast<ArdourCanvas::Line*
> (item);
6518 list <boost::shared_ptr<Playlist > > used_playlists;
6522 if (!_session || rs.empty()) {
6526 begin_reversible_command (
_(
"snap regions to grid"));
6528 for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ++r) {
6536 used_playlists.push_back(pl);
6540 framepos_t start_frame = (*r)->region()->first_frame ();
6541 snap_to (start_frame);
6542 (*r)->region()->set_position (start_frame);
6545 while (used_playlists.size() > 0) {
6546 list <boost::shared_ptr<Playlist > >::iterator i = used_playlists.begin();
6548 used_playlists.pop_front();
6551 commit_reversible_command ();
6557 list <boost::shared_ptr<Playlist > > used_playlists;
6561 if (!_session || rs.empty()) {
6565 Dialog dialog (
_(
"Close Region Gaps"));
6568 table.set_spacings (12);
6569 table.set_border_width (12);
6571 table.attach (*l, 0, 1, 0, 1);
6573 SpinButton spin_crossfade (1, 0);
6574 spin_crossfade.set_range (0, 15);
6575 spin_crossfade.set_increments (1, 1);
6576 spin_crossfade.set_value (5);
6577 table.attach (spin_crossfade, 1, 2, 0, 1);
6579 table.attach (*manage (
new Label (
_(
"ms"))), 2, 3, 0, 1);
6582 table.attach (*l, 0, 1, 1, 2);
6584 SpinButton spin_pullback (1, 0);
6585 spin_pullback.set_range (0, 100);
6586 spin_pullback.set_increments (1, 1);
6587 spin_pullback.set_value(30);
6588 table.attach (spin_pullback, 1, 2, 1, 2);
6590 table.attach (*manage (
new Label (
_(
"ms"))), 2, 3, 1, 2);
6592 dialog.get_vbox()->pack_start (table);
6593 dialog.add_button (Stock::CANCEL, RESPONSE_CANCEL);
6594 dialog.add_button (
_(
"Ok"), RESPONSE_ACCEPT);
6597 if (dialog.run () == RESPONSE_CANCEL) {
6601 framepos_t crossfade_len = spin_crossfade.get_value();
6602 framepos_t pull_back_frames = spin_pullback.get_value();
6604 crossfade_len = lrintf (crossfade_len * _session->frame_rate()/1000);
6605 pull_back_frames = lrintf (pull_back_frames * _session->frame_rate()/1000);
6609 begin_reversible_command (
_(
"close region gaps"));
6616 for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ++r) {
6624 used_playlists.push_back(pl);
6630 if (idx == 0 || position < last_region->
position()){
6631 last_region = (*r)->region();
6636 (*r)->region()->
trim_front( (position - pull_back_frames));
6637 last_region->
trim_end( (position - pull_back_frames + crossfade_len));
6639 last_region = (*r)->region();
6644 while (used_playlists.size() > 0) {
6645 list <boost::shared_ptr<Playlist > >::iterator i = used_playlists.begin();
6647 used_playlists.pop_front();
6650 commit_reversible_command ();
6666 if (!selection->tracks.empty()) {
6673 for (TrackViewList::iterator t = ts.begin(); t != ts.end(); ++t) {
6685 positions.push_back (result);
6698 for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ++r) {
6699 (*r)->region()->get_transients (positions);
6703 TransientDetector::cleanup_transients (positions, _session->frame_rate(), 3.0);
6706 AnalysisFeatureList::iterator x;
6708 for (x = positions.begin(); x != positions.end(); ++x) {
6714 if (x != positions.end ()) {
6715 _session->request_locate (*x);
6719 AnalysisFeatureList::reverse_iterator x;
6721 for (x = positions.rbegin(); x != positions.rend(); ++x) {
6727 if (x != positions.rend ()) {
6728 _session->request_locate (*x);
6740 framepos_t pos = playhead_cursor->current_frame ();
6744 _session->request_locate (pos);
6756 framepos_t pos = playhead_cursor->current_frame ();
6760 _session->request_locate (pos);
6769 for (TrackSelection::iterator x = ts.begin(); x != ts.end(); ++x) {
6770 (*x)->set_height_enum (h);
6779 bool target =
false;
6785 for (TrackSelection::iterator x = ts.begin(); x != ts.end(); ++x) {
6824 vector<string> choices;
6828 const char* trackstr;
6830 vector<boost::shared_ptr<Route> > routes;
6831 bool special_bus =
false;
6833 for (TrackSelection::iterator x = ts.begin(); x != ts.end(); ++x) {
6843 routes.push_back (rtv->
_route);
6850 if (special_bus && !
Config->get_allow_special_bus_removal()) {
6851 MessageDialog msg (
_(
"That would be bad news ...."),
6856 "Removing the master or monitor bus is such a bad idea\n\
6857 that %1 is not going to allow it.\n\
6859 If you really want to do this sort of thing\n\
6860 edit your ardour.rc file to set the\n\
6861 \"allow-special-bus-removal\" option to be \"yes\""), PROGRAM_NAME));
6868 if (ntracks + nbusses == 0) {
6872 trackstr =
P_(
"track",
"tracks", ntracks);
6873 busstr =
P_(
"bus",
"busses", nbusses);
6877 prompt =
string_compose (
_(
"Do you really want to remove %1 %2 and %3 %4?\n"
6878 "(You may also lose the playlists associated with the %2)\n\n"
6879 "This action cannot be undone, and the session file will be overwritten!"),
6880 ntracks, trackstr, nbusses, busstr);
6883 "(You may also lose the playlists associated with the %2)\n\n"
6884 "This action cannot be undone, and the session file will be overwritten!"),
6887 }
else if (nbusses) {
6889 "This action cannot be undone, and the session file will be overwritten"),
6893 choices.push_back (
_(
"No, do nothing."));
6894 if (ntracks + nbusses > 1) {
6895 choices.push_back (
_(
"Yes, remove them."));
6897 choices.push_back (
_(
"Yes, remove it."));
6907 Choice prompter (title, prompt, choices);
6909 if (prompter.run () != 1) {
6917 _session->remove_route (*x);
6925 if (selection->tracks.empty()) {
6930 int response = d.run ();
6932 if (response != RESPONSE_OK) {
6943 get_preferred_edit_position(),
6958 bool all_playlists,
bool ignore_music_glue,
bool markers_too,
bool glued_markers_too,
bool locked_markers_too,
bool tempo_too
6961 bool commit =
false;
6967 begin_reversible_command (
_(
"insert time"));
6971 for (TrackViewList::iterator x = ts.begin(); x != ts.end(); ++x) {
6980 set<boost::shared_ptr<Playlist> > pl;
6982 if (all_playlists) {
6985 vector<boost::shared_ptr<Playlist> > all = _session->playlists->playlists_for_track (rtav->
track ());
6991 if ((*x)->playlist ()) {
6992 pl.insert ((*x)->playlist ());
6998 (*i)->clear_changes ();
6999 (*i)->clear_owned_changes ();
7001 if (opt == SplitIntersected) {
7005 (*i)->shift (pos, frames, (opt == MoveIntersected), ignore_music_glue);
7007 vector<Command*> cmds;
7009 _session->add_commands (cmds);
7026 XMLNode& before (_session->locations()->get_state());
7029 for (Locations::LocationList::iterator i = copy.begin(); i != copy.end(); ++i) {
7031 Locations::LocationList::const_iterator tmp;
7033 bool const was_locked = (*i)->locked ();
7034 if (locked_markers_too) {
7038 if ((*i)->position_lock_style() ==
AudioTime || glued_markers_too) {
7040 if ((*i)->start() >= pos) {
7041 (*i)->set_start ((*i)->start() + frames);
7042 if (!(*i)->is_mark()) {
7043 (*i)->set_end ((*i)->end() + frames);
7056 XMLNode& after (_session->locations()->get_state());
7062 _session->tempo_map().insert_time (pos, frames);
7066 commit_reversible_command ();
7072 if (selection->tracks.empty()) {
7078 VButtonBox button_box;
7081 CheckButton glue_button (
_(
"Move Glued Regions")); glue_button.set_active();
7082 CheckButton marker_button (
_(
"Move Markers")); marker_button.set_active();
7083 CheckButton tempo_button (
_(
"Move Tempo & Meters")); tempo_button.set_active();
7084 AudioClock clock (
"cutTimeClock",
true,
"",
true,
false,
true,
false);
7091 clock_box.pack_start (clock,
false,
true);
7093 option_box.set_spacing (6);
7094 option_box.pack_start (button_box,
false,
false);
7095 option_box.pack_start (glue_button,
false,
false);
7096 option_box.pack_start (marker_button,
false,
false);
7097 option_box.pack_start (tempo_button,
false,
false);
7099 d.get_vbox()->set_border_width (12);
7100 d.get_vbox()->pack_start (clock_box,
false,
false);
7101 d.get_vbox()->pack_start (option_box,
false,
false);
7105 glue_button.show ();
7108 marker_button.show ();
7109 tempo_button.show ();
7111 d.add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
7112 d.add_button (Gtk::Stock::OK, Gtk::RESPONSE_OK);
7115 int response = d.run ();
7117 if (response != RESPONSE_OK) {
7123 if (distance == 0) {
7127 cut_time (pos, distance, SplitIntersected, glue_button.get_active(), marker_button.get_active(), tempo_button.get_active());
7132 bool ignore_music_glue,
bool markers_too,
bool tempo_too)
7134 bool commit =
false;
7137 error << (
_(
"Cannot insert or delete time when in Lock edit.")) <<
endmsg;
7141 begin_reversible_command (
_(
"cut time"));
7143 for (TrackSelection::iterator x = selection->tracks.begin(); x != selection->tracks.end(); ++x) {
7151 std::list<AudioRange> rl;
7155 pl->
shift (pos, -frames,
true, ignore_music_glue);
7171 std::list<Location*> loc_kill_list;
7176 XMLNode& before (_session->locations()->get_state());
7179 for (Locations::LocationList::iterator i = copy.begin(); i != copy.end(); ++i) {
7181 if (!(*i)->is_mark()) {
7182 if ((*i)->end() >= pos
7183 && (*i)->end() < pos+frames
7184 && (*i)->start() >= pos
7185 && (*i)->end() < pos+frames) {
7187 loc_kill_list.push_back(*i);
7189 if ((*i)->end() >= pos && (*i)->end() < pos+frames) {
7190 (*i)->set_end (pos);
7192 }
else if ((*i)->end() >= pos) {
7193 (*i)->set_end ((*i)->end()-frames);
7196 if ((*i)->start() >= pos && (*i)->start() < pos+frames) {
7197 (*i)->set_start (pos);
7199 }
else if ((*i)->start() >= pos) {
7200 (*i)->set_start ((*i)->start() -frames);
7204 }
else if ((*i)->start() >= pos && (*i)->start() < pos+frames ) {
7205 loc_kill_list.push_back(*i);
7207 }
else if ((*i)->start() >= pos) {
7208 (*i)->set_start ((*i)->start() -frames);
7213 for (list<Location*>::iterator i = loc_kill_list.begin(); i != loc_kill_list.end(); ++i) {
7214 _session->locations()->remove( *i );
7218 XMLNode& after (_session->locations()->get_state());
7225 XMLNode& before (_session->tempo_map().get_state());
7227 if (_session->tempo_map().cut_time (pos, frames) ) {
7228 XMLNode& after (_session->tempo_map().get_state());
7235 commit_reversible_command ();
7242 if (!selection->tracks.empty()) {
7243 fit_tracks (selection->tracks);
7249 if (!selection->regions.empty()) {
7250 for (RegionSelection::iterator r = selection->regions.begin(); r != selection->regions.end(); ++r) {
7251 tvl.push_back (&(*r)->get_time_axis_view ());
7257 }
else if (internal_editing()) {
7261 if (entered_track) {
7262 tvl.push_back (entered_track);
7273 if (tracks.empty()) {
7277 uint32_t child_heights = 0;
7278 int visible_tracks = 0;
7280 for (TrackSelection::iterator t = tracks.begin(); t != tracks.end(); ++t) {
7282 if (!(*t)->marked_for_display()) {
7286 child_heights += (*t)->effective_height() - (*t)->current_height();
7296 uint32_t h = (uint32_t) floor ((trackviews_height() - child_heights) / visible_tracks);
7297 double first_y_pos = DBL_MAX;
7300 MessageDialog msg (*
this,
_(
"There are too many tracks to fit in the current window"));
7305 undo_visual_stack.push_back (current_visual_state (
true));
7311 for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
7314 for (TimeAxisView::Children::iterator j = c.begin(); j != c.end(); ++j) {
7315 all.push_back (j->get());
7323 int selected_top = -1;
7324 int selected_bottom = -1;
7326 for (TrackViewList::iterator t = all.begin(); t != all.end(); ++t, ++i) {
7327 if ((*t)->marked_for_display ()) {
7329 if (selected_top == -1) {
7332 selected_bottom = i;
7338 for (TrackViewList::iterator t = all.begin(); t != all.end(); ++t, ++i) {
7339 if ((*t)->marked_for_display ()) {
7341 (*t)->set_height (h);
7342 first_y_pos = std::min ((*t)->y_position (), first_y_pos);
7344 if (i > selected_top && i < selected_bottom) {
7345 hide_track_in_display (*t);
7356 controls_layout.property_height () = _full_canvas_height;
7357 vertical_adjustment.set_value (first_y_pos);
7359 redo_visual_stack.push_back (current_visual_state (
true));
7361 visible_tracks_selector.set_text (
_(
"Sel"));
7367 while (visual_states.size() <= n) {
7368 visual_states.push_back (0);
7371 if (visual_states[n] != 0) {
7372 delete visual_states[n];
7375 visual_states[n] = current_visual_state (
true);
7382 if (visual_states.size() <= n) {
7386 if (visual_states[n] == 0) {
7390 use_visual_state (*visual_states[n]);
7396 save_visual_state (n);
7398 PopUp* pup =
new PopUp (WIN_POS_MOUSE, 1000,
true);
7400 snprintf (buf,
sizeof (buf),
_(
"Saved view %u"), n+1);
7408 goto_visual_state (n);
7414 if (_ignore_region_action) {
7424 if (rs.size() > 1) {
7425 begin_reversible_command (
_(
"mute regions"));
7427 begin_reversible_command (
_(
"mute region"));
7430 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
7432 (*i)->region()->playlist()->clear_changes ();
7433 (*i)->region()->set_muted (!(*i)->region()->muted ());
7438 commit_reversible_command ();
7449 typedef set<RouteTimeAxisView*> RTVS;
7452 if (selection->regions.empty()) {
7456 for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
7460 tracks.insert (rtv);
7464 begin_reversible_command (
_(
"combine regions"));
7466 vector<RegionView*> new_selection;
7468 for (RTVS::iterator i = tracks.begin(); i != tracks.end(); ++i) {
7471 if ((rv = (*i)->combine_regions ()) != 0) {
7472 new_selection.push_back (rv);
7476 selection->clear_regions ();
7477 for (vector<RegionView*>::iterator i = new_selection.begin(); i != new_selection.end(); ++i) {
7478 selection->add (*i);
7481 commit_reversible_command ();
7487 typedef set<RouteTimeAxisView*> RTVS;
7490 if (selection->regions.empty()) {
7494 for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
7498 tracks.insert (rtv);
7502 begin_reversible_command (
_(
"uncombine regions"));
7504 for (RTVS::iterator i = tracks.begin(); i != tracks.end(); ++i) {
7505 (*i)->uncombine_regions ();
7508 commit_reversible_command ();
7517 for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
7527 rl->push_back (rtav->
route());
7532 _session->set_exclusive_input_active (rl, onoff, flip_others);
7539 lock_dialog =
new Gtk::Dialog (
string_compose (
_(
"%1: Locked"), PROGRAM_NAME),
true);
7542 lock_dialog->get_vbox()->pack_start (*padlock);
7545 b->set_name (
"lock button");
7548 lock_dialog->get_vbox()->pack_start (*b);
7550 lock_dialog->get_vbox()->show_all ();
7551 lock_dialog->set_size_request (200, 200);
7562 lock_dialog->present ();
7568 lock_dialog->hide ();
7575 start_lock_event_timing ();
7588 label->set_text (
string_compose (
"Copying %1, %2 of %3", name, n, total));
7600 ArdourDialog w (
_(
"Moving embedded files into session folder"));
7601 w.get_vbox()->pack_start (msg);
MidiTimeAxisView * midi_view() const
void set_region_gain_visibility(RegionView *)
void selected_marker_to_selection_end()
boost::shared_ptr< ARDOUR::Playlist > playlist() const
void set_record_enabled(bool yn, void *src)
void raise_region_to_top()
LIBPBD_API Transmitter fatal
void ripple(framepos_t at, framecnt_t distance, RegionList *exclude)
bool scroll_up_one_track(bool skip_child_views=false)
void cut_copy_points(Editing::CutCopyOp, Evoral::Beats earliest=Evoral::Beats(), bool midi=false)
void set_session_extents_from_selection()
void show_midi_list_editor()
Beats round_down_to_beat() const
void add_location_mark(framepos_t where)
void scroll_tracks_up_line()
TimeAxisView & get_time_axis_view() const
void split_region_at_transients()
std::multiset< NotePtr, EarlierNoteComparator > Notes
void trim_front(framepos_t new_position)
void set_session_start_from_playhead()
void nudge_track(bool use_edit_point, bool forwards)
boost::shared_ptr< ARDOUR::MidiTrack > midi_track() const
void set(framepos_t, bool force=false, ARDOUR::framecnt_t offset=0)
void jump_backward_to_mark()
ARDOUR::framepos_t find_next_region_boundary(ARDOUR::framepos_t, int32_t dir, const TrackViewList &)
bool can_cut_copy() const
void sort_by_position_and_track()
void cursor_to_previous_region_point(EditorCursor *, ARDOUR::RegionPoint)
TimeAxisView * get_parent()
void set_session(ARDOUR::Session *s)
void set_fade_out_length(framecnt_t)
std::list< Location * > LocationList
void selected_marker_to_next_region_point(ARDOUR::RegionPoint)
void trim_region(bool front)
void duplicate_some_regions(RegionSelection &, float times)
LIBARDOUR_API PBD::PropertyDescriptor< layer_t > layer
void toggle_record_enable()
void cursor_align(bool playhead_to_edit)
void toggle_opaque_region()
sigc::signal< void, RegionView * > RegionViewAdded
void reset_region_scale_amplitude()
void new_region_from_selection()
void set_envelope_active(bool yn)
void pitch_shift_region()
void tav_zoom_smooth(bool coarser, bool force_all)
void separate_regions_between(const TimeSelection &)
bool idle_remove_tracks()
const DataType & data_type() const
virtual void set_height(uint32_t h, TrackHeightMode m=OnlySelf)
void transition_to_rolling(bool forward)
shared_ptr< T > dynamic_pointer_cast(shared_ptr< U > const &r)
void set_playhead_cursor()
TrackViewList get_tracks_for_range_action() const
framepos_t end_frame() const
LIBARDOUR_API PBD::PropertyDescriptor< std::string > name
boost::shared_ptr< ARDOUR::AutomationList > the_list() const
XMLNode & state(bool full)
boost::shared_ptr< AutomationList > fade_in()
void audition_playlist_region_via_route(boost::shared_ptr< ARDOUR::Region >, ARDOUR::Route &)
void trim_region_to_punch()
void scroll_tracks_down_line()
std::vector< boost::shared_ptr< TimeAxisView > > Children
void set_fade_length(bool in)
void cut_copy_regions(Editing::CutCopyOp, RegionSelection &)
virtual void clear(bool with_signals=true)
void toggle_region_fades(int dir)
void align_regions_relative(ARDOUR::RegionPoint point)
Dialog box to set options for the `strip silence' filter.
void remove_region(boost::shared_ptr< Region >)
const SourceList & sources() const
Always round up, even if on a division.
void legatize_region(bool shrink_only)
static void * _freeze_thread(void *)
void set_punch_from_selection()
void temporal_zoom(framecnt_t samples_per_pixel)
boost::shared_ptr< AutomationList > fade_out()
void quantize_regions(const RegionSelection &rs)
ARDOUR::framecnt_t fade_length() const
LIBARDOUR_API GQuark region_fill
size_t n_midi_regions() const
void toggle_region_video_lock()
void remove_location_at_playhead_cursor()
LIBPBD_API Transmitter error
void toggle_region_mute()
void clear_owned_changes()
void align_region_internal(boost::shared_ptr< ARDOUR::Region >, ARDOUR::RegionPoint point, framepos_t position)
void cursor_to_region_point(EditorCursor *, ARDOUR::RegionPoint, int32_t dir)
LIBARDOUR_API GQuark paste
ARDOUR::InstrumentInfo & instrument_info() const
boost::shared_ptr< MidiRegion > clone(std::string path=std::string()) const
LIBARDOUR_API GQuark duplicate_region
void add_locations_from_region()
const AutomationTracks & automation_tracks() const
virtual void step_height(bool)
void selected_marker_to_selection_start()
std::ostream & endmsg(std::ostream &ostr)
void insert_region_list_selection(float times)
const AutomationLine * line
line this came from
void temporal_zoom_step(bool coarser)
#define P_(Singular, Plural, HowMany)
StreamView * view() const
boost::shared_ptr< ARDOUR::AudioRegion > audio_region() const
LIBARDOUR_API PBD::PropertyDescriptor< framepos_t > start
int move_to(framepos_t pos)
void insert_time(framepos_t, framecnt_t, Editing::InsertTimeOption, bool, bool, bool, bool, bool, bool)
void audition_playlist_region_standalone(boost::shared_ptr< ARDOUR::Region >)
bool get_selection_extents(framepos_t &start, framepos_t &end)
uint32_t current_height() const
LIBPBD_API void strip_whitespace_edges(std::string &str)
void by_position(std::list< RegionView * > &) const
#define ENSURE_GUI_THREAD(obj, method,...)
void cut_time(framepos_t pos, framecnt_t distance, Editing::InsertTimeOption opt, bool ignore_music_glue, bool markers_too, bool tempo_too)
double start_grid_size() const
void cursor_to_previous_region_boundary(bool with_selection)
bool fade_in_active() const
void selected_marker_to_region_point(ARDOUR::RegionPoint, int32_t dir)
void thaw(bool from_undo=false)
void remove_transient(float pos)
void external_edit_region()
framepos_t sync_position() const
void set_initial_text(std::string txt)
void cut_copy_ranges(Editing::CutCopyOp)
bool empty(bool internal_selection=false)
static float accurate_coefficient_to_dB(float coeff)
void cut_copy_clear(Editing::CutCopyOp)
void update_envelope_visibility()
std::map< boost::shared_ptr< ARDOUR::Region >, AudioIntervalResult > AudioIntervalMap
void selected_marker_to_previous_region_boundary(bool with_selection)
static Handle create(Editor &editor, Gdk::Cursor *cursor)
void update_bring_in_message(Gtk::Label *label, uint32_t n, uint32_t total, std::string name)
void region_changed(const PBD::PropertyChange &)
void nudge_forward_capture_offset()
void trim_region_to_location(const ARDOUR::Location &, const char *cmd)
void selected_marker_to_region_boundary(bool with_selection, int32_t dir)
static void add_if_covered(RegionView *rv, const AudioRange *ar, RegionSelection *rs)
void nudge_backward(bool next, bool force_playhead)
void set_fade_out_shape(FadeShape)
Selection selection() const
void set_track_height(Height)
void maybe_locate_with_edit_preroll(framepos_t)
void set_punch_from_region()
LIBGTKMM2EXT_API void disable_all_actions()
void trim_end(framepos_t new_position)
void toggle_region_lock_style()
void bounce_range_selection(bool replace, bool enable_processing)
void duplicate_selection(float times)
ArdourCanvas::PolyLine * line
boost::shared_ptr< ARDOUR::Route > _route
boost::shared_ptr< AutomationList > envelope()
LIBGTKMM2EXT_API uint64_t Keyboard
framepos_t current_frame() const
void set_fade_in_shape(ARDOUR::FadeShape)
void add_region(boost::shared_ptr< Region >, framepos_t position, float times=1, bool auto_partition=false)
void foreach_regionview(sigc::slot< void, RegionView * > slot)
A filter to strip silence from regions.
void temporal_zoom_region(bool both_axes)
void bring_all_sources_into_session()
void cut_copy(Editing::CutCopyOp)
uint32_t order_key() const
void partition(framepos_t start, framepos_t end, bool cut=false)
LIBARDOUR_API RCConfiguration * Config
void set_position(framepos_t)
void cursor_to_selection_end(EditorCursor *)
int set(framepos_t start, framepos_t end, bool allow_bbt_recompute=true)
double maximum_amplitude(Progress *p=0) const
void define_one_bar(framepos_t start, framepos_t end)
const std::list< RegionView * > & by_layer() const
void set_fade_out_active(bool)
boost::shared_ptr< ARDOUR::Region > region() const
void set_prompt(std::string prompt)
void show_region_properties()
void set_position(framepos_t)
std::list< framepos_t > AnalysisFeatureList
void replace_region(boost::shared_ptr< Region > old, boost::shared_ptr< Region > newr, framepos_t pos)
PlaylistMapping(TimeAxisView *tvp)
void region_from_selection()
boost::shared_ptr< Region > top_region_at(framepos_t frame)
void play_from_edit_point()
void move_range_selection_start_or_end_to_region_boundary(bool, bool)
const boost::shared_ptr< ARDOUR::MidiRegion > midi_region() const
void selection_as_notelist(Notes &selected, bool allow_all_if_none_selected=false)
void remove_clicked_region()
void region_fill_selection()
bool fade_out_active() const
LIBARDOUR_API GQuark fill_selection
boost::shared_ptr< Delivery > main_outs() const
Round down only if necessary.
void shift(framepos_t, framecnt_t)
void scroll_tracks_down()
void toggle_solo_isolate()
void remove_region_sync()
void nudge_backward_capture_offset()
void set_solo(bool yn, void *src)
virtual boost::shared_ptr< ControlList > create(const Parameter &id, const ParameterDescriptor &desc)
void set_fade_in_length(framecnt_t)
void cursor_to_region_boundary(bool with_selection, int32_t dir)
gain_t scale_amplitude() const
void temporal_zoom_to_frame(bool coarser, framepos_t frame)
boost::shared_ptr< ARDOUR::Track > track() const
void legatize_regions(const RegionSelection &rs, bool shrink_only)
AutomationRecord(XMLNode *s, const AutomationLine *l)
void scroll_forward(float pages=0.8f)
void split_multichannel_region()
void split_region_at_points(boost::shared_ptr< ARDOUR::Region >, ARDOUR::AnalysisFeatureList &, bool can_ferret, bool select_new=false)
XMLNode * state
state before any operation
void goto_visual_state(uint32_t)
void reset_region_gain_envelopes()
Evoral::OverlapType coverage(framepos_t start, framepos_t end) const
bool nudge_backward_release(GdkEventButton *)
framepos_t get_region_boundary(framepos_t pos, int32_t dir, bool with_selection, bool only_onscreen)
void paste_internal(framepos_t position, float times)
LIBGTKMM2EXT_API Gtk::Label * left_aligned_label(std::string const &)
boost::shared_ptr< Playlist > playlist()
boost::shared_ptr< ARDOUR::Region > find_next_region(ARDOUR::framepos_t, ARDOUR::RegionPoint, int32_t dir, TrackViewList &, TimeAxisView **=0)
XMLNode & get_state(void)
double end_grid_size() const
void save_visual_state(uint32_t)
void calc_extra_zoom_edges(framepos_t &start, framepos_t &end)
#define DEBUG_TRACE(bits, str)
int get_transients(AnalysisFeatureList &, bool force_new=false)
void set_fade_out_active(bool yn)
bool record_enabled() const
void selected_marker_to_previous_region_point(ARDOUR::RegionPoint)
void play_selected_region()
gint really_remove_marker(ARDOUR::Location *loc)
void duplicate(boost::shared_ptr< Region >, framepos_t position, float times)
void fit_tracks(TrackViewList &)
RegionSelectionAfterSplit
void crop_region_to_selection()
virtual void show_region_editor()
TrackViewList filter_to_unique_playlists()
LIBARDOUR_API PBD::PropertyDescriptor< bool > regions
void separate_region_from_punch()
framepos_t adjust_to_sync(framepos_t) const
void lower_region_to_bottom()
void get_result(std::string &str, bool strip=true)
void set_fade_in_shape(FadeShape)
void set_fade_in_active(bool yn)
static MixerStrip * entered_mixer_strip()
void loop_location(ARDOUR::Location &)
void tav_zoom_step(bool coarser)
framepos_t position() const
void strip_region_silence()
void call_slot(EventLoop::InvalidationRecord *, const boost::function< void()> &)
void separate_under_selected_regions()
virtual bool bounceable(boost::shared_ptr< Processor > endpoint, bool include_endpoint) const =0
void set_region_sync_position()
void jump_forward_to_mark()
void snap_regions_to_grid()
int set_start(framepos_t s, bool force=false, bool allow_bbt_recompute=true)
std::vector< boost::shared_ptr< ARDOUR::Region > > results
void trim_to(framepos_t position, framecnt_t length)
void cursor_to_selection_start(EditorCursor *)
void bring_in_callback(Gtk::Label *, uint32_t n, uint32_t total, std::string name)
void play_location(ARDOUR::Location &)
void add_location_from_playhead_cursor()
void cut_copy_midi(Editing::CutCopyOp)
void set_gain_envelope_visibility()
boost::shared_ptr< Playlist > playlist
void create_region_from_selection(std::vector< boost::shared_ptr< ARDOUR::Region > > &)
AudioStreamView * audio_view()
void remove_last_capture()
void align_region(boost::shared_ptr< ARDOUR::Region >, ARDOUR::RegionPoint point, framepos_t position)
void add_location_from_selection()
virtual std::string name() const =0
void insert_patch_change(bool from_context)
void add_location_from_region()
void apply_midi_note_edit_op(ARDOUR::MidiOperator &op, const RegionSelection &rs)
boost::shared_ptr< ControlList > copy(double, double)
void trim_region_to_previous_region_end()
void set_active(bool yn, void *)
bool scroll_down_one_track(bool skip_child_views=false)
static ARDOUR::framepos_t track_frame_to_session_frame(ARDOUR::framepos_t track_frame, double speed)
void set_sync_point(framepos_t, const RegionSelection &)
void toggle_tracks_active()
void set_fade_out_shape(ARDOUR::FadeShape)
static ARDOUR::framepos_t session_frame_to_track_frame(ARDOUR::framepos_t session_frame, double speed)
void remove_transient(ArdourCanvas::Item *item)
LIBARDOUR_API PBD::PropertyDescriptor< framepos_t > position
static UIConfiguration * config()
void nudge_after(framepos_t start, framecnt_t distance, bool forwards)
void set_loop_from_selection(bool play)
void toggle_gain_envelope_active()
void toggle_region_lock()
void remove_selected_regions()
void rdiff(std::vector< Command * > &) const
void set_bbt_reference(framepos_t)
void set_default_envelope()
void playhead_backward_to_grid()
void set_scale_amplitude(gain_t)
void split_region(boost::shared_ptr< Region >, framepos_t position)
bool input_active() const
void adjust_region_gain(bool up)
framecnt_t length() const
virtual boost::shared_ptr< Region > bounce_range(framepos_t start, framepos_t end, InterThreadInfo &, boost::shared_ptr< Processor > endpoint, bool include_endpoint)=0
double divisions_per_bar() const
void toggle_midi_input_active(bool flip_others)
void trim_region_to_next_region_start()
bool contains(TimeAxisView const *) const
bool choose_new_marker_name(std::string &name)
static float dB_to_coefficient(float dB)
framepos_t current_duration(framepos_t position=0) const
void temporal_zoom_by_frame(framepos_t start, framepos_t end)
void reset_point_selection()
void set_fade_in_active(bool)
bool nudge_forward_release(GdkEventButton *)
LIBGTKMM2EXT_API void pop_action_state()
LIBEVORAL_API uint64_t Beats
void temporal_zoom_session()
void paste(float times, bool from_context_menu=false)
std::map< Evoral::Parameter, boost::shared_ptr< AutomationTimeAxisView > > AutomationTracks
void crop_region_to(framepos_t start, framepos_t end)
void trim_to_region(bool forward)
framecnt_t length() const
static const framepos_t max_framepos
void split_regions_at(framepos_t, RegionSelection &)
bool is_range_marker() const
framepos_t first_frame() const
boost::shared_ptr< Playlist > pl
static uint32_t preset_height(Height)
void separate_region_from_selection()
void silences(ARDOUR::AudioIntervalMap &)
void nudge_forward(bool next, bool force_playhead)
void play_from_edit_point_and_return()
void cursor_to_next_region_boundary(bool with_selection)
void collect_new_region_view(RegionView *)
void apply_filter(ARDOUR::Filter &, std::string cmd, ProgressReporter *progress=0)
int apply(Filter &, Progress *progress=0)
void build_region_boundary_cache()
void set_tempo_from_region()
Glib::RefPtr< Gdk::Pixbuf > get_icon(const char *cname)
void selected_marker_to_next_region_boundary(bool with_selection)
void normalize(float, float target_in_dB=0.0f)
std::list< boost::shared_ptr< Route > > RouteList
void separate_regions_using_location(ARDOUR::Location &)
boost::shared_ptr< Playlist > cut(std::list< AudioRange > &, bool result_is_hidden=true)
void playhead_forward_to_grid()
void set_loop_from_region(bool play)
void shift(framepos_t at, frameoffset_t distance, bool move_intersected, bool ignore_music_glue)
LIBPBD_API int pthread_create_and_store(std::string name, pthread_t *thread, void *(*start_routine)(void *), void *arg)
void clear_playlist(boost::shared_ptr< ARDOUR::Playlist >)
void tab_to_transient(bool forward)
void update_region_fade_visibility()
void separate_region_from_loop()
void do_layer_operation(LayerOperation)
void set_hidden(bool yn, void *src)
bool add(PropertyBase *prop)
boost::shared_ptr< ARDOUR::Route > route() const
boost::shared_ptr< MidiModel > model()
void trim_region_to_loop()
Always round down, even if on a division.
void cursor_to_next_region_point(EditorCursor *, ARDOUR::RegionPoint)
framepos_t find_next_region_boundary(framepos_t pos, int32_t dir)
void scroll_backward(float pages=0.8f)
EventList::iterator iterator
LIBARDOUR_API PBD::PropertyChange bounds_change
int set_end(framepos_t e, bool force=false, bool allow_bbt_recompute=true)
std::string string_compose(const std::string &fmt, const T1 &o1)
void cancel_visual_state_op(uint32_t n)
void transform_regions(const RegionSelection &rs)
framepos_t find_next_transient(framepos_t position, int dir)
void add_patch_change(framecnt_t, Evoral::PatchChange< Evoral::Beats > const &)
boost::shared_ptr< ARDOUR::Playlist > playlist() const
void temporal_zoom_selection(bool both_axes=false)
void align_regions(ARDOUR::RegionPoint)
void scroll_playhead(bool forward)
boost::shared_ptr< Evoral::ControlList > copy
copied events for the cut buffer
framepos_t last_frame() const
LIBARDOUR_API PBD::PropertyDescriptor< framecnt_t > length
Command * apply_midi_note_edit_op_to_region(ARDOUR::MidiOperator &op, MidiRegionView &mrv)
void start_visual_state_op(uint32_t n)
void set_session_end_from_playhead()
bool envelope_active() const