#include "ardour/strip_silence.h"
#include "ardour/transient_detector.h"
+#include "canvas/canvas.h"
+
+#include "actions.h"
#include "ardour_ui.h"
-#include "debug.h"
-#include "editor.h"
-#include "time_axis_view.h"
-#include "route_time_axis.h"
+#include "audio_region_view.h"
+#include "audio_streamview.h"
#include "audio_time_axis.h"
#include "automation_time_axis.h"
#include "control_point.h"
-#include "streamview.h"
-#include "audio_streamview.h"
-#include "audio_region_view.h"
-#include "midi_region_view.h"
-#include "rgb_macros.h"
-#include "selection_templates.h"
-#include "selection.h"
+#include "debug.h"
#include "editing.h"
-#include "gtk-custom-hruler.h"
-#include "gui_thread.h"
-#include "keyboard.h"
-#include "utils.h"
+#include "editor.h"
+#include "editor_cursors.h"
#include "editor_drag.h"
-#include "strip_silence_dialog.h"
-#include "editor_routes.h"
#include "editor_regions.h"
-#include "quantize_dialog.h"
-#include "interthread_progress_window.h"
+#include "editor_routes.h"
+#include "gui_thread.h"
#include "insert_time_dialog.h"
-#include "normalize_dialog.h"
-#include "editor_cursors.h"
+#include "interthread_progress_window.h"
+#include "keyboard.h"
+#include "midi_region_view.h"
#include "mouse_cursors.h"
+#include "normalize_dialog.h"
#include "patch_change_dialog.h"
+#include "quantize_dialog.h"
+#include "region_gain_line.h"
+#include "rgb_macros.h"
+#include "route_time_axis.h"
+#include "selection.h"
+#include "selection_templates.h"
+#include "streamview.h"
+#include "strip_silence_dialog.h"
+#include "time_axis_view.h"
#include "transpose_dialog.h"
#include "i18n.h"
{
bool frozen = false;
- list <boost::shared_ptr<Playlist > > used_playlists;
+ 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 (!latest_regionviews.empty()) {
+ selection->add (latest_regionviews);
+ }
+
}
/** Move one extreme of the current range selection. If more than one range is selected,
commit_reversible_command ();
} else {
- distance = get_nudge_distance (playhead_cursor->current_frame, next_distance);
- _session->request_locate (playhead_cursor->current_frame + distance);
+ distance = get_nudge_distance (playhead_cursor->current_frame (), next_distance);
+ _session->request_locate (playhead_cursor->current_frame () + distance);
}
}
} else {
- distance = get_nudge_distance (playhead_cursor->current_frame, next_distance);
+ distance = get_nudge_distance (playhead_cursor->current_frame (), next_distance);
- if (playhead_cursor->current_frame > distance) {
- _session->request_locate (playhead_cursor->current_frame - distance);
+ if (playhead_cursor->current_frame () > distance) {
+ _session->request_locate (playhead_cursor->current_frame () - distance);
} else {
_session->goto_start();
}
commit_reversible_command ();
}
+struct RegionSelectionPositionSorter {
+ bool operator() (RegionView* a, RegionView* b) {
+ return a->region()->position() < b->region()->position();
+ }
+};
+
+void
+Editor::sequence_regions ()
+{
+ framepos_t r_end;
+ framepos_t r_end_prev;
+
+ int iCount=0;
+
+ if (!_session) {
+ return;
+ }
+
+ RegionSelection rs = get_regions_from_selection_and_entered ();
+ rs.sort(RegionSelectionPositionSorter());
+
+ if (!rs.empty()) {
+
+ begin_reversible_command (_("sequence regions"));
+ for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
+ boost::shared_ptr<Region> r ((*i)->region());
+
+ r->clear_changes();
+
+ if(r->locked())
+ {
+ continue;
+ }
+ if(r->position_locked())
+ {
+ continue;
+ }
+ if(iCount>0)
+ {
+ r_end_prev=r_end;
+ r->set_position(r_end_prev);
+ }
+
+ _session->add_command (new StatefulDiffCommand (r));
+
+ r_end=r->position() + r->length();
+
+ iCount++;
+ }
+ commit_reversible_command ();
+ }
+}
+
+
/* DISPLAY MOTION */
void
void
Editor::cursor_to_region_boundary (bool with_selection, int32_t dir)
{
- framepos_t pos = playhead_cursor->current_frame;
+ framepos_t pos = playhead_cursor->current_frame ();
framepos_t target;
if (!_session) {
Editor::cursor_to_region_point (EditorCursor* cursor, RegionPoint point, int32_t dir)
{
boost::shared_ptr<Region> r;
- framepos_t pos = cursor->current_frame;
+ framepos_t pos = cursor->current_frame ();
if (!_session) {
return;
void
Editor::scroll_playhead (bool forward)
{
- framepos_t pos = playhead_cursor->current_frame;
- framecnt_t delta = (framecnt_t) floor (current_page_frames() / 0.8);
+ framepos_t pos = playhead_cursor->current_frame ();
+ framecnt_t delta = (framecnt_t) floor (current_page_samples() / 0.8);
if (forward) {
if (pos == max_framepos) {
Location* loc = find_location_from_marker (*i, ignored);
if (loc->is_mark()) {
- loc->set_start (playhead_cursor->current_frame);
+ loc->set_start (playhead_cursor->current_frame ());
} else {
- loc->set (playhead_cursor->current_frame,
- playhead_cursor->current_frame + loc->length());
+ loc->set (playhead_cursor->current_frame (),
+ playhead_cursor->current_frame () + loc->length());
}
}
}
void
Editor::scroll_backward (float pages)
{
- framepos_t const one_page = (framepos_t) rint (_canvas_width * frames_per_unit);
+ framepos_t const one_page = (framepos_t) rint (_visible_canvas_width * samples_per_pixel);
framepos_t const cnt = (framepos_t) floor (pages * one_page);
framepos_t frame;
void
Editor::scroll_forward (float pages)
{
- framepos_t const one_page = (framepos_t) rint (_canvas_width * frames_per_unit);
+ framepos_t const one_page = (framepos_t) rint (_visible_canvas_width * samples_per_pixel);
framepos_t const cnt = (framepos_t) floor (pages * one_page);
framepos_t frame;
Editor::scroll_tracks_down ()
{
double vert_value = vertical_adjustment.get_value() + vertical_adjustment.get_page_size();
- if (vert_value > vertical_adjustment.get_upper() - _canvas_height) {
- vert_value = vertical_adjustment.get_upper() - _canvas_height;
+ if (vert_value > vertical_adjustment.get_upper() - _visible_canvas_height) {
+ vert_value = vertical_adjustment.get_upper() - _visible_canvas_height;
}
vertical_adjustment.set_value (vert_value);
{
double vert_value = vertical_adjustment.get_value() + 60;
- if (vert_value > vertical_adjustment.get_upper() - _canvas_height) {
- vert_value = vertical_adjustment.get_upper() - _canvas_height;
+ if (vert_value > vertical_adjustment.get_upper() - _visible_canvas_height) {
+ vert_value = vertical_adjustment.get_upper() - _visible_canvas_height;
}
vertical_adjustment.set_value (vert_value);
reset_y_origin (vertical_adjustment.get_value() - 60);
}
+bool
+Editor::scroll_down_one_track ()
+{
+ TrackViewList::reverse_iterator next = track_views.rend();
+ std::pair<TimeAxisView*,double> res;
+ const double bottom_of_trackviews = vertical_adjustment.get_value() + vertical_adjustment.get_page_size() - 1;
+
+ for (TrackViewList::reverse_iterator t = track_views.rbegin(); t != track_views.rend(); ++t) {
+ if ((*t)->hidden()) {
+ continue;
+ }
+
+ /* If this is the bottom visible trackview, we want to display
+ the next one.
+ */
+
+ res = (*t)->covers_y_position (bottom_of_trackviews);
+
+ if (res.first) {
+ break;
+ }
+
+ ++next; // moves "next" towards the "front" since it is a reverse iterator
+ }
+
+ /* move to the track below the first one that covers the */
+
+ if (next != track_views.rend()) {
+ ensure_time_axis_view_is_visible (**next);
+ return true;
+ }
+
+ return false;
+}
+
+bool
+Editor::scroll_up_one_track ()
+{
+ double vertical_pos = vertical_adjustment.get_value ();
+
+ TrackViewList::iterator prev = track_views.end();
+ std::pair<TimeAxisView*,double> res;
+
+ for (TrackViewList::iterator t = track_views.begin(); t != track_views.end(); ++t) {
+
+ if ((*t)->hidden()) {
+ continue;
+ }
+
+ /* find the trackview at the top of the trackview group */
+ res = (*t)->covers_y_position (vertical_pos);
+
+ if (res.first) {
+ cerr << res.first->name() << " covers the top\n";
+ break;
+ }
+
+ prev = t;
+ }
+
+ if (prev != track_views.end()) {
+ ensure_time_axis_view_is_visible (**prev);
+ return true;
+ }
+
+ return false;
+}
+
/* ZOOM */
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_frames_per_unit (double& fpu) const
-{
- bool clamped = false;
-
- if (fpu < 2.0) {
- fpu = 2.0;
- clamped = true;
- }
-
- if (max_framepos / fpu < 800) {
- fpu = max_framepos / 800.0;
- clamped = true;
- }
-
- return clamped;
-}
void
Editor::temporal_zoom_step (bool coarser)
{
ENSURE_GUI_THREAD (*this, &Editor::temporal_zoom_step, coarser)
- double nfpu = frames_per_unit;
+ framecnt_t nspp = samples_per_pixel;
if (coarser) {
- nfpu = min (9e6, nfpu * 1.61803399);
+ nspp *= 2;
} else {
- nfpu = max (1.0, nfpu / 1.61803399);
+ nspp /= 2;
}
- temporal_zoom (nfpu);
+ temporal_zoom (nspp);
}
void
-Editor::temporal_zoom (double fpu)
+Editor::temporal_zoom (framecnt_t fpp)
{
if (!_session) {
return;
}
- framepos_t current_page = current_page_frames();
+ framepos_t current_page = current_page_samples();
framepos_t current_leftmost = leftmost_frame;
framepos_t current_rightmost;
framepos_t current_center;
framepos_t leftmost_after_zoom = 0;
framepos_t where;
bool in_track_canvas;
- double nfpu;
+ framecnt_t nfpp;
double l;
- clamp_frames_per_unit (fpu);
- if (fpu == frames_per_unit) {
+ if (fpp == samples_per_pixel) {
return;
}
- nfpu = fpu;
-
// Imposing an arbitrary limit to zoom out as too much zoom out produces
// segfaults for lack of memory. If somebody decides this is not high enough I
// believe it can be raisen to higher values but some limit must be in place.
- if (nfpu > 8e+08) {
- nfpu = 8e+08;
- }
+ //
+ // This constant represents 1 day @ 48kHz on a 1600 pixel wide display
+ // all of which is used for the editor track displays. The whole day
+ // would be 4147200000 samples, so 2592000 samples per pixel.
+
+ nfpp = min (fpp, (framecnt_t) 2592000);
+ nfpp = max ((framecnt_t) 1, fpp);
- new_page_size = (framepos_t) floor (_canvas_width * nfpu);
+ new_page_size = (framepos_t) floor (_visible_canvas_width * nfpp);
half_page_size = new_page_size / 2;
switch (zoom_focus) {
case ZoomFocusPlayhead:
/* centre playhead */
- l = playhead_cursor->current_frame - (new_page_size * 0.5);
+ l = playhead_cursor->current_frame () - (new_page_size * 0.5);
if (l < 0) {
leftmost_after_zoom = 0;
if (!mouse_frame (where, in_track_canvas)) {
/* use playhead instead */
- where = playhead_cursor->current_frame;
+ where = playhead_cursor->current_frame ();
if (where < half_page_size) {
leftmost_after_zoom = 0;
// leftmost_after_zoom = min (leftmost_after_zoom, _session->current_end_frame());
- reposition_and_zoom (leftmost_after_zoom, nfpu);
+ reposition_and_zoom (leftmost_after_zoom, nfpp);
}
void
}
framepos_t range = end - start;
- double new_fpu = (double)range / (double)_canvas_width;
- framepos_t extra_samples = (framepos_t) floor (one_centimeter_in_pixels * new_fpu);
+ 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;
temporal_zoom_by_frame (start, end);
if (both_axes) {
- uint32_t per_track_height = (uint32_t) floor ((_canvas_height - canvas_timebars_vsize - 10.0) / tracks.size());
+ uint32_t per_track_height = (uint32_t) floor ((_visible_canvas_height - 10.0) / tracks.size());
/* set visible track heights appropriately */
/* 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);
}
framepos_t range = end - start;
- double new_fpu = (double)range / (double)_canvas_width;
+ double const new_fpp = (double) range / (double) _visible_canvas_width;
- framepos_t new_page = (framepos_t) floor (_canvas_width * new_fpu);
- 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));
+ framepos_t new_page = (framepos_t) floor (_visible_canvas_width * new_fpp);
+ 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));
if (new_leftmost > middle) {
new_leftmost = 0;
new_leftmost = 0;
}
- reposition_and_zoom (new_leftmost, new_fpu);
+ reposition_and_zoom (new_leftmost, new_fpp);
}
void
if (!_session) {
return;
}
- double range_before = frame - leftmost_frame;
- double new_fpu;
- new_fpu = frames_per_unit;
+ framecnt_t range_before = frame - leftmost_frame;
+ framecnt_t new_spp;
if (coarser) {
- new_fpu *= 1.61803399;
- range_before *= 1.61803399;
+ if (samples_per_pixel <= 1) {
+ new_spp = 2;
+ } else {
+ new_spp = samples_per_pixel + (samples_per_pixel/2);
+ }
+ range_before += range_before/2;
} else {
- new_fpu = max(1.0,(new_fpu/1.61803399));
- range_before /= 1.61803399;
+ if (samples_per_pixel >= 1) {
+ 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 equality test below
+ */
+ new_spp = samples_per_pixel;
+ }
+
+ range_before -= range_before/2;
}
- if (new_fpu == frames_per_unit) {
+ if (new_spp == samples_per_pixel) {
return;
}
+ /* zoom focus is automatically taken as @param frame when this
+ method is used.
+ */
+
framepos_t new_leftmost = frame - (framepos_t)range_before;
if (new_leftmost > frame) {
new_leftmost = 0;
}
- reposition_and_zoom (new_leftmost, new_fpu);
+ reposition_and_zoom (new_leftmost, new_spp);
}
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 ()
return;
}
- framepos_t pos = _session->locations()->first_mark_after (playhead_cursor->current_frame);
+ framepos_t pos = _session->locations()->first_mark_after (playhead_cursor->current_frame());
if (pos < 0) {
return;
return;
}
- framepos_t pos = _session->locations()->first_mark_before (playhead_cursor->current_frame);
+ framepos_t pos = _session->locations()->first_mark_before (playhead_cursor->current_frame());
if (pos < 0) {
return;
/* INSERT/REPLACE */
-void
-Editor::insert_region_list_drag (boost::shared_ptr<Region> region, int x, int y)
-{
- double wx, wy;
- double cx, cy;
- framepos_t where;
- RouteTimeAxisView *rtv = 0;
- boost::shared_ptr<Playlist> playlist;
-
- track_canvas->window_to_world (x, y, wx, wy);
-
- GdkEvent event;
- event.type = GDK_BUTTON_RELEASE;
- event.button.x = wx;
- event.button.y = wy;
-
- where = event_frame (&event, &cx, &cy);
-
- if (where < leftmost_frame || where > leftmost_frame + current_page_frames()) {
- /* 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 wx, wy;
- double cx, cy;
- RouteTimeAxisView *dest_rtv = 0;
- RouteTimeAxisView *source_rtv = 0;
-
- track_canvas->window_to_world (x, y, wx, wy);
- wx += horizontal_position ();
- wy += vertical_adjustment.get_value();
-
- GdkEvent event;
- event.type = GDK_BUTTON_RELEASE;
- event.button.x = wx;
- event.button.y = wy;
-
- event_frame (&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() )
return;
location -= get_preroll();
/* create event pool because we may need to talk to the session */
SessionEvent::create_per_thread_pool ("freeze events", 64);
/* create per-thread buffers for process() tree to use */
- current_interthread_info->process_thread.get_buffers ();
clicked_routeview->audio_track()->freeze_me (*current_interthread_info);
current_interthread_info->done = true;
- current_interthread_info->process_thread.drop_buffers();
return 0;
}
/* wait for just a little while, because the above call is asynchronous */
- ::usleep (250000);
+ Glib::usleep (250000);
if (clicked_routeview == 0 || !clicked_routeview->is_audio_track()) {
return;
/** 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) {
switch (effective_mouse_mode()) {
case MouseObject:
case MouseRange:
+ begin_reversible_command (opname + ' ' + X_("MIDI"));
cut_copy_midi (op);
+ commit_reversible_command ();
break;
default:
break;
}
- } else {
+ return;
+ }
- RegionSelection rs;
+ bool did_edit = false;
- /* we only want to cut regions if some are selected */
+ 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()) {
- rs = selection->regions;
- }
+ if (!selection->regions.empty() || !selection->points.empty()) {
- switch (effective_mouse_mode()) {
-/*
- * case MouseGain: {
- //find regions's gain line
- AudioRegionView *rview = dynamic_cast<AudioRegionView*>(clicked_regionview);
- AutomationTimeAxisView *tview = dynamic_cast<AutomationTimeAxisView*>(clicked_trackview);
- if (rview) {
- AudioRegionGainLine *line = rview->get_gain_line();
- if (!line) break;
-
- //cut region gain points in the selection
- AutomationList& alist (line->the_list());
- XMLNode &before = alist.get_state();
- AutomationList* what_we_got = 0;
- if ((what_we_got = alist.cut (selection->time.front().start - rview->audio_region()->position(), selection->time.front().end - rview->audio_region()->position())) != 0) {
- session->add_command(new MementoCommand<AutomationList>(alist, &before, &alist.get_state()));
- delete what_we_got;
- what_we_got = 0;
- }
-
- rview->set_envelope_visible(true);
- rview->audio_region()->set_envelope_active(true);
-
- } else if (tview) {
- AutomationLine *line = *(tview->lines.begin());
- if (!line) break;
-
- //cut auto points in the selection
- AutomationList& alist (line->the_list());
- XMLNode &before = alist.get_state();
- AutomationList* what_we_got = 0;
- if ((what_we_got = alist.cut (selection->time.front().start, selection->time.front().end)) != 0) {
- session->add_command(new MementoCommand<AutomationList>(alist, &before, &alist.get_state()));
- delete what_we_got;
- what_we_got = 0;
- }
- } else
- break;
- } break;
-*/
- case MouseObject:
- case MouseRange:
- if (!rs.empty() || !selection->points.empty()) {
- begin_reversible_command (opname + _(" objects"));
-
- if (!rs.empty()) {
- cut_copy_regions (op, rs);
-
- if (op == Cut || op == Delete) {
- selection->clear_regions ();
- }
- }
+ string thing_name;
- if (!selection->points.empty()) {
- cut_copy_points (op);
+ 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 (op == Cut || op == Delete) {
- selection->clear_points ();
- }
+ if (!selection->regions.empty()) {
+ cut_copy_regions (op, selection->regions);
+
+ if (op == Cut || op == Delete) {
+ selection->clear_regions ();
}
-
- commit_reversible_command ();
- break;
- }
+ }
- if (selection->time.empty()) {
- framepos_t start, end;
- if (!get_edit_op_range (start, end)) {
- return;
+ if (!selection->points.empty()) {
+ cut_copy_points (op);
+
+ if (op == Cut || op == Delete) {
+ selection->clear_points ();
}
+ }
+ }
+ break;
+
+ 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 (!selection->time.empty()) {
begin_reversible_command (opname + _(" range"));
+
+ did_edit = true;
cut_copy_ranges (op);
- commit_reversible_command ();
if (op == Cut || op == Delete) {
selection->clear_time ();
}
-
- break;
-
- default:
- break;
}
+ break;
+
+ default:
+ break;
}
-
+
+ if (did_edit) {
+ commit_reversible_command ();
+ }
+
if (op == Delete || op == Cut || op == Clear) {
_drags->abort ();
}
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;
}
void
Editor::center_playhead ()
{
- float page = _canvas_width * frames_per_unit;
- center_screen_internal (playhead_cursor->current_frame, page);
+ float const page = _visible_canvas_width * samples_per_pixel;
+ center_screen_internal (playhead_cursor->current_frame (), page);
}
void
Editor::center_edit_point ()
{
- float page = _canvas_width * frames_per_unit;
+ float const page = _visible_canvas_width * samples_per_pixel;
center_screen_internal (get_preferred_edit_position(), page);
}
vector<Evoral::Sequence<Evoral::MusicalTime>::Notes> v;
v.push_back (selected);
- framepos_t pos_frames = mrv.midi_region()->position();
+ framepos_t pos_frames = mrv.midi_region()->position() - mrv.midi_region()->start();
double pos_beats = _session->tempo_map().framewalk_to_beats(0, pos_frames);
return op (mrv.midi_region()->model(), pos_beats, v);
MidiRegionView* const mrv = dynamic_cast<MidiRegionView*>(*r);
if (mrv) {
- boost::shared_ptr<Playlist> playlist = mrv->region()->playlist();
- boost::shared_ptr<MidiRegion> newregion = mrv->midi_region()->clone ();
-
- playlist->clear_changes ();
- playlist->replace_region (mrv->region(), newregion, mrv->region()->position());
- _session->add_command(new StatefulDiffCommand (playlist));
+ try {
+ boost::shared_ptr<Playlist> playlist = mrv->region()->playlist();
+ boost::shared_ptr<MidiSource> new_source = _session->create_midi_source_by_stealing_name (mrv->midi_view()->track());
+ boost::shared_ptr<MidiRegion> newregion = mrv->midi_region()->clone (new_source);
+
+ playlist->clear_changes ();
+ playlist->replace_region (mrv->region(), newregion, mrv->region()->position());
+ _session->add_command(new StatefulDiffCommand (playlist));
+ } catch (...) {
+ error << string_compose (_("Could not unlink %1"), mrv->region()->name()) << endmsg;
+ }
}
r = tmp;
}
}
- 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);
}
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() - canvas_timebars_vsize;
-
- 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() + canvas_timebars_vsize - vertical_adjustment.get_page_size();
- }
-
- vertical_adjustment.set_value(new_value);
+ ensure_time_axis_view_is_visible (*current);
}
void
void
Editor::playhead_forward_to_grid ()
{
- if (!_session) return;
- framepos_t pos = playhead_cursor->current_frame;
+ if (!_session) {
+ return;
+ }
+
+ framepos_t pos = playhead_cursor->current_frame ();
if (pos < max_framepos - 1) {
pos += 2;
snap_to_internal (pos, 1, false);
void
Editor::playhead_backward_to_grid ()
{
- if (!_session) return;
- framepos_t pos = playhead_cursor->current_frame;
+ if (!_session) {
+ return;
+ }
+
+ framepos_t pos = playhead_cursor->current_frame ();
if (pos > 2) {
pos -= 2;
snap_to_internal (pos, -1, false);
for (TrackSelection::iterator x = ts.begin(); x != ts.end(); ++x) {
RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*x);
- if (rtv) {
- if (rtv->is_track()) {
- ntracks++;
- } else {
- nbusses++;
- }
+ if (!rtv) {
+ continue;
+ }
+ if (rtv->is_track()) {
+ ntracks++;
+ } else {
+ nbusses++;
}
routes.push_back (rtv->_route);
return;
}
- for (vector<boost::shared_ptr<Route> >::iterator x = routes.begin(); x != routes.end(); ++x) {
- _session->remove_route (*x);
+ {
+ Session::StateProtector sp (_session);
+ for (vector<boost::shared_ptr<Route> >::iterator x = routes.begin(); x != routes.end(); ++x) {
+ _session->remove_route (*x);
+ }
}
}
++visible_tracks;
}
- uint32_t h = (uint32_t) floor ((_canvas_height - child_heights - canvas_timebars_vsize) / 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 ((_visible_canvas_height - (child_heights + _trackview_group->canvas_origin().y)) / 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;
+ bool within_selected = false;
for (TrackViewList::iterator t = all.begin(); t != all.end(); ++t) {
next = t;
++next;
-
- if (next != all.end()) {
- next_is_selected = tracks.contains (*next);
- } else {
- next_is_selected = false;
- }
-
+
if ((*t)->marked_for_display ()) {
- if (is_selected) {
+ if (tracks.contains (*t)) {
(*t)->set_height (h);
first_y_pos = std::min ((*t)->y_position (), first_y_pos);
- } else {
- if (prev_was_selected && next_is_selected) {
- hide_track_in_display (*t);
- }
+ within_selected = true;
+ } else if (within_selected) {
+ hide_track_in_display (*t);
}
}
-
- prev_was_selected = is_selected;
- is_selected = next_is_selected;
}
/*
request signal handler will cause the vertical adjustment setting to fail
*/
- controls_layout.property_height () = full_canvas_height - canvas_timebars_vsize;
+ controls_layout.property_height () = _full_canvas_height;
vertical_adjustment.set_value (first_y_pos);
redo_visual_stack.push_back (current_visual_state (true));
_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_markup (string_compose ("<span size=\"large\" weight=\"bold\">%1</span>", _("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 ();
+ }
+}
projects / ardour.git / blobdiff