#include <cstdlib>
#include <cmath>
#include <string>
+#include <limits>
#include <map>
#include <set>
#include "ardour/midi_track.h"
#include "ardour/operations.h"
#include "ardour/playlist_factory.h"
+#include "ardour/profile.h"
#include "ardour/quantize.h"
#include "ardour/region_factory.h"
#include "ardour/reverse.h"
#include "canvas/canvas.h"
+#include "actions.h"
#include "ardour_ui.h"
#include "audio_region_view.h"
#include "audio_streamview.h"
#include "audio_time_axis.h"
+#include "automation_region_view.h"
#include "automation_time_axis.h"
#include "control_point.h"
#include "debug.h"
#include "editor_drag.h"
#include "editor_regions.h"
#include "editor_routes.h"
-#include "gtk-custom-hruler.h"
#include "gui_thread.h"
#include "insert_time_dialog.h"
#include "interthread_progress_window.h"
+#include "item_counts.h"
#include "keyboard.h"
#include "midi_region_view.h"
+#include "mixer_strip.h"
#include "mouse_cursors.h"
#include "normalize_dialog.h"
#include "patch_change_dialog.h"
#include "strip_silence_dialog.h"
#include "time_axis_view.h"
#include "transpose_dialog.h"
-#include "utils.h"
#include "i18n.h"
{
bool frozen = false;
- list <boost::shared_ptr<Playlist > > used_playlists;
+ RegionSelection pre_selected_regions = selection->regions;
+ bool working_on_selection = !pre_selected_regions.empty();
+
+ list<boost::shared_ptr<Playlist> > used_playlists;
+ list<RouteTimeAxisView*> used_trackviews;
if (regions.empty()) {
return;
/* remember used playlists so we can thaw them later */
used_playlists.push_back(pl);
+
+ TimeAxisView& tv = (*a)->get_time_axis_view();
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (&tv);
+ if (rtv) {
+ used_trackviews.push_back (rtv);
+ }
pl->freeze();
}
+
if (pl) {
pl->clear_changes ();
pl->split_region ((*a)->region(), where);
a = tmp;
}
+ vector<sigc::connection> region_added_connections;
+
+ for (list<RouteTimeAxisView*>::iterator i = used_trackviews.begin(); i != used_trackviews.end(); ++i) {
+ region_added_connections.push_back ((*i)->view()->RegionViewAdded.connect (sigc::mem_fun(*this, &Editor::collect_new_region_view)));
+ }
+
+ latest_regionviews.clear ();
+
while (used_playlists.size() > 0) {
list <boost::shared_ptr<Playlist > >::iterator i = used_playlists.begin();
(*i)->thaw();
used_playlists.pop_front();
}
+ for (vector<sigc::connection>::iterator c = region_added_connections.begin(); c != region_added_connections.end(); ++c) {
+ (*c).disconnect ();
+ }
+
commit_reversible_command ();
if (frozen){
EditorThaw(); /* Emit Signal */
}
+
+ if (ARDOUR::Profile->get_mixbus()) {
+ //IFF we were working on selected regions, try to reinstate the other region selections that existed before the freeze/thaw.
+ _ignore_follow_edits = true; //a split will change the region selection in mysterious ways; its not practical or wanted to follow this edit
+ if( working_on_selection ) {
+ selection->add ( pre_selected_regions );
+ selection->add (latest_regionviews); //these are the new regions created after the split
+ }
+ _ignore_follow_edits = false;
+ }
}
/** Move one extreme of the current range selection. If more than one range is selected,
break;
default:
fatal << string_compose (_("build_region_boundary_cache called with snap_type = %1"), _snap_type) << endmsg;
- /*NOTREACHED*/
+ abort(); /*NOTREACHED*/
return;
}
{
TrackViewList::reverse_iterator next = track_views.rend();
std::pair<TimeAxisView*,double> res;
+ const double top_of_trackviews = vertical_adjustment.get_value();
for (TrackViewList::reverse_iterator t = track_views.rbegin(); t != track_views.rend(); ++t) {
if ((*t)->hidden()) {
continue;
}
-
- /* find the trackview at the bottom of the trackview group */
- res = (*t)->covers_y_position (_visible_canvas_height);
+
+
+ /* If this is the upper-most visible trackview, we want to display
+ the one above it (next)
+ */
+
+ res = (*t)->covers_y_position (top_of_trackviews);
if (res.first) {
break;
}
-
next = t;
}
/* move to the track below the first one that covers the */
if (next != track_views.rend()) {
- ensure_track_visible (*next);
+ ensure_time_axis_view_is_visible (**next, true);
return true;
}
bool
Editor::scroll_up_one_track ()
{
- double vertical_pos = vertical_adjustment.get_value ();
-
TrackViewList::iterator prev = track_views.end();
std::pair<TimeAxisView*,double> res;
-
+ double top_of_trackviews = vertical_adjustment.get_value ();
+
for (TrackViewList::iterator t = track_views.begin(); t != track_views.end(); ++t) {
if ((*t)->hidden()) {
}
/* find the trackview at the top of the trackview group */
- res = (*t)->covers_y_position (0);
+ res = (*t)->covers_y_position (top_of_trackviews);
if (res.first) {
break;
}
if (prev != track_views.end()) {
- ensure_track_visible (*prev);
+ ensure_time_axis_view_is_visible (**prev, true);
return true;
}
void
Editor::tav_zoom_step (bool coarser)
{
- _routes->suspend_redisplay ();
+ DisplaySuspender ds;
TrackViewList* ts;
TimeAxisView *tv = (static_cast<TimeAxisView*>(*i));
tv->step_height (coarser);
}
-
- _routes->resume_redisplay ();
}
void
Editor::tav_zoom_smooth (bool coarser, bool force_all)
{
- _routes->suspend_redisplay ();
+ DisplaySuspender ds;
TrackViewList* ts;
tv->set_height (h + 5);
}
}
-
- _routes->resume_redisplay ();
}
-bool
-Editor::clamp_samples_per_pixel (framecnt_t& fpp) const
-{
- bool clamped = false;
-
- if (fpp < 1) {
- fpp = 1;
- clamped = true;
- }
-
- if (max_framepos / fpp < 800) {
- fpp = max_framepos / 800;
- clamped = true;
- }
-
- return clamped;
-}
void
Editor::temporal_zoom_step (bool coarser)
framecnt_t nfpp;
double l;
- clamp_samples_per_pixel (fpp);
if (fpp == samples_per_pixel) {
return;
}
// would be 4147200000 samples, so 2592000 samples per pixel.
nfpp = min (fpp, (framecnt_t) 2592000);
- nfpp = max ((framecnt_t) 1, fpp);
+ nfpp = max ((framecnt_t) 1, nfpp);
new_page_size = (framepos_t) floor (_visible_canvas_width * nfpp);
half_page_size = new_page_size / 2;
reposition_and_zoom (leftmost_after_zoom, nfpp);
}
+void
+Editor::calc_extra_zoom_edges(framepos_t &start, framepos_t &end)
+{
+ /* this func helps make sure we leave a little space
+ at each end of the editor so that the zoom doesn't fit the region
+ precisely to the screen.
+ */
+
+ GdkScreen* screen = gdk_screen_get_default ();
+ const gint pixwidth = gdk_screen_get_width (screen);
+ const gint mmwidth = gdk_screen_get_width_mm (screen);
+ const double pix_per_mm = (double) pixwidth/ (double) mmwidth;
+ const double one_centimeter_in_pixels = pix_per_mm * 10.0;
+
+ const framepos_t range = end - start;
+ const framecnt_t new_fpp = (framecnt_t) ceil ((double) range / (double) _visible_canvas_width);
+ const framepos_t extra_samples = (framepos_t) floor (one_centimeter_in_pixels * new_fpp);
+
+ if (start > extra_samples) {
+ start -= extra_samples;
+ } else {
+ start = 0;
+ }
+
+ if (max_framepos - extra_samples > end) {
+ end += extra_samples;
+ } else {
+ end = max_framepos;
+ }
+}
+
void
Editor::temporal_zoom_region (bool both_axes)
{
tracks.insert (&((*i)->get_time_axis_view()));
}
- /* now comes an "interesting" hack ... make sure we leave a little space
- at each end of the editor so that the zoom doesn't fit the region
- precisely to the screen.
- */
-
- GdkScreen* screen = gdk_screen_get_default ();
- gint pixwidth = gdk_screen_get_width (screen);
- gint mmwidth = gdk_screen_get_width_mm (screen);
- double pix_per_mm = (double) pixwidth/ (double) mmwidth;
- double one_centimeter_in_pixels = pix_per_mm * 10.0;
-
if ((start == 0 && end == 0) || end < start) {
return;
}
- framepos_t range = end - start;
- double new_fpp = (double) range / (double) _visible_canvas_width;
- framepos_t extra_samples = (framepos_t) floor (one_centimeter_in_pixels * new_fpp);
-
- if (start > extra_samples) {
- start -= extra_samples;
- } else {
- start = 0;
- }
-
- if (max_framepos - extra_samples > end) {
- end += extra_samples;
- } else {
- end = max_framepos;
- }
+ calc_extra_zoom_edges (start, end);
/* if we're zooming on both axes we need to save track heights etc.
*/
/* hide irrelevant tracks */
- _routes->suspend_redisplay ();
+ DisplaySuspender ds;
for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
if (find (tracks.begin(), tracks.end(), (*i)) == tracks.end()) {
}
}
- _routes->resume_redisplay ();
-
vertical_adjustment.set_value (0.0);
}
}
void
-Editor::temporal_zoom_selection ()
+Editor::temporal_zoom_selection (bool both_axes)
{
if (!selection) return;
- if (selection->time.empty()) {
- return;
+ //if a range is selected, zoom to that
+ if (!selection->time.empty()) {
+
+ framepos_t start = selection->time.start();
+ framepos_t end = selection->time.end_frame();
+
+ calc_extra_zoom_edges(start, end);
+
+ temporal_zoom_by_frame (start, end);
+
+ if (both_axes)
+ fit_selected_tracks();
+
+ } else {
+ temporal_zoom_region (both_axes);
}
- framepos_t start = selection->time[clicked_selection].start;
- framepos_t end = selection->time[clicked_selection].end;
- temporal_zoom_by_frame (start, end);
}
void
ENSURE_GUI_THREAD (*this, &Editor::temporal_zoom_session)
if (_session) {
- framecnt_t const l = _session->current_end_frame() - _session->current_start_frame();
- double s = _session->current_start_frame() - l * 0.01;
- if (s < 0) {
- s = 0;
+ framecnt_t start = _session->current_start_frame();
+ framecnt_t end = _session->current_end_frame();
+
+ if (_session->actively_recording () ) {
+ framepos_t cur = playhead_cursor->current_frame ();
+ if (cur > end) {
+ /* recording beyond the end marker; zoom out
+ * by 5 seconds more so that if 'follow
+ * playhead' is active we don't immediately
+ * scroll.
+ */
+ end = cur + _session->frame_rate() * 5;
+ }
+ }
+
+ if ((start == 0 && end == 0) || end < start) {
+ return;
}
- framecnt_t const e = _session->current_end_frame() + l * 0.01;
- temporal_zoom_by_frame (framecnt_t (s), e);
+
+ calc_extra_zoom_edges(start, end);
+
+ temporal_zoom_by_frame (start, end);
}
}
framepos_t range = end - start;
- double const new_fpp = (double) range / (double) _visible_canvas_width;
-
- framepos_t new_page = (framepos_t) floor (_visible_canvas_width * new_fpp);
+ const framecnt_t new_fpp = (framecnt_t) ceil ((double) range / (double) _visible_canvas_width);
+
+ framepos_t new_page = range;
framepos_t middle = (framepos_t) floor ((double) start + ((double) range / 2.0f));
framepos_t new_leftmost = (framepos_t) floor ((double) middle - ((double) new_page / 2.0f));
new_spp = samples_per_pixel - (samples_per_pixel/2);
} else {
/* could bail out here since we cannot zoom any finer,
- but leave that to the clamp_samples_per_pixel() and
- equality test below
+ but leave that to the equality test below
*/
new_spp = samples_per_pixel;
}
range_before -= range_before/2;
}
- clamp_samples_per_pixel (new_spp);
-
if (new_spp == samples_per_pixel) {
return;
}
add_location_mark (_session->audible_frame());
}
+void
+Editor::remove_location_at_playhead_cursor ()
+{
+ if (_session) {
+
+ //set up for undo
+ _session->begin_reversible_command (_("remove marker"));
+ XMLNode &before = _session->locations()->get_state();
+ bool removed = false;
+
+ //find location(s) at this time
+ Locations::LocationList locs;
+ _session->locations()->find_all_between (_session->audible_frame(), _session->audible_frame()+1, locs, Location::Flags(0));
+ for (Locations::LocationList::iterator i = locs.begin(); i != locs.end(); ++i) {
+ if ((*i)->is_mark()) {
+ _session->locations()->remove (*i);
+ removed = true;
+ }
+ }
+
+ //store undo
+ if (removed) {
+ XMLNode &after = _session->locations()->get_state();
+ _session->add_command(new MementoCommand<Locations>(*(_session->locations()), &before, &after));
+ _session->commit_reversible_command ();
+ }
+ }
+}
+
/** Add a range marker around each selected region */
void
Editor::add_locations_from_region ()
_session->begin_reversible_command (_("clear ranges"));
XMLNode &before = _session->locations()->get_state();
- Location * looploc = _session->locations()->auto_loop_location();
- Location * punchloc = _session->locations()->auto_punch_location();
- Location * sessionloc = _session->locations()->session_range_location();
-
_session->locations()->clear_ranges ();
- // re-add these
- if (looploc) _session->locations()->add (looploc);
- if (punchloc) _session->locations()->add (punchloc);
- if (sessionloc) _session->locations()->add (sessionloc);
XMLNode &after = _session->locations()->get_state();
_session->add_command(new MementoCommand<Locations>(*(_session->locations()), &before, &after));
/* INSERT/REPLACE */
-void
-Editor::insert_region_list_drag (boost::shared_ptr<Region> region, int x, int y)
-{
- double cx, cy;
- framepos_t where;
- RouteTimeAxisView *rtv = 0;
- boost::shared_ptr<Playlist> playlist;
-
- GdkEvent event;
- event.type = GDK_BUTTON_RELEASE;
- event.button.x = x;
- event.button.y = y;
-
- where = window_event_sample (&event, &cx, &cy);
-
- if (where < leftmost_frame || where > leftmost_frame + current_page_samples()) {
- /* clearly outside canvas area */
- return;
- }
-
- std::pair<TimeAxisView*, int> tv = trackview_by_y_position (cy);
- if (tv.first == 0) {
- return;
- }
-
- if ((rtv = dynamic_cast<RouteTimeAxisView*> (tv.first)) == 0) {
- return;
- }
-
- if ((playlist = rtv->playlist()) == 0) {
- return;
- }
-
- snap_to (where);
-
- begin_reversible_command (_("insert dragged region"));
- playlist->clear_changes ();
- playlist->add_region (RegionFactory::create (region, true), where, 1.0);
- _session->add_command(new StatefulDiffCommand (playlist));
- commit_reversible_command ();
-}
-
-void
-Editor::insert_route_list_drag (boost::shared_ptr<Route> route, int x, int y)
-{
- double cx, cy;
- RouteTimeAxisView *dest_rtv = 0;
- RouteTimeAxisView *source_rtv = 0;
-
- GdkEvent event;
- event.type = GDK_BUTTON_RELEASE;
- event.button.x = x;
- event.button.y = y;
-
- window_event_sample (&event, &cx, &cy);
-
- std::pair<TimeAxisView*, int> const tv = trackview_by_y_position (cy);
- if (tv.first == 0) {
- return;
- }
-
- if ((dest_rtv = dynamic_cast<RouteTimeAxisView*> (tv.first)) == 0) {
- return;
- }
-
- /* use this drag source to add underlay to a track. But we really don't care
- about the Route, only the view of the route, so find it first */
- for(TrackViewList::iterator it = track_views.begin(); it != track_views.end(); ++it) {
- if((source_rtv = dynamic_cast<RouteTimeAxisView*>(*it)) == 0) {
- continue;
- }
-
- if(source_rtv->route() == route && source_rtv != dest_rtv) {
- dest_rtv->add_underlay(source_rtv->view());
- break;
- }
- }
-}
-
void
Editor::insert_region_list_selection (float times)
{
begin_reversible_command (_("insert region"));
playlist->clear_changes ();
playlist->add_region ((RegionFactory::create (region, true)), get_preferred_edit_position(), times);
+ if (Config->get_edit_mode() == Ripple)
+ playlist->ripple (get_preferred_edit_position(), region->length() * times, boost::shared_ptr<Region>());
+
_session->add_command(new StatefulDiffCommand (playlist));
commit_reversible_command ();
}
void
Editor::maybe_locate_with_edit_preroll ( framepos_t location )
{
- if ( _session->transport_rolling() || !Config->get_always_play_range() )
+ if ( _session->transport_rolling() || !Config->get_follow_edits() || _ignore_follow_edits )
return;
location -= get_preroll();
tll->set (location.start(), location.end());
// enable looping, reposition and start rolling
- _session->request_play_loop (true);
_session->request_locate (tll->start(), true);
+ _session->request_play_loop (true);
}
}
add_if_covered (RegionView* rv, const AudioRange* ar, RegionSelection* rs)
{
switch (rv->region()->coverage (ar->start, ar->end - 1)) {
+ // n.b. -1 because AudioRange::end is one past the end, but coverage expects inclusive ranges
case Evoral::OverlapNone:
break;
default:
}
if (in_command) {
- selection->set (new_selection);
- set_mouse_mode (MouseObject);
+// selection->set (new_selection);
commit_reversible_command ();
}
void
Editor::delete_ ()
{
- cut_copy (Delete);
+ //special case: if the user is pointing in the editor/mixer strip, they may be trying to delete a plugin.
+ //we need this because the editor-mixer strip is in the editor window, so it doesn't get the bindings from the mix window
+ bool deleted = false;
+ if ( current_mixer_strip && current_mixer_strip == MixerStrip::entered_mixer_strip() )
+ deleted = current_mixer_strip->delete_processors ();
+
+ if (!deleted)
+ cut_copy (Delete);
}
/** Cut selected regions, automation points or a time range */
bool
Editor::can_cut_copy () const
{
- switch (effective_mouse_mode()) {
-
- case MouseObject:
- if (!selection->regions.empty() || !selection->points.empty()) {
- return true;
- }
- break;
-
- case MouseRange:
- if (!selection->time.empty()) {
- return true;
- }
- break;
-
- default:
- break;
- }
+ if (!selection->time.empty() || !selection->regions.empty() || !selection->points.empty())
+ return true;
return false;
}
/** Cut, copy or clear selected regions, automation points or a time range.
- * @param op Operation (Cut, Copy or Clear)
+ * @param op Operation (Delete, Cut, Copy or Clear)
*/
void
Editor::cut_copy (CutCopyOp op)
}
}
- if ( op != Clear ) //"Delete" doesn't change copy/paste buf
+ if ( op != Delete ) //"Delete" doesn't change copy/paste buf
cut_buffer->clear ();
if (entered_marker) {
bool did_edit = false;
- switch (effective_mouse_mode()) {
- case MouseGain:
- if (!selection->points.empty()) {
- begin_reversible_command (opname + _(" points"));
- did_edit = true;
- cut_copy_points (op);
- if (op == Cut || op == Delete) {
- selection->clear_points ();
- }
- }
- break;
-
- case MouseObject:
-
- if (!selection->regions.empty() || !selection->points.empty()) {
-
- string thing_name;
+ if (!selection->regions.empty() || !selection->points.empty()) {
+ begin_reversible_command (opname + ' ' + _("objects"));
+ did_edit = true;
- if (selection->regions.empty()) {
- thing_name = _("points");
- } else if (selection->points.empty()) {
- thing_name = _("regions");
- } else {
- thing_name = _("objects");
- }
-
- begin_reversible_command (opname + ' ' + thing_name);
- did_edit = true;
-
- if (!selection->regions.empty()) {
- cut_copy_regions (op, selection->regions);
-
- if (op == Cut || op == Delete) {
- selection->clear_regions ();
- }
- }
-
- if (!selection->points.empty()) {
- cut_copy_points (op);
-
- if (op == Cut || op == Delete) {
- selection->clear_points ();
- }
- }
- }
- break;
+ if (!selection->regions.empty()) {
+ cut_copy_regions (op, selection->regions);
- case MouseRange:
- if (selection->time.empty()) {
- framepos_t start, end;
- /* no time selection, see if we can get an edit range
- and use that.
- */
- if (get_edit_op_range (start, end)) {
- selection->set (start, end);
+ if (op == Cut || op == Delete) {
+ selection->clear_regions ();
}
}
- if (!selection->time.empty()) {
- begin_reversible_command (opname + _(" range"));
-
- did_edit = true;
- cut_copy_ranges (op);
+
+ if (!selection->points.empty()) {
+ cut_copy_points (op);
if (op == Cut || op == Delete) {
- selection->clear_time ();
+ selection->clear_points ();
}
}
- break;
+ } else if (selection->time.empty()) {
+ framepos_t start, end;
+ /* no time selection, see if we can get an edit range
+ and use that.
+ */
+ if (get_edit_op_range (start, end)) {
+ selection->set (start, end);
+ }
+ } else if (!selection->time.empty()) {
+ begin_reversible_command (opname + ' ' + _("range"));
+
+ did_edit = true;
+ cut_copy_ranges (op);
- default:
- break;
+ if (op == Cut || op == Delete) {
+ selection->clear_time ();
+ }
}
if (did_edit) {
+ /* reset repeated paste state */
+ paste_count = 0;
+ last_paste_pos = 0;
commit_reversible_command ();
}
}
struct AutomationRecord {
- AutomationRecord () : state (0) {}
- AutomationRecord (XMLNode* s) : state (s) {}
+ AutomationRecord () : state (0) , line(NULL) {}
+ AutomationRecord (XMLNode* s, const AutomationLine* l) : state (s) , line (l) {}
XMLNode* state; ///< state before any operation
+ const AutomationLine* line; ///< line this came from
boost::shared_ptr<Evoral::ControlList> copy; ///< copied events for the cut buffer
};
/* Go through all selected points, making an AutomationRecord for each distinct AutomationList */
for (PointSelection::iterator i = selection->points.begin(); i != selection->points.end(); ++i) {
- boost::shared_ptr<AutomationList> al = (*i)->line().the_list();
+ const AutomationLine& line = (*i)->line();
+ const boost::shared_ptr<AutomationList> al = line.the_list();
if (lists.find (al) == lists.end ()) {
/* We haven't seen this list yet, so make a record for it. This includes
taking a copy of its current state, in case this is needed for undo later.
*/
- lists[al] = AutomationRecord (&al->get_state ());
+ lists[al] = AutomationRecord (&al->get_state (), &line);
}
}
/* This operation will involve putting things in the cut buffer, so create an empty
ControlList for each of our source lists to put the cut buffer data in.
*/
+ framepos_t start = std::numeric_limits<framepos_t>::max();
for (Lists::iterator i = lists.begin(); i != lists.end(); ++i) {
i->second.copy = i->first->create (i->first->parameter ());
+
+ /* Calculate earliest start position of any point in selection. */
+ start = std::min(start, i->second.line->session_position(i->first->begin()));
}
/* Add all selected points to the relevant copy ControlLists */
for (PointSelection::iterator i = selection->points.begin(); i != selection->points.end(); ++i) {
boost::shared_ptr<AutomationList> al = (*i)->line().the_list();
AutomationList::const_iterator j = (*i)->model ();
- lists[al].copy->add ((*j)->when, (*j)->value);
+ lists[al].copy->fast_simple_add ((*j)->when, (*j)->value);
}
+ /* Snap start time backwards, so copy/paste is snap aligned. */
+ snap_to(start, RoundDownMaybe);
+
for (Lists::iterator i = lists.begin(); i != lists.end(); ++i) {
- /* Correct this copy list so that it starts at time 0 */
- double const start = i->second.copy->front()->when;
+ /* Correct this copy list so that it is relative to the earliest
+ start time, so relative ordering between points is preserved
+ when copying from several lists. */
+ const AutomationLine* line = i->second.line;
+ const double line_offset = line->time_converter().from(start);
+
for (AutomationList::iterator j = i->second.copy->begin(); j != i->second.copy->end(); ++j) {
- (*j)->when -= start;
+ (*j)->when -= line_offset;
}
/* And add it to the cut buffer */
Editor::cut_copy_midi (CutCopyOp op)
{
for (MidiRegionSelection::iterator i = selection->midi_regions.begin(); i != selection->midi_regions.end(); ++i) {
- MidiRegionView* mrv = *i;
- mrv->cut_copy_clear (op);
- }
-}
+ MidiRegionView* mrv = dynamic_cast<MidiRegionView*>(*i);
+ if (mrv) {
+ mrv->cut_copy_clear (op);
+ /* XXX: not ideal, as there may be more than one track involved in the selection */
+ _last_cut_copy_source_track = &mrv->get_time_axis_view();
+ }
+ }
+ if (!selection->points.empty()) {
+ cut_copy_points (op);
+ if (op == Cut || op == Delete) {
+ selection->clear_points ();
+ }
+ }
+}
struct lt_playlist {
bool operator () (const PlaylistState& a, const PlaylistState& b) {
boost::shared_ptr<Playlist> playlist = clicked_routeview->playlist();
- begin_reversible_command (_("remove region"));
playlist->clear_changes ();
playlist->clear_owned_changes ();
playlist->remove_region (clicked_regionview->region());
+ if (Config->get_edit_mode() == Ripple)
+ playlist->ripple (clicked_regionview->region()->position(), -clicked_regionview->region()->length(), boost::shared_ptr<Region>());
/* We might have removed regions, which alters other regions' layering_index,
so we need to do a recursive diff here.
playlist->clear_owned_changes ();
playlist->freeze ();
playlist->remove_region (*rl);
+ if (Config->get_edit_mode() == Ripple)
+ playlist->ripple ((*rl)->position(), -(*rl)->length(), boost::shared_ptr<Region>());
+
}
vector<boost::shared_ptr<Playlist> >::iterator pl;
switch (op) {
case Delete:
pl->remove_region (r);
+ if (Config->get_edit_mode() == Ripple)
+ pl->ripple (r->position(), -r->length(), boost::shared_ptr<Region>());
break;
case Cut:
_xx = RegionFactory::create (r);
npl->add_region (_xx, r->position() - first_position);
pl->remove_region (r);
+ if (Config->get_edit_mode() == Ripple)
+ pl->ripple (r->position(), -r->length(), boost::shared_ptr<Region>());
break;
case Copy:
break;
case Clear:
- pl->remove_region (r);
+ pl->remove_region (r);
+ if (Config->get_edit_mode() == Ripple)
+ pl->ripple (r->position(), -r->length(), boost::shared_ptr<Region>());
break;
}
{
DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("apparent paste position is %1\n", position));
- if (internal_editing()) {
- if (cut_buffer->midi_notes.empty()) {
- return;
- }
- } else {
- if (cut_buffer->empty()) {
- return;
- }
+ if (cut_buffer->empty(internal_editing())) {
+ return;
}
if (position == max_framepos) {
DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("preferred edit position is %1\n", position));
}
- TrackViewList ts;
- TrackViewList::iterator i;
- size_t nth;
+ if (position == last_paste_pos) {
+ /* repeated paste in the same position */
+ ++paste_count;
+ } else {
+ /* paste in new location, reset repeated paste state */
+ paste_count = 0;
+ last_paste_pos = position;
+ }
/* get everything in the correct order */
- if (_edit_point == Editing::EditAtMouse && entered_track) {
- /* With the mouse edit point, paste onto the track under the mouse */
- ts.push_back (entered_track);
- } else if (!selection->tracks.empty()) {
- /* Otherwise, if there are some selected tracks, paste to them */
+ TrackViewList ts;
+ if (!selection->tracks.empty()) {
+ /* If there is a track selection, paste into exactly those tracks and
+ only those tracks. This allows the user to be explicit and override
+ the below "do the reasonable thing" logic. */
ts = selection->tracks.filter_to_unique_playlists ();
sort_track_selection (ts);
- } else if (_last_cut_copy_source_track) {
- /* Otherwise paste to the track that the cut/copy came from;
- see discussion in mantis #3333.
- */
- ts.push_back (_last_cut_copy_source_track);
+ } else {
+ /* Figure out which track to base the paste at. */
+ TimeAxisView* base_track = NULL;
+ if (_edit_point == Editing::EditAtMouse && entered_track) {
+ /* With the mouse edit point, paste onto the track under the mouse. */
+ base_track = entered_track;
+ } else if (_edit_point == Editing::EditAtMouse && entered_regionview) {
+ /* With the mouse edit point, paste onto the track of the region under the mouse. */
+ base_track = &entered_regionview->get_time_axis_view();
+ } else if (_last_cut_copy_source_track) {
+ /* Paste to the track that the cut/copy came from (see mantis #333). */
+ base_track = _last_cut_copy_source_track;
+ } else {
+ /* This is "impossible" since we've copied... well, do nothing. */
+ return;
+ }
+
+ /* Walk up to parent if necessary, so base track is a route. */
+ while (base_track->get_parent()) {
+ base_track = base_track->get_parent();
+ }
+
+ /* Add base track and all tracks below it. The paste logic will select
+ the appropriate object types from the cut buffer in relative order. */
+ for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
+ if ((*i)->order() >= base_track->order()) {
+ ts.push_back(*i);
+ }
+ }
+
+ /* Sort tracks so the nth track of type T will pick the nth object of type T. */
+ sort_track_selection (ts);
+
+ /* Add automation children of each track in order, for pasting several lines. */
+ for (TrackViewList::iterator i = ts.begin(); i != ts.end();) {
+ /* Add any automation children for pasting several lines */
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*>(*i++);
+ if (!rtv) {
+ continue;
+ }
+
+ typedef RouteTimeAxisView::AutomationTracks ATracks;
+ const ATracks& atracks = rtv->automation_tracks();
+ for (ATracks::const_iterator a = atracks.begin(); a != atracks.end(); ++a) {
+ i = ts.insert(i, a->second.get());
+ ++i;
+ }
+ }
+
+ /* We now have a list of trackviews starting at base_track, including
+ automation children, in the order shown in the editor, e.g. R1,
+ R1.A1, R1.A2, R2, R2.A1, ... */
}
if (internal_editing ()) {
/* undo/redo is handled by individual tracks/regions */
- for (nth = 0, i = ts.begin(); i != ts.end(); ++i, ++nth) {
-
- RegionSelection rs;
- RegionSelection::iterator r;
- MidiNoteSelection::iterator cb;
-
- get_regions_at (rs, position, ts);
+ RegionSelection rs;
+ get_regions_at (rs, position, ts);
- for (cb = cut_buffer->midi_notes.begin(), r = rs.begin();
- cb != cut_buffer->midi_notes.end() && r != rs.end(); ++r) {
- MidiRegionView* mrv = dynamic_cast<MidiRegionView*> (*r);
- if (mrv) {
- mrv->paste (position, times, **cb);
- ++cb;
- }
+ ItemCounts counts;
+ for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ++r) {
+ MidiRegionView* mrv = dynamic_cast<MidiRegionView*> (*r);
+ if (mrv) {
+ mrv->paste (position, paste_count, times, *cut_buffer, counts);
}
}
begin_reversible_command (Operations::paste);
- for (nth = 0, i = ts.begin(); i != ts.end(); ++i, ++nth) {
- (*i)->paste (position, times, *cut_buffer, nth);
+ ItemCounts counts;
+ for (TrackViewList::iterator i = ts.begin(); i != ts.end(); ++i) {
+ (*i)->paste (position, paste_count, times, *cut_buffer, counts);
}
commit_reversible_command ();
vector<Evoral::Sequence<Evoral::MusicalTime>::Notes> v;
v.push_back (selected);
- framepos_t pos_frames = mrv.midi_region()->position() - mrv.midi_region()->start();
- double pos_beats = _session->tempo_map().framewalk_to_beats(0, pos_frames);
+ framepos_t pos_frames = mrv.midi_region()->position() - mrv.midi_region()->start();
+ Evoral::MusicalTime pos_beats = _session->tempo_map().framewalk_to_beats(0, pos_frames);
return op (mrv.midi_region()->model(), pos_beats, v);
}
qd->hide ();
if (r == Gtk::RESPONSE_OK) {
- Quantize quant (*_session, qd->snap_start(), qd->snap_end(),
+ Quantize quant (qd->snap_start(), qd->snap_end(),
qd->start_grid_size(), qd->end_grid_size(),
qd->strength(), qd->swing(), qd->threshold());
*/
MidiRegionView* first = dynamic_cast<MidiRegionView*> (rs.front ());
- Evoral::PatchChange<Evoral::MusicalTime> empty (0, 0, 0, 0);
+ Evoral::PatchChange<Evoral::MusicalTime> empty (Evoral::MusicalTime(), 0, 0, 0);
PatchChangeDialog d (0, _session, empty, first->instrument_info(), Gtk::Stock::ADD);
if (d.run() == RESPONSE_CANCEL) {
{
}
+
+void
+Editor::fade_range ()
+{
+ TrackViewList ts = selection->tracks.filter_to_unique_playlists ();
+
+ begin_reversible_command (_("fade range"));
+
+ for (TrackViewList::iterator i = ts.begin(); i != ts.end(); ++i) {
+ (*i)->fade_range (selection->time);
+ }
+
+ commit_reversible_command ();
+}
+
+
void
Editor::set_fade_length (bool in)
{
}
}
- if ( Config->get_always_play_range() )
+ if ( Config->get_follow_edits() )
cancel_time_selection();
}
selection->set(current);
- ensure_track_visible(current);
+ ensure_time_axis_view_is_visible (*current, false);
}
void
selection->set (current);
- ensure_track_visible(current);
-}
-
-void
-Editor::ensure_track_visible(TimeAxisView *track)
-{
- if (track->hidden())
- return;
-
- double const current_view_min_y = vertical_adjustment.get_value();
- double const current_view_max_y = vertical_adjustment.get_value() + vertical_adjustment.get_page_size();
-
- double const track_min_y = track->y_position ();
- double const track_max_y = track->y_position () + track->effective_height ();
-
- if (track_min_y >= current_view_min_y &&
- track_max_y <= current_view_max_y) {
- return;
- }
-
- double new_value;
-
- if (track_min_y < current_view_min_y) {
- // Track is above the current view
- new_value = track_min_y;
- } else {
- // Track is below the current view
- new_value = track->y_position () + track->effective_height() - vertical_adjustment.get_page_size();
- }
-
- vertical_adjustment.set_value(new_value);
+ ensure_time_axis_view_is_visible (*current, false);
}
void
set_loop_range (start, end, _("set loop range from selection"));
if (play) {
- _session->request_play_loop (true);
_session->request_locate (start, true);
+ _session->request_play_loop (true);
}
}
set_loop_range (start, end, _("set loop range from edit range"));
if (play) {
- _session->request_play_loop (true);
_session->request_locate (start, true);
+ _session->request_play_loop (true);
}
}
set_loop_range (start, end, _("set loop range from region"));
if (play) {
- _session->request_play_loop (true);
_session->request_locate (start, true);
+ _session->request_play_loop (true);
}
}
framepos_t pos = playhead_cursor->current_frame ();
if (pos < max_framepos - 1) {
pos += 2;
- snap_to_internal (pos, 1, false);
+ snap_to_internal (pos, RoundUpAlways, false);
_session->request_locate (pos);
}
}
framepos_t pos = playhead_cursor->current_frame ();
if (pos > 2) {
pos -= 2;
- snap_to_internal (pos, -1, false);
+ snap_to_internal (pos, RoundDownAlways, false);
_session->request_locate (pos);
}
}
return;
}
+ // XXX should be using gettext plural forms, maybe?
if (ntracks > 1) {
trackstr = _("tracks");
} else {
}
} else if (nbusses) {
prompt = string_compose (_("Do you really want to remove %1 %2?\n\n"
- "This action cannot be undon, and the session file will be overwritten"),
+ "This action cannot be undone, and the session file will be overwritten"),
nbusses, busstr);
}
return;
}
- for (vector<boost::shared_ptr<Route> >::iterator x = routes.begin(); x != routes.end(); ++x) {
- _session->remove_route (*x);
+ {
+ Session::StateProtector sp (_session);
+ DisplaySuspender ds;
+ for (vector<boost::shared_ptr<Route> >::iterator x = routes.begin(); x != routes.end(); ++x) {
+ _session->remove_route (*x);
+ }
}
}
}
}
}
+
}
void
++visible_tracks;
}
- uint32_t h = (uint32_t) floor ((_visible_canvas_height - child_heights) / visible_tracks);
+ /* compute the per-track height from:
+
+ total canvas visible height -
+ height that will be taken by visible children of selected
+ tracks - height of the ruler/hscroll area
+ */
+ uint32_t h = (uint32_t) floor ((trackviews_height() - child_heights) / visible_tracks);
double first_y_pos = DBL_MAX;
if (h < TimeAxisView::preset_height (HeightSmall)) {
}
}
- /* operate on all tracks, hide unselected ones that are in the middle of selected ones */
-
bool prev_was_selected = false;
bool is_selected = tracks.contains (all.front());
bool next_is_selected;
vertical_adjustment.set_value (first_y_pos);
redo_visual_stack.push_back (current_visual_state (true));
+
+ visible_tracks_selector.set_text (_("Sel"));
}
void
_session->set_exclusive_input_active (rl, onoff, flip_others);
}
+
+void
+Editor::lock ()
+{
+ if (!lock_dialog) {
+ lock_dialog = new Gtk::Dialog (string_compose (_("%1: Locked"), PROGRAM_NAME), true);
+
+ Gtk::Image* padlock = manage (new Gtk::Image (ARDOUR_UI_UTILS::get_icon ("padlock_closed")));
+ lock_dialog->get_vbox()->pack_start (*padlock);
+
+ ArdourButton* b = manage (new ArdourButton);
+ b->set_name ("lock button");
+ b->set_text (_("Click to unlock"));
+ b->signal_clicked.connect (sigc::mem_fun (*this, &Editor::unlock));
+ lock_dialog->get_vbox()->pack_start (*b);
+
+ lock_dialog->get_vbox()->show_all ();
+ lock_dialog->set_size_request (200, 200);
+ }
+
+#ifdef __APPLE__
+ /* The global menu bar continues to be accessible to applications
+ with modal dialogs, which means that we need to desensitize
+ all items in the menu bar. Since those items are really just
+ proxies for actions, that means disabling all actions.
+ */
+ ActionManager::disable_all_actions ();
+#endif
+ lock_dialog->present ();
+}
+
+void
+Editor::unlock ()
+{
+ lock_dialog->hide ();
+
+#ifdef __APPLE__
+ ActionManager::pop_action_state ();
+#endif
+
+ if (ARDOUR_UI::config()->get_lock_gui_after_seconds()) {
+ start_lock_event_timing ();
+ }
+}
+
+void
+Editor::bring_in_callback (Gtk::Label* label, uint32_t n, uint32_t total, string name)
+{
+ Gtkmm2ext::UI::instance()->call_slot (invalidator (*this), boost::bind (&Editor::update_bring_in_message, this, label, n, total, name));
+}
+
+void
+Editor::update_bring_in_message (Gtk::Label* label, uint32_t n, uint32_t total, string name)
+{
+ label->set_text (string_compose ("Copying %1, %2 of %3", name, n, total));
+ Gtkmm2ext::UI::instance()->flush_pending ();
+}
+
+void
+Editor::bring_all_sources_into_session ()
+{
+ if (!_session) {
+ return;
+ }
+
+ Gtk::Label msg;
+ ArdourDialog w (_("Moving embedded files into session folder"));
+ w.get_vbox()->pack_start (msg);
+ w.present ();
+
+ /* flush all pending GUI events because we're about to start copying
+ * files
+ */
+
+ Gtkmm2ext::UI::instance()->flush_pending ();
+
+ cerr << " Do it\n";
+
+ _session->bring_all_sources_into_session (boost::bind (&Editor::bring_in_callback, this, &msg, _1, _2, _3));
+}