2 Copyright (C) 2009 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 #include "gtk2ardour-config.h"
27 #include "pbd/memento_command.h"
28 #include "pbd/basename.h"
29 #include "pbd/stateful_diff_command.h"
31 #include "gtkmm2ext/utils.h"
33 #include "ardour/audioengine.h"
34 #include "ardour/audioregion.h"
35 #include "ardour/audio_track.h"
36 #include "ardour/dB.h"
37 #include "ardour/midi_region.h"
38 #include "ardour/midi_track.h"
39 #include "ardour/operations.h"
40 #include "ardour/region_factory.h"
41 #include "ardour/session.h"
43 #include "canvas/canvas.h"
44 #include "canvas/scroll_group.h"
49 #include "audio_region_view.h"
50 #include "midi_region_view.h"
51 #include "ardour_ui.h"
52 #include "gui_thread.h"
53 #include "control_point.h"
54 #include "region_gain_line.h"
55 #include "editor_drag.h"
56 #include "audio_time_axis.h"
57 #include "midi_time_axis.h"
58 #include "selection.h"
59 #include "midi_selection.h"
60 #include "automation_time_axis.h"
62 #include "editor_cursors.h"
63 #include "mouse_cursors.h"
64 #include "note_base.h"
65 #include "patch_change.h"
66 #include "verbose_cursor.h"
69 using namespace ARDOUR;
72 using namespace Gtkmm2ext;
73 using namespace Editing;
74 using namespace ArdourCanvas;
76 using Gtkmm2ext::Keyboard;
78 double ControlPointDrag::_zero_gain_fraction = -1.0;
80 DragManager::DragManager (Editor* e)
83 , _current_pointer_frame (0)
87 DragManager::~DragManager ()
92 /** Call abort for each active drag */
98 cerr << "Aborting drag\n";
100 for (list<Drag*>::const_iterator i = _drags.begin(); i != _drags.end(); ++i) {
105 if (!_drags.empty ()) {
106 _editor->set_follow_playhead (_old_follow_playhead, false);
115 DragManager::add (Drag* d)
117 d->set_manager (this);
118 _drags.push_back (d);
122 DragManager::set (Drag* d, GdkEvent* e, Gdk::Cursor* c)
124 d->set_manager (this);
125 _drags.push_back (d);
130 DragManager::start_grab (GdkEvent* e, Gdk::Cursor* c)
132 /* Prevent follow playhead during the drag to be nice to the user */
133 _old_follow_playhead = _editor->follow_playhead ();
134 _editor->set_follow_playhead (false);
136 _current_pointer_frame = _editor->canvas_event_sample (e, &_current_pointer_x, &_current_pointer_y);
138 for (list<Drag*>::const_iterator i = _drags.begin(); i != _drags.end(); ++i) {
139 (*i)->start_grab (e, c);
143 /** Call end_grab for each active drag.
144 * @return true if any drag reported movement having occurred.
147 DragManager::end_grab (GdkEvent* e)
152 for (list<Drag*>::iterator i = _drags.begin(); i != _drags.end(); ++i) {
153 bool const t = (*i)->end_grab (e);
164 _editor->set_follow_playhead (_old_follow_playhead, false);
170 DragManager::mark_double_click ()
172 for (list<Drag*>::const_iterator i = _drags.begin(); i != _drags.end(); ++i) {
173 (*i)->set_double_click (true);
178 DragManager::motion_handler (GdkEvent* e, bool from_autoscroll)
182 /* calling this implies that we expect the event to have canvas
185 * Can we guarantee that this is true?
188 _current_pointer_frame = _editor->canvas_event_sample (e, &_current_pointer_x, &_current_pointer_y);
190 for (list<Drag*>::iterator i = _drags.begin(); i != _drags.end(); ++i) {
191 bool const t = (*i)->motion_handler (e, from_autoscroll);
192 /* run all handlers; return true if at least one of them
193 returns true (indicating that the event has been handled).
205 DragManager::have_item (ArdourCanvas::Item* i) const
207 list<Drag*>::const_iterator j = _drags.begin ();
208 while (j != _drags.end() && (*j)->item () != i) {
212 return j != _drags.end ();
215 Drag::Drag (Editor* e, ArdourCanvas::Item* i, bool trackview_only)
218 , _pointer_frame_offset (0)
219 , _trackview_only (trackview_only)
220 , _move_threshold_passed (false)
221 , _was_double_click (false)
222 , _raw_grab_frame (0)
224 , _last_pointer_frame (0)
230 Drag::swap_grab (ArdourCanvas::Item* new_item, Gdk::Cursor* cursor, uint32_t /*time*/)
243 Drag::start_grab (GdkEvent* event, Gdk::Cursor *cursor)
245 // if dragging with button2, the motion is x constrained, with Alt-button2 it is y constrained
247 if (Keyboard::is_button2_event (&event->button)) {
248 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::SecondaryModifier)) {
249 _y_constrained = true;
250 _x_constrained = false;
252 _y_constrained = false;
253 _x_constrained = true;
256 _x_constrained = false;
257 _y_constrained = false;
260 _raw_grab_frame = _editor->canvas_event_sample (event, &_grab_x, &_grab_y);
261 setup_pointer_frame_offset ();
262 _grab_frame = adjusted_frame (_raw_grab_frame, event);
263 _last_pointer_frame = _grab_frame;
264 _last_pointer_x = _grab_x;
266 if (_trackview_only) {
267 _grab_y = _grab_y - _editor->get_trackview_group()->canvas_origin().y;
270 _last_pointer_y = _grab_y;
275 /* CAIROCANVAS need a variant here that passes *cursor */
277 _editor->push_canvas_cursor (cursor);
280 if (_editor->session() && _editor->session()->transport_rolling()) {
283 _was_rolling = false;
286 switch (_editor->snap_type()) {
287 case SnapToRegionStart:
288 case SnapToRegionEnd:
289 case SnapToRegionSync:
290 case SnapToRegionBoundary:
291 _editor->build_region_boundary_cache ();
298 /** Call to end a drag `successfully'. Ungrabs item and calls
299 * subclass' finished() method.
301 * @param event GDK event, or 0.
302 * @return true if some movement occurred, otherwise false.
305 Drag::end_grab (GdkEvent* event)
307 _editor->stop_canvas_autoscroll ();
311 finished (event, _move_threshold_passed);
313 _editor->verbose_cursor()->hide ();
314 _editor->pop_canvas_cursor ();
316 return _move_threshold_passed;
320 Drag::adjusted_frame (framepos_t f, GdkEvent const * event, bool snap) const
324 if (f > _pointer_frame_offset) {
325 pos = f - _pointer_frame_offset;
329 _editor->snap_to_with_modifier (pos, event);
336 Drag::adjusted_current_frame (GdkEvent const * event, bool snap) const
338 return adjusted_frame (_drags->current_pointer_frame (), event, snap);
342 Drag::current_pointer_x() const
344 return _drags->current_pointer_x ();
348 Drag::current_pointer_y () const
350 if (!_trackview_only) {
351 return _drags->current_pointer_y ();
354 return _drags->current_pointer_y () - _editor->get_trackview_group()->canvas_origin().y;
358 Drag::motion_handler (GdkEvent* event, bool from_autoscroll)
360 /* check to see if we have moved in any way that matters since the last motion event */
361 if (_move_threshold_passed &&
362 (!x_movement_matters() || _last_pointer_x == current_pointer_x ()) &&
363 (!y_movement_matters() || _last_pointer_y == current_pointer_y ()) ) {
367 pair<framecnt_t, int> const threshold = move_threshold ();
369 bool const old_move_threshold_passed = _move_threshold_passed;
371 if (!from_autoscroll && !_move_threshold_passed) {
373 bool const xp = (::llabs (_drags->current_pointer_frame () - _raw_grab_frame) >= threshold.first);
374 bool const yp = (::fabs ((current_pointer_y () - _grab_y)) >= threshold.second);
376 _move_threshold_passed = ((xp && x_movement_matters()) || (yp && y_movement_matters()));
379 if (active (_editor->mouse_mode) && _move_threshold_passed) {
381 if (event->motion.state & Gdk::BUTTON1_MASK || event->motion.state & Gdk::BUTTON2_MASK) {
382 if (!from_autoscroll) {
383 _editor->maybe_autoscroll (true, allow_vertical_autoscroll (), false);
386 if (!_editor->autoscroll_active() || from_autoscroll) {
387 motion (event, _move_threshold_passed != old_move_threshold_passed);
389 _last_pointer_x = _drags->current_pointer_x ();
390 _last_pointer_y = current_pointer_y ();
391 _last_pointer_frame = adjusted_current_frame (event);
401 /** Call to abort a drag. Ungrabs item and calls subclass's aborted () */
409 aborted (_move_threshold_passed);
411 _editor->stop_canvas_autoscroll ();
412 _editor->verbose_cursor()->hide ();
416 Drag::show_verbose_cursor_time (framepos_t frame)
418 _editor->verbose_cursor()->set_time (frame);
419 _editor->verbose_cursor()->show ();
423 Drag::show_verbose_cursor_duration (framepos_t start, framepos_t end, double /*xoffset*/)
425 _editor->verbose_cursor()->set_duration (start, end);
426 _editor->verbose_cursor()->show ();
430 Drag::show_verbose_cursor_text (string const & text)
432 _editor->verbose_cursor()->set (text);
433 _editor->verbose_cursor()->show ();
436 boost::shared_ptr<Region>
437 Drag::add_midi_region (MidiTimeAxisView* view)
439 if (_editor->session()) {
440 const TempoMap& map (_editor->session()->tempo_map());
441 framecnt_t pos = grab_frame();
442 const Meter& m = map.meter_at (pos);
443 /* not that the frame rate used here can be affected by pull up/down which
446 framecnt_t len = m.frames_per_bar (map.tempo_at (pos), _editor->session()->frame_rate());
447 return view->add_region (grab_frame(), len, true);
450 return boost::shared_ptr<Region>();
453 struct EditorOrderTimeAxisViewSorter {
454 bool operator() (TimeAxisView* a, TimeAxisView* b) {
455 RouteTimeAxisView* ra = dynamic_cast<RouteTimeAxisView*> (a);
456 RouteTimeAxisView* rb = dynamic_cast<RouteTimeAxisView*> (b);
458 return ra->route()->order_key () < rb->route()->order_key ();
462 RegionDrag::RegionDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v)
466 _editor->visible_order_range (&_visible_y_low, &_visible_y_high);
468 /* Make a list of tracks to refer to during the drag; we include hidden tracks,
469 as some of the regions we are dragging may be on such tracks.
472 TrackViewList track_views = _editor->track_views;
473 track_views.sort (EditorOrderTimeAxisViewSorter ());
475 for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
476 _time_axis_views.push_back (*i);
478 TimeAxisView::Children children_list = (*i)->get_child_list ();
479 for (TimeAxisView::Children::iterator j = children_list.begin(); j != children_list.end(); ++j) {
480 _time_axis_views.push_back (j->get());
484 /* the list of views can be empty at this point if this is a region list-insert drag
487 for (list<RegionView*>::const_iterator i = v.begin(); i != v.end(); ++i) {
488 _views.push_back (DraggingView (*i, this, &(*i)->get_time_axis_view()));
491 RegionView::RegionViewGoingAway.connect (death_connection, invalidator (*this), boost::bind (&RegionDrag::region_going_away, this, _1), gui_context());
495 RegionDrag::region_going_away (RegionView* v)
497 list<DraggingView>::iterator i = _views.begin ();
498 while (i != _views.end() && i->view != v) {
502 if (i != _views.end()) {
507 /** Given a TimeAxisView, return the index of it into the _time_axis_views vector,
508 * or -1 if it is not found.
511 RegionDrag::find_time_axis_view (TimeAxisView* t) const
514 int const N = _time_axis_views.size ();
515 while (i < N && _time_axis_views[i] != t) {
526 RegionMotionDrag::RegionMotionDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v, bool b)
527 : RegionDrag (e, i, p, v)
530 , _last_pointer_time_axis_view (0)
531 , _last_pointer_layer (0)
533 DEBUG_TRACE (DEBUG::Drags, "New RegionMotionDrag\n");
537 RegionMotionDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
539 Drag::start_grab (event, cursor);
541 show_verbose_cursor_time (_last_frame_position);
543 pair<TimeAxisView*, double> const tv = _editor->trackview_by_y_position (current_pointer_y ());
545 _last_pointer_time_axis_view = find_time_axis_view (tv.first);
546 _last_pointer_layer = tv.first->layer_display() == Overlaid ? 0 : tv.second;
551 RegionMotionDrag::compute_x_delta (GdkEvent const * event, framepos_t* pending_region_position)
553 /* compute the amount of pointer motion in frames, and where
554 the region would be if we moved it by that much.
556 *pending_region_position = adjusted_current_frame (event);
558 framepos_t sync_frame;
559 framecnt_t sync_offset;
562 sync_offset = _primary->region()->sync_offset (sync_dir);
564 /* we don't handle a sync point that lies before zero.
566 if (sync_dir >= 0 || (sync_dir < 0 && *pending_region_position >= sync_offset)) {
568 sync_frame = *pending_region_position + (sync_dir*sync_offset);
570 _editor->snap_to_with_modifier (sync_frame, event);
572 *pending_region_position = _primary->region()->adjust_to_sync (sync_frame);
575 *pending_region_position = _last_frame_position;
578 if (*pending_region_position > max_framepos - _primary->region()->length()) {
579 *pending_region_position = _last_frame_position;
584 /* in locked edit mode, reverse the usual meaning of _x_constrained */
585 bool const x_move_allowed = Config->get_edit_mode() == Lock ? _x_constrained : !_x_constrained;
587 if ((*pending_region_position != _last_frame_position) && x_move_allowed) {
589 /* x movement since last time (in pixels) */
590 dx = (static_cast<double> (*pending_region_position) - _last_frame_position) / _editor->samples_per_pixel;
592 /* total x movement */
593 framecnt_t total_dx = *pending_region_position;
594 if (regions_came_from_canvas()) {
595 total_dx = total_dx - grab_frame ();
598 /* check that no regions have gone off the start of the session */
599 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
600 if ((i->view->region()->position() + total_dx) < 0) {
602 *pending_region_position = _last_frame_position;
613 RegionMotionDrag::y_movement_allowed (int delta_track, double delta_layer) const
615 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
616 int const n = i->time_axis_view + delta_track;
617 if (n < 0 || n >= int (_time_axis_views.size())) {
618 /* off the top or bottom track */
622 RouteTimeAxisView const * to = dynamic_cast<RouteTimeAxisView const *> (_time_axis_views[n]);
623 if (to == 0 || !to->is_track() || to->track()->data_type() != i->view->region()->data_type()) {
624 /* not a track, or the wrong type */
628 double const l = i->layer + delta_layer;
630 /* Note that we allow layer to be up to 0.5 below zero, as this is used by `Expanded'
631 mode to allow the user to place a region below another on layer 0.
633 if (delta_track == 0 && (l < -0.5 || l >= int (to->view()->layers()))) {
634 /* Off the top or bottom layer; note that we only refuse if the track hasn't changed.
635 If it has, the layers will be munged later anyway, so it's ok.
641 /* all regions being dragged are ok with this change */
646 RegionMotionDrag::motion (GdkEvent* event, bool first_move)
648 double delta_layer = 0;
649 int delta_time_axis_view = 0;
651 assert (!_views.empty ());
653 /* Note: time axis views in this method are often expressed as an index into the _time_axis_views vector */
655 /* Find the TimeAxisView that the pointer is now over */
656 pair<TimeAxisView*, double> const r = _editor->trackview_by_y_position (current_pointer_y ());
657 TimeAxisView* tv = r.first;
659 if (tv && tv->view()) {
660 double layer = r.second;
662 if (first_move && tv->view()->layer_display() == Stacked) {
663 tv->view()->set_layer_display (Expanded);
666 /* Here's the current pointer position in terms of time axis view and layer */
667 int const current_pointer_time_axis_view = find_time_axis_view (tv);
668 double const current_pointer_layer = tv->layer_display() == Overlaid ? 0 : layer;
670 /* Work out the change in y */
672 delta_time_axis_view = current_pointer_time_axis_view - _last_pointer_time_axis_view;
673 delta_layer = current_pointer_layer - _last_pointer_layer;
676 /* Work out the change in x */
677 framepos_t pending_region_position;
678 double const x_delta = compute_x_delta (event, &pending_region_position);
679 _last_frame_position = pending_region_position;
681 /* Verify change in y */
682 if (!y_movement_allowed (delta_time_axis_view, delta_layer)) {
683 /* this y movement is not allowed, so do no y movement this time */
684 delta_time_axis_view = 0;
688 if (x_delta == 0 && (tv && tv->view() && delta_time_axis_view == 0) && delta_layer == 0 && !first_move) {
689 /* haven't reached next snap point, and we're not switching
690 trackviews nor layers. nothing to do.
695 pair<set<boost::shared_ptr<Playlist> >::iterator,bool> insert_result;
697 for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
699 RegionView* rv = i->view;
701 if (rv->region()->locked() || rv->region()->video_locked()) {
708 /* reparent the regionview into a group above all
712 ArdourCanvas::Item* rvg = rv->get_canvas_group();
713 Duple rv_canvas_offset = rvg->parent()->canvas_origin ();
714 Duple dmg_canvas_offset = _editor->_drag_motion_group->canvas_origin ();
715 rv->get_canvas_group()->reparent (_editor->_drag_motion_group);
716 /* move the item so that it continues to appear at the
717 same location now that its parent has changed.
719 rvg->move (rv_canvas_offset - dmg_canvas_offset);
722 /* If we have moved tracks, we'll fudge the layer delta so that the
723 region gets moved back onto layer 0 on its new track; this avoids
724 confusion when dragging regions from non-zero layers onto different
727 double this_delta_layer = delta_layer;
728 if (delta_time_axis_view != 0) {
729 this_delta_layer = - i->layer;
736 if (i->time_axis_view >= 0) {
737 track_index = i->time_axis_view + delta_time_axis_view;
739 track_index = _time_axis_views.size() - 1 + delta_time_axis_view;
742 if (track_index < 0 || track_index >= (int) _time_axis_views.size()) {
746 /* The TimeAxisView that this region is now over */
747 TimeAxisView* current_tv = _time_axis_views[track_index];
749 /* Ensure it is moved from stacked -> expanded if appropriate */
750 if (current_tv->view()->layer_display() == Stacked) {
751 current_tv->view()->set_layer_display (Expanded);
754 /* We're only allowed to go -ve in layer on Expanded views */
755 if (current_tv->view()->layer_display() != Expanded && (i->layer + this_delta_layer) < 0) {
756 this_delta_layer = - i->layer;
760 rv->set_height (current_tv->view()->child_height ());
762 /* Update show/hidden status as the region view may have come from a hidden track,
763 or have moved to one.
765 if (current_tv->hidden ()) {
766 rv->get_canvas_group()->hide ();
768 rv->get_canvas_group()->show ();
771 /* Update the DraggingView */
772 i->time_axis_view = track_index;
773 i->layer += this_delta_layer;
776 _editor->mouse_brush_insert_region (rv, pending_region_position);
780 /* Get the y coordinate of the top of the track that this region is now over */
781 track_origin = current_tv->canvas_display()->item_to_canvas (track_origin);
783 /* And adjust for the layer that it should be on */
784 StreamView* cv = current_tv->view ();
785 switch (cv->layer_display ()) {
789 track_origin.y += (cv->layers() - i->layer - 1) * cv->child_height ();
792 track_origin.y += (cv->layers() - i->layer - 0.5) * 2 * cv->child_height ();
796 /* need to get the parent of the regionview
797 * canvas group and get its position in
798 * equivalent coordinate space as the trackview
799 * we are now dragging over.
802 /* Now move the region view */
803 rv->move (x_delta, track_origin.y - rv->get_canvas_group()->canvas_origin().y);
807 /* Only move the region into the empty dropzone at the bottom if the pointer
811 if (current_pointer_y() >= 0) {
813 Coord last_track_bottom_edge;
814 if (!_time_axis_views.empty()) {
815 TimeAxisView* last = _time_axis_views.back();
816 last_track_bottom_edge = last->canvas_display()->canvas_origin ().y + last->effective_height();
818 last_track_bottom_edge = 0;
821 rv->move (x_delta, last_track_bottom_edge - rv->get_canvas_group()->canvas_origin().y);
822 i->time_axis_view = -1;
826 } /* foreach region */
828 _total_x_delta += x_delta;
830 if (x_delta != 0 && !_brushing) {
831 show_verbose_cursor_time (_last_frame_position);
834 _last_pointer_time_axis_view += delta_time_axis_view;
835 _last_pointer_layer += delta_layer;
839 RegionMoveDrag::motion (GdkEvent* event, bool first_move)
841 if (_copy && first_move) {
843 /* duplicate the regionview(s) and region(s) */
845 list<DraggingView> new_regionviews;
847 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
849 RegionView* rv = i->view;
850 AudioRegionView* arv = dynamic_cast<AudioRegionView*>(rv);
851 MidiRegionView* mrv = dynamic_cast<MidiRegionView*>(rv);
853 const boost::shared_ptr<const Region> original = rv->region();
854 boost::shared_ptr<Region> region_copy = RegionFactory::create (original, true);
855 region_copy->set_position (original->position());
859 boost::shared_ptr<AudioRegion> audioregion_copy
860 = boost::dynamic_pointer_cast<AudioRegion>(region_copy);
862 nrv = new AudioRegionView (*arv, audioregion_copy);
864 boost::shared_ptr<MidiRegion> midiregion_copy
865 = boost::dynamic_pointer_cast<MidiRegion>(region_copy);
866 nrv = new MidiRegionView (*mrv, midiregion_copy);
871 nrv->get_canvas_group()->show ();
872 new_regionviews.push_back (DraggingView (nrv, this, i->initial_time_axis_view));
874 /* swap _primary to the copy */
876 if (rv == _primary) {
880 /* ..and deselect the one we copied */
882 rv->set_selected (false);
885 if (!new_regionviews.empty()) {
887 /* reflect the fact that we are dragging the copies */
889 _views = new_regionviews;
891 swap_grab (new_regionviews.front().view->get_canvas_group (), 0, event ? event->motion.time : 0);
895 RegionMotionDrag::motion (event, first_move);
899 RegionMotionDrag::finished (GdkEvent *, bool)
901 for (vector<TimeAxisView*>::iterator i = _time_axis_views.begin(); i != _time_axis_views.end(); ++i) {
906 if ((*i)->view()->layer_display() == Expanded) {
907 (*i)->view()->set_layer_display (Stacked);
913 RegionMoveDrag::finished (GdkEvent* ev, bool movement_occurred)
915 RegionMotionDrag::finished (ev, movement_occurred);
917 if (!movement_occurred) {
921 if (was_double_click() && !_views.empty()) {
922 DraggingView dv = _views.front();
923 dv.view->show_region_editor ();
930 /* reverse this here so that we have the correct logic to finalize
934 if (Config->get_edit_mode() == Lock) {
935 _x_constrained = !_x_constrained;
938 assert (!_views.empty ());
940 /* We might have hidden region views so that they weren't visible during the drag
941 (when they have been reparented). Now everything can be shown again, as region
942 views are back in their track parent groups.
944 for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
945 i->view->get_canvas_group()->show ();
948 bool const changed_position = (_last_frame_position != _primary->region()->position());
949 bool const changed_tracks = (_time_axis_views[_views.front().time_axis_view] != &_views.front().view->get_time_axis_view());
950 framecnt_t const drag_delta = _primary->region()->position() - _last_frame_position;
970 _editor->maybe_locate_with_edit_preroll (_editor->get_selection().regions.start());
974 RegionMoveDrag::create_destination_time_axis (boost::shared_ptr<Region> region, TimeAxisView* original)
976 /* Add a new track of the correct type, and return the RouteTimeAxisView that is created to display the
981 if (boost::dynamic_pointer_cast<AudioRegion> (region)) {
982 list<boost::shared_ptr<AudioTrack> > audio_tracks;
983 audio_tracks = _editor->session()->new_audio_track (region->n_channels(), region->n_channels(), ARDOUR::Normal, 0, 1, region->name());
984 RouteTimeAxisView* rtav = _editor->axis_view_from_route (audio_tracks.front());
986 rtav->set_height (original->current_height());
990 ChanCount one_midi_port (DataType::MIDI, 1);
991 list<boost::shared_ptr<MidiTrack> > midi_tracks;
992 midi_tracks = _editor->session()->new_midi_track (one_midi_port, one_midi_port, boost::shared_ptr<ARDOUR::PluginInfo>(), ARDOUR::Normal, 0, 1, region->name());
993 RouteTimeAxisView* rtav = _editor->axis_view_from_route (midi_tracks.front());
995 rtav->set_height (original->current_height());
1000 error << _("Could not create new track after region placed in the drop zone") << endmsg;
1006 RegionMoveDrag::finished_copy (bool const changed_position, bool const /*changed_tracks*/, framecnt_t const drag_delta)
1008 RegionSelection new_views;
1009 PlaylistSet modified_playlists;
1010 RouteTimeAxisView* new_time_axis_view = 0;
1013 /* all changes were made during motion event handlers */
1015 for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
1019 _editor->commit_reversible_command ();
1023 if (_x_constrained) {
1024 _editor->begin_reversible_command (Operations::fixed_time_region_copy);
1026 _editor->begin_reversible_command (Operations::region_copy);
1029 /* insert the regions into their new playlists */
1030 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end();) {
1032 RouteTimeAxisView* dest_rtv = 0;
1034 if (i->view->region()->locked() || i->view->region()->video_locked()) {
1040 if (changed_position && !_x_constrained) {
1041 where = i->view->region()->position() - drag_delta;
1043 where = i->view->region()->position();
1046 if (i->time_axis_view < 0) {
1047 if (!new_time_axis_view) {
1048 new_time_axis_view = create_destination_time_axis (i->view->region(), i->initial_time_axis_view);
1050 dest_rtv = new_time_axis_view;
1052 dest_rtv = dynamic_cast<RouteTimeAxisView*> (_time_axis_views[i->time_axis_view]);
1055 if (dest_rtv != 0) {
1056 RegionView* new_view = insert_region_into_playlist (i->view->region(), dest_rtv, i->layer, where, modified_playlists);
1057 if (new_view != 0) {
1058 new_views.push_back (new_view);
1062 /* Delete the copy of the view that was used for dragging. Need to play safe with the iterator
1063 since deletion will automagically remove it from _views, thus invalidating i as an iterator.
1066 list<DraggingView>::const_iterator next = i;
1072 /* If we've created new regions either by copying or moving
1073 to a new track, we want to replace the old selection with the new ones
1076 if (new_views.size() > 0) {
1077 _editor->selection->set (new_views);
1080 /* write commands for the accumulated diffs for all our modified playlists */
1081 add_stateful_diff_commands_for_playlists (modified_playlists);
1083 _editor->commit_reversible_command ();
1087 RegionMoveDrag::finished_no_copy (
1088 bool const changed_position,
1089 bool const changed_tracks,
1090 framecnt_t const drag_delta
1093 RegionSelection new_views;
1094 PlaylistSet modified_playlists;
1095 PlaylistSet frozen_playlists;
1096 set<RouteTimeAxisView*> views_to_update;
1097 RouteTimeAxisView* new_time_axis_view = 0;
1100 /* all changes were made during motion event handlers */
1101 _editor->commit_reversible_command ();
1105 if (_x_constrained) {
1106 _editor->begin_reversible_command (_("fixed time region drag"));
1108 _editor->begin_reversible_command (Operations::region_drag);
1111 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ) {
1113 RegionView* rv = i->view;
1114 RouteTimeAxisView* dest_rtv = 0;
1116 if (rv->region()->locked() || rv->region()->video_locked()) {
1121 if (i->time_axis_view < 0) {
1122 if (!new_time_axis_view) {
1123 new_time_axis_view = create_destination_time_axis (rv->region(), i->initial_time_axis_view);
1125 dest_rtv = new_time_axis_view;
1127 dest_rtv = dynamic_cast<RouteTimeAxisView*> (_time_axis_views[i->time_axis_view]);
1132 double const dest_layer = i->layer;
1134 views_to_update.insert (dest_rtv);
1138 if (changed_position && !_x_constrained) {
1139 where = rv->region()->position() - drag_delta;
1141 where = rv->region()->position();
1144 if (changed_tracks) {
1146 /* insert into new playlist */
1148 RegionView* new_view = insert_region_into_playlist (
1149 RegionFactory::create (rv->region (), true), dest_rtv, dest_layer, where, modified_playlists
1152 if (new_view == 0) {
1157 new_views.push_back (new_view);
1159 /* remove from old playlist */
1161 /* the region that used to be in the old playlist is not
1162 moved to the new one - we use a copy of it. as a result,
1163 any existing editor for the region should no longer be
1166 rv->hide_region_editor();
1169 remove_region_from_playlist (rv->region(), i->initial_playlist, modified_playlists);
1173 boost::shared_ptr<Playlist> playlist = dest_rtv->playlist();
1175 /* this movement may result in a crossfade being modified, or a layering change,
1176 so we need to get undo data from the playlist as well as the region.
1179 pair<PlaylistSet::iterator, bool> r = modified_playlists.insert (playlist);
1181 playlist->clear_changes ();
1184 rv->region()->clear_changes ();
1187 motion on the same track. plonk the previously reparented region
1188 back to its original canvas group (its streamview).
1189 No need to do anything for copies as they are fake regions which will be deleted.
1192 rv->get_canvas_group()->reparent (dest_rtv->view()->canvas_item());
1193 rv->get_canvas_group()->set_y_position (i->initial_y);
1196 /* just change the model */
1197 if (dest_rtv->view()->layer_display() == Stacked || dest_rtv->view()->layer_display() == Expanded) {
1198 playlist->set_layer (rv->region(), dest_layer);
1201 /* freeze playlist to avoid lots of relayering in the case of a multi-region drag */
1203 r = frozen_playlists.insert (playlist);
1206 playlist->freeze ();
1209 rv->region()->set_position (where);
1211 _editor->session()->add_command (new StatefulDiffCommand (rv->region()));
1214 if (changed_tracks) {
1216 /* OK, this is where it gets tricky. If the playlist was being used by >1 tracks, and the region
1217 was selected in all of them, then removing it from a playlist will have removed all
1218 trace of it from _views (i.e. there were N regions selected, we removed 1,
1219 but since its the same playlist for N tracks, all N tracks updated themselves, removed the
1220 corresponding regionview, and _views is now empty).
1222 This could have invalidated any and all iterators into _views.
1224 The heuristic we use here is: if the region selection is empty, break out of the loop
1225 here. if the region selection is not empty, then restart the loop because we know that
1226 we must have removed at least the region(view) we've just been working on as well as any
1227 that we processed on previous iterations.
1229 EXCEPT .... if we are doing a copy drag, then _views hasn't been modified and
1230 we can just iterate.
1234 if (_views.empty()) {
1245 /* If we've created new regions either by copying or moving
1246 to a new track, we want to replace the old selection with the new ones
1249 if (new_views.size() > 0) {
1250 _editor->selection->set (new_views);
1253 for (set<boost::shared_ptr<Playlist> >::iterator p = frozen_playlists.begin(); p != frozen_playlists.end(); ++p) {
1257 /* write commands for the accumulated diffs for all our modified playlists */
1258 add_stateful_diff_commands_for_playlists (modified_playlists);
1260 _editor->commit_reversible_command ();
1262 /* We have futzed with the layering of canvas items on our streamviews.
1263 If any region changed layer, this will have resulted in the stream
1264 views being asked to set up their region views, and all will be well.
1265 If not, we might now have badly-ordered region views. Ask the StreamViews
1266 involved to sort themselves out, just in case.
1269 for (set<RouteTimeAxisView*>::iterator i = views_to_update.begin(); i != views_to_update.end(); ++i) {
1270 (*i)->view()->playlist_layered ((*i)->track ());
1274 /** Remove a region from a playlist, clearing the diff history of the playlist first if necessary.
1275 * @param region Region to remove.
1276 * @param playlist playlist To remove from.
1277 * @param modified_playlists The playlist will be added to this if it is not there already; used to ensure
1278 * that clear_changes () is only called once per playlist.
1281 RegionMoveDrag::remove_region_from_playlist (
1282 boost::shared_ptr<Region> region,
1283 boost::shared_ptr<Playlist> playlist,
1284 PlaylistSet& modified_playlists
1287 pair<set<boost::shared_ptr<Playlist> >::iterator, bool> r = modified_playlists.insert (playlist);
1290 playlist->clear_changes ();
1293 playlist->remove_region (region); // should be no need to ripple; we better already have rippled the playlist in RegionRippleDrag
1297 /** Insert a region into a playlist, handling the recovery of the resulting new RegionView, and
1298 * clearing the playlist's diff history first if necessary.
1299 * @param region Region to insert.
1300 * @param dest_rtv Destination RouteTimeAxisView.
1301 * @param dest_layer Destination layer.
1302 * @param where Destination position.
1303 * @param modified_playlists The playlist will be added to this if it is not there already; used to ensure
1304 * that clear_changes () is only called once per playlist.
1305 * @return New RegionView, or 0 if no insert was performed.
1308 RegionMoveDrag::insert_region_into_playlist (
1309 boost::shared_ptr<Region> region,
1310 RouteTimeAxisView* dest_rtv,
1313 PlaylistSet& modified_playlists
1316 boost::shared_ptr<Playlist> dest_playlist = dest_rtv->playlist ();
1317 if (!dest_playlist) {
1321 /* arrange to collect the new region view that will be created as a result of our playlist insertion */
1322 _new_region_view = 0;
1323 sigc::connection c = dest_rtv->view()->RegionViewAdded.connect (sigc::mem_fun (*this, &RegionMoveDrag::collect_new_region_view));
1325 /* clear history for the playlist we are about to insert to, provided we haven't already done so */
1326 pair<PlaylistSet::iterator, bool> r = modified_playlists.insert (dest_playlist);
1328 dest_playlist->clear_changes ();
1331 dest_playlist->add_region (region, where);
1333 if (dest_rtv->view()->layer_display() == Stacked || dest_rtv->view()->layer_display() == Expanded) {
1334 dest_playlist->set_layer (region, dest_layer);
1339 assert (_new_region_view);
1341 return _new_region_view;
1345 RegionMoveDrag::collect_new_region_view (RegionView* rv)
1347 _new_region_view = rv;
1351 RegionMoveDrag::add_stateful_diff_commands_for_playlists (PlaylistSet const & playlists)
1353 for (PlaylistSet::const_iterator i = playlists.begin(); i != playlists.end(); ++i) {
1354 StatefulDiffCommand* c = new StatefulDiffCommand (*i);
1356 _editor->session()->add_command (c);
1365 RegionMoveDrag::aborted (bool movement_occurred)
1369 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
1376 RegionMotionDrag::aborted (movement_occurred);
1381 RegionMotionDrag::aborted (bool)
1383 for (vector<TimeAxisView*>::iterator i = _time_axis_views.begin(); i != _time_axis_views.end(); ++i) {
1385 StreamView* sview = (*i)->view();
1388 if (sview->layer_display() == Expanded) {
1389 sview->set_layer_display (Stacked);
1394 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
1395 RegionView* rv = i->view;
1396 TimeAxisView* tv = &(rv->get_time_axis_view ());
1397 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tv);
1399 rv->get_canvas_group()->reparent (rtv->view()->canvas_item());
1400 rv->get_canvas_group()->set_y_position (0);
1402 rv->move (-_total_x_delta, 0);
1403 rv->set_height (rtv->view()->child_height ());
1407 /** @param b true to brush, otherwise false.
1408 * @param c true to make copies of the regions being moved, otherwise false.
1410 RegionMoveDrag::RegionMoveDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v, bool b, bool c)
1411 : RegionMotionDrag (e, i, p, v, b),
1414 DEBUG_TRACE (DEBUG::Drags, "New RegionMoveDrag\n");
1417 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (&_primary->get_time_axis_view ());
1418 if (rtv && rtv->is_track()) {
1419 speed = rtv->track()->speed ();
1422 _last_frame_position = static_cast<framepos_t> (_primary->region()->position() / speed);
1426 RegionMoveDrag::setup_pointer_frame_offset ()
1428 _pointer_frame_offset = raw_grab_frame() - _last_frame_position;
1431 RegionInsertDrag::RegionInsertDrag (Editor* e, boost::shared_ptr<Region> r, RouteTimeAxisView* v, framepos_t pos)
1432 : RegionMotionDrag (e, 0, 0, list<RegionView*> (), false)
1434 DEBUG_TRACE (DEBUG::Drags, "New RegionInsertDrag\n");
1436 assert ((boost::dynamic_pointer_cast<AudioRegion> (r) && dynamic_cast<AudioTimeAxisView*> (v)) ||
1437 (boost::dynamic_pointer_cast<MidiRegion> (r) && dynamic_cast<MidiTimeAxisView*> (v)));
1439 _primary = v->view()->create_region_view (r, false, false);
1441 _primary->get_canvas_group()->show ();
1442 _primary->set_position (pos, 0);
1443 _views.push_back (DraggingView (_primary, this, v));
1445 _last_frame_position = pos;
1447 _item = _primary->get_canvas_group ();
1451 RegionInsertDrag::finished (GdkEvent *, bool)
1453 RouteTimeAxisView* dest_rtv = dynamic_cast<RouteTimeAxisView*> (_time_axis_views[_views.front().time_axis_view]);
1455 _primary->get_canvas_group()->reparent (dest_rtv->view()->canvas_item());
1456 _primary->get_canvas_group()->set_y_position (0);
1458 boost::shared_ptr<Playlist> playlist = dest_rtv->playlist();
1460 _editor->begin_reversible_command (Operations::insert_region);
1461 playlist->clear_changes ();
1462 playlist->add_region (_primary->region (), _last_frame_position);
1464 // Mixbus doesn't seem to ripple when inserting regions from the list: should we? yes, probably
1465 if (Config->get_edit_mode() == Ripple) {
1466 playlist->ripple (_last_frame_position, _primary->region()->length(), _primary->region());
1469 _editor->session()->add_command (new StatefulDiffCommand (playlist));
1470 _editor->commit_reversible_command ();
1478 RegionInsertDrag::aborted (bool)
1485 RegionSpliceDrag::RegionSpliceDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v)
1486 : RegionMoveDrag (e, i, p, v, false, false)
1488 DEBUG_TRACE (DEBUG::Drags, "New RegionSpliceDrag\n");
1491 struct RegionSelectionByPosition {
1492 bool operator() (RegionView*a, RegionView* b) {
1493 return a->region()->position () < b->region()->position();
1498 RegionSpliceDrag::motion (GdkEvent* event, bool)
1500 /* Which trackview is this ? */
1502 pair<TimeAxisView*, double> const tvp = _editor->trackview_by_y_position (current_pointer_y ());
1503 RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*> (tvp.first);
1505 /* The region motion is only processed if the pointer is over
1509 if (!tv || !tv->is_track()) {
1510 /* To make sure we hide the verbose canvas cursor when the mouse is
1511 not held over an audio track.
1513 _editor->verbose_cursor()->hide ();
1516 _editor->verbose_cursor()->show ();
1521 if ((_drags->current_pointer_x() - last_pointer_x()) > 0) {
1527 RegionSelection copy;
1528 _editor->selection->regions.by_position(copy);
1530 framepos_t const pf = adjusted_current_frame (event);
1532 for (RegionSelection::iterator i = copy.begin(); i != copy.end(); ++i) {
1534 RouteTimeAxisView* atv = dynamic_cast<RouteTimeAxisView*> (&(*i)->get_time_axis_view());
1540 boost::shared_ptr<Playlist> playlist;
1542 if ((playlist = atv->playlist()) == 0) {
1546 if (!playlist->region_is_shuffle_constrained ((*i)->region())) {
1551 if (pf < (*i)->region()->last_frame() + 1) {
1555 if (pf > (*i)->region()->first_frame()) {
1561 playlist->shuffle ((*i)->region(), dir);
1566 RegionSpliceDrag::finished (GdkEvent* event, bool movement_occurred)
1568 RegionMoveDrag::finished (event, movement_occurred);
1572 RegionSpliceDrag::aborted (bool)
1582 RegionRippleDrag::add_all_after_to_views(TimeAxisView *tav, framepos_t where, const RegionSelection &exclude, bool drag_in_progress)
1585 boost::shared_ptr<RegionList> rl = tav->playlist()->regions_with_start_within (Evoral::Range<framepos_t>(where, max_framepos));
1587 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*>(tav);
1588 RegionSelection to_ripple;
1589 for (RegionList::iterator i = rl->begin(); i != rl->end(); ++i) {
1590 if ((*i)->position() >= where) {
1591 to_ripple.push_back (rtv->view()->find_view(*i));
1595 for (RegionSelection::iterator i = to_ripple.begin(); i != to_ripple.end(); ++i) {
1596 if (!exclude.contains (*i)) {
1597 // the selection has already been added to _views
1599 if (drag_in_progress) {
1600 // do the same things that RegionMotionDrag::motion does when
1601 // first_move is true, for the region views that we're adding
1602 // to _views this time
1605 ArdourCanvas::Item* rvg = (*i)->get_canvas_group();
1606 Duple rv_canvas_offset = rvg->item_to_canvas (Duple (0,0));
1607 Duple dmg_canvas_offset = _editor->_drag_motion_group->canvas_origin ();
1608 rvg->reparent (_editor->_drag_motion_group);
1610 // we only need to move in the y direction
1611 Duple fudge = rv_canvas_offset - dmg_canvas_offset;
1616 _views.push_back (DraggingView (*i, this, tav));
1622 RegionRippleDrag::remove_unselected_from_views(framecnt_t amount, bool move_regions)
1625 for (std::list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ) {
1626 // we added all the regions after the selection
1628 std::list<DraggingView>::iterator to_erase = i++;
1629 if (!_editor->selection->regions.contains (to_erase->view)) {
1630 // restore the non-selected regions to their original playlist & positions,
1631 // and then ripple them back by the length of the regions that were dragged away
1632 // do the same things as RegionMotionDrag::aborted
1634 RegionView *rv = to_erase->view;
1635 TimeAxisView* tv = &(rv->get_time_axis_view ());
1636 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tv);
1639 // plonk them back onto their own track
1640 rv->get_canvas_group()->reparent(rtv->view()->canvas_item());
1641 rv->get_canvas_group()->set_y_position (0);
1645 // move the underlying region to match the view
1646 rv->region()->set_position (rv->region()->position() + amount);
1648 // restore the view to match the underlying region's original position
1649 rv->move(-amount, 0); // second parameter is y delta - seems 0 is OK
1652 rv->set_height (rtv->view()->child_height ());
1653 _views.erase (to_erase);
1659 RegionRippleDrag::y_movement_allowed (int delta_track, double delta_layer) const
1661 if (RegionMotionDrag::y_movement_allowed (delta_track, delta_layer)) {
1663 return allow_moves_across_tracks;
1671 RegionRippleDrag::RegionRippleDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v)
1672 : RegionMoveDrag (e, i, p, v, false, false)
1674 DEBUG_TRACE (DEBUG::Drags, "New RegionRippleDrag\n");
1675 // compute length of selection
1676 RegionSelection selected_regions = _editor->selection->regions;
1677 selection_length = selected_regions.end_frame() - selected_regions.start();
1679 // we'll only allow dragging to another track in ripple mode if all the regions
1680 // being dragged start off on the same track
1681 allow_moves_across_tracks = (selected_regions.playlists().size() == 1);
1684 exclude = new RegionList;
1685 for (RegionSelection::iterator i =selected_regions.begin(); i != selected_regions.end(); ++i) {
1686 exclude->push_back((*i)->region());
1689 // also add regions before start of selection to exclude, to be consistent with how Mixbus does ripple
1690 RegionSelection copy;
1691 selected_regions.by_position(copy); // get selected regions sorted by position into copy
1693 std::set<boost::shared_ptr<ARDOUR::Playlist> > playlists = copy.playlists();
1694 std::set<boost::shared_ptr<ARDOUR::Playlist> >::const_iterator pi;
1696 for (pi = playlists.begin(); pi != playlists.end(); ++pi) {
1697 // find ripple start point on each applicable playlist
1698 RegionView *first_selected_on_this_track = NULL;
1699 for (RegionSelection::iterator i = copy.begin(); i != copy.end(); ++i) {
1700 if ((*i)->region()->playlist() == (*pi)) {
1701 // region is on this playlist - it's the first, because they're sorted
1702 first_selected_on_this_track = *i;
1706 assert (first_selected_on_this_track); // we should always find the region in one of the playlists...
1707 add_all_after_to_views (
1708 &first_selected_on_this_track->get_time_axis_view(),
1709 first_selected_on_this_track->region()->position(),
1710 selected_regions, false);
1713 if (allow_moves_across_tracks) {
1714 orig_tav = &(*selected_regions.begin())->get_time_axis_view();
1722 RegionRippleDrag::motion (GdkEvent* event, bool first_move)
1724 /* Which trackview is this ? */
1726 pair<TimeAxisView*, double> const tvp = _editor->trackview_by_y_position (current_pointer_y ());
1727 RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*> (tvp.first);
1729 /* The region motion is only processed if the pointer is over
1733 if (!tv || !tv->is_track()) {
1734 /* To make sure we hide the verbose canvas cursor when the mouse is
1735 not held over an audiotrack.
1737 _editor->verbose_cursor()->hide ();
1741 framepos_t where = adjusted_current_frame (event);
1742 assert (where >= 0);
1744 double delta = compute_x_delta (event, &after);
1746 framecnt_t amount = _editor->pixel_to_sample (delta);
1748 if (allow_moves_across_tracks) {
1749 // all the originally selected regions were on the same track
1751 framecnt_t adjust = 0;
1752 if (prev_tav && tv != prev_tav) {
1753 // dragged onto a different track
1754 // remove the unselected regions from _views, restore them to their original positions
1755 // and add the regions after the drop point on the new playlist to _views instead.
1756 // undo the effect of rippling the previous playlist, and include the effect of removing
1757 // the dragged region(s) from this track
1759 remove_unselected_from_views (prev_amount, false);
1760 // ripple previous playlist according to the regions that have been removed onto the new playlist
1761 prev_tav->playlist()->ripple(prev_position, -selection_length, exclude);
1764 // move just the selected regions
1765 RegionMoveDrag::motion(event, first_move);
1767 // ensure that the ripple operation on the new playlist inserts selection_length time
1768 adjust = selection_length;
1769 // ripple the new current playlist
1770 tv->playlist()->ripple (where, amount+adjust, exclude);
1772 // add regions after point where drag entered this track to subsequent ripples
1773 add_all_after_to_views (tv, where, _editor->selection->regions, true);
1776 // motion on same track
1777 RegionMoveDrag::motion(event, first_move);
1781 // remember what we've done to this playlist so we can undo it if the selection is dragged to another track
1782 prev_position = where;
1784 // selection encompasses multiple tracks - just drag
1785 // cross-track drags are forbidden
1786 RegionMoveDrag::motion(event, first_move);
1789 if (!_x_constrained) {
1790 prev_amount += amount;
1793 _last_frame_position = after;
1797 RegionRippleDrag::finished (GdkEvent* event, bool movement_occurred)
1799 if (!movement_occurred) {
1803 if (was_double_click() && !_views.empty()) {
1804 DraggingView dv = _views.front();
1805 dv.view->show_region_editor ();
1812 _editor->begin_reversible_command(_("Ripple drag"));
1814 // remove the regions being rippled from the dragging view, updating them to
1815 // their new positions
1816 remove_unselected_from_views (prev_amount, true);
1818 if (allow_moves_across_tracks) {
1820 // if regions were dragged across tracks, we've rippled any later
1821 // regions on the track the regions were dragged off, so we need
1822 // to add the original track to the undo record
1823 orig_tav->playlist()->clear_changes();
1824 vector<Command*> cmds;
1825 orig_tav->playlist()->rdiff (cmds);
1826 _editor->session()->add_commands (cmds);
1828 if (prev_tav && prev_tav != orig_tav) {
1829 prev_tav->playlist()->clear_changes();
1830 vector<Command*> cmds;
1831 prev_tav->playlist()->rdiff (cmds);
1832 _editor->session()->add_commands (cmds);
1835 // selection spanned multiple tracks - all will need adding to undo record
1837 std::set<boost::shared_ptr<ARDOUR::Playlist> > playlists = _editor->selection->regions.playlists();
1838 std::set<boost::shared_ptr<ARDOUR::Playlist> >::const_iterator pi;
1840 for (pi = playlists.begin(); pi != playlists.end(); ++pi) {
1841 (*pi)->clear_changes();
1842 vector<Command*> cmds;
1843 (*pi)->rdiff (cmds);
1844 _editor->session()->add_commands (cmds);
1848 // other modified playlists are added to undo by RegionMoveDrag::finished()
1849 RegionMoveDrag::finished (event, movement_occurred);
1850 _editor->commit_reversible_command();
1854 RegionRippleDrag::aborted (bool movement_occurred)
1856 RegionMoveDrag::aborted (movement_occurred);
1861 RegionCreateDrag::RegionCreateDrag (Editor* e, ArdourCanvas::Item* i, TimeAxisView* v)
1863 _view (dynamic_cast<MidiTimeAxisView*> (v))
1865 DEBUG_TRACE (DEBUG::Drags, "New RegionCreateDrag\n");
1871 RegionCreateDrag::motion (GdkEvent* event, bool first_move)
1874 _region = add_midi_region (_view);
1875 _view->playlist()->freeze ();
1878 framepos_t const f = adjusted_current_frame (event);
1879 if (f < grab_frame()) {
1880 _region->set_position (f);
1883 /* Don't use a zero-length region, and subtract 1 frame from the snapped length
1884 so that if this region is duplicated, its duplicate starts on
1885 a snap point rather than 1 frame after a snap point. Otherwise things get
1886 a bit confusing as if a region starts 1 frame after a snap point, one cannot
1887 place snapped notes at the start of the region.
1890 framecnt_t const len = (framecnt_t) fabs ((double)(f - grab_frame () - 1));
1891 _region->set_length (len < 1 ? 1 : len);
1897 RegionCreateDrag::finished (GdkEvent*, bool movement_occurred)
1899 if (!movement_occurred) {
1900 add_midi_region (_view);
1902 _view->playlist()->thaw ();
1907 RegionCreateDrag::aborted (bool)
1910 _view->playlist()->thaw ();
1916 NoteResizeDrag::NoteResizeDrag (Editor* e, ArdourCanvas::Item* i)
1920 DEBUG_TRACE (DEBUG::Drags, "New NoteResizeDrag\n");
1924 NoteResizeDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*ignored*/)
1926 Gdk::Cursor* cursor;
1927 NoteBase* cnote = reinterpret_cast<NoteBase*> (_item->get_data ("notebase"));
1929 float x_fraction = cnote->mouse_x_fraction ();
1931 if (x_fraction > 0.0 && x_fraction < 0.25) {
1932 cursor = _editor->cursors()->left_side_trim;
1935 cursor = _editor->cursors()->right_side_trim;
1939 Drag::start_grab (event, cursor);
1941 region = &cnote->region_view();
1945 if (event->motion.state & Keyboard::PrimaryModifier) {
1951 MidiRegionSelection& ms (_editor->get_selection().midi_regions);
1953 if (ms.size() > 1) {
1954 /* has to be relative, may make no sense otherwise */
1958 /* select this note; if it is already selected, preserve the existing selection,
1959 otherwise make this note the only one selected.
1961 region->note_selected (cnote, cnote->selected ());
1963 for (MidiRegionSelection::iterator r = ms.begin(); r != ms.end(); ) {
1964 MidiRegionSelection::iterator next;
1967 MidiRegionView* mrv = dynamic_cast<MidiRegionView*>(*r);
1969 mrv->begin_resizing (at_front);
1976 NoteResizeDrag::motion (GdkEvent* /*event*/, bool /*first_move*/)
1978 MidiRegionSelection& ms (_editor->get_selection().midi_regions);
1979 for (MidiRegionSelection::iterator r = ms.begin(); r != ms.end(); ++r) {
1980 NoteBase* nb = reinterpret_cast<NoteBase*> (_item->get_data ("notebase"));
1982 MidiRegionView* mrv = dynamic_cast<MidiRegionView*>(*r);
1984 mrv->update_resizing (nb, at_front, _drags->current_pointer_x() - grab_x(), relative);
1990 NoteResizeDrag::finished (GdkEvent*, bool /*movement_occurred*/)
1992 MidiRegionSelection& ms (_editor->get_selection().midi_regions);
1993 for (MidiRegionSelection::iterator r = ms.begin(); r != ms.end(); ++r) {
1994 NoteBase* nb = reinterpret_cast<NoteBase*> (_item->get_data ("notebase"));
1996 MidiRegionView* mrv = dynamic_cast<MidiRegionView*>(*r);
1998 mrv->commit_resizing (nb, at_front, _drags->current_pointer_x() - grab_x(), relative);
2004 NoteResizeDrag::aborted (bool)
2006 MidiRegionSelection& ms (_editor->get_selection().midi_regions);
2007 for (MidiRegionSelection::iterator r = ms.begin(); r != ms.end(); ++r) {
2008 MidiRegionView* mrv = dynamic_cast<MidiRegionView*>(*r);
2010 mrv->abort_resizing ();
2015 AVDraggingView::AVDraggingView (RegionView* v)
2018 initial_position = v->region()->position ();
2021 VideoTimeLineDrag::VideoTimeLineDrag (Editor* e, ArdourCanvas::Item* i)
2024 DEBUG_TRACE (DEBUG::Drags, "New VideoTimeLineDrag\n");
2027 TrackViewList empty;
2029 _editor->get_regions_after(rs, (framepos_t) 0, empty);
2030 std::list<RegionView*> views = rs.by_layer();
2032 for (list<RegionView*>::iterator i = views.begin(); i != views.end(); ++i) {
2033 RegionView* rv = (*i);
2034 if (!rv->region()->video_locked()) {
2037 _views.push_back (AVDraggingView (rv));
2042 VideoTimeLineDrag::start_grab (GdkEvent* event, Gdk::Cursor*)
2044 Drag::start_grab (event);
2045 if (_editor->session() == 0) {
2049 _startdrag_video_offset=ARDOUR_UI::instance()->video_timeline->get_offset();
2050 _max_backwards_drag = (
2051 ARDOUR_UI::instance()->video_timeline->get_duration()
2052 + ARDOUR_UI::instance()->video_timeline->get_offset()
2053 - ceil(ARDOUR_UI::instance()->video_timeline->get_apv())
2056 for (list<AVDraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
2057 if (i->initial_position < _max_backwards_drag || _max_backwards_drag < 0) {
2058 _max_backwards_drag = ARDOUR_UI::instance()->video_timeline->quantify_frames_to_apv (i->initial_position);
2061 DEBUG_TRACE (DEBUG::Drags, string_compose("VideoTimeLineDrag: max backwards-drag: %1\n", _max_backwards_drag));
2064 Timecode::Time timecode;
2065 _editor->session()->sample_to_timecode(abs(_startdrag_video_offset), timecode, true /* use_offset */, false /* use_subframes */ );
2066 snprintf (buf, sizeof (buf), "Video Start:\n%c%02" PRId32 ":%02" PRId32 ":%02" PRId32 ":%02" PRId32, (_startdrag_video_offset<0?'-':' '), timecode.hours, timecode.minutes, timecode.seconds, timecode.frames);
2067 show_verbose_cursor_text (buf);
2071 VideoTimeLineDrag::motion (GdkEvent* event, bool first_move)
2073 if (_editor->session() == 0) {
2076 if (ARDOUR_UI::instance()->video_timeline->is_offset_locked()) {
2080 framecnt_t dt = adjusted_current_frame (event) - raw_grab_frame() + _pointer_frame_offset;
2081 dt = ARDOUR_UI::instance()->video_timeline->quantify_frames_to_apv(_startdrag_video_offset+dt) - _startdrag_video_offset;
2083 if (_max_backwards_drag >= 0 && dt <= - _max_backwards_drag) {
2084 dt = - _max_backwards_drag;
2087 ARDOUR_UI::instance()->video_timeline->set_offset(_startdrag_video_offset+dt);
2088 ARDOUR_UI::instance()->flush_videotimeline_cache(true);
2090 for (list<AVDraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
2091 RegionView* rv = i->view;
2092 DEBUG_TRACE (DEBUG::Drags, string_compose("SHIFT REGION at %1 by %2\n", i->initial_position, dt));
2095 rv->region()->clear_changes ();
2096 rv->region()->suspend_property_changes();
2098 rv->region()->set_position(i->initial_position + dt);
2099 rv->region_changed(ARDOUR::Properties::position);
2102 const framepos_t offset = ARDOUR_UI::instance()->video_timeline->get_offset();
2103 Timecode::Time timecode;
2104 Timecode::Time timediff;
2106 _editor->session()->sample_to_timecode(abs(offset), timecode, true /* use_offset */, false /* use_subframes */ );
2107 _editor->session()->sample_to_timecode(abs(dt), timediff, false /* use_offset */, false /* use_subframes */ );
2108 snprintf (buf, sizeof (buf),
2109 "%s\n%c%02" PRId32 ":%02" PRId32 ":%02" PRId32 ":%02" PRId32
2110 "\n%s\n%c%02" PRId32 ":%02" PRId32 ":%02" PRId32 ":%02" PRId32
2111 , _("Video Start:"),
2112 (offset<0?'-':' '), timecode.hours, timecode.minutes, timecode.seconds, timecode.frames
2114 (dt<0?'-':' '), timediff.hours, timediff.minutes, timediff.seconds, timediff.frames
2116 show_verbose_cursor_text (buf);
2120 VideoTimeLineDrag::finished (GdkEvent * /*event*/, bool movement_occurred)
2122 if (ARDOUR_UI::instance()->video_timeline->is_offset_locked()) {
2126 if (!movement_occurred || ! _editor->session()) {
2130 ARDOUR_UI::instance()->flush_videotimeline_cache(true);
2132 _editor->begin_reversible_command (_("Move Video"));
2134 XMLNode &before = ARDOUR_UI::instance()->video_timeline->get_state();
2135 ARDOUR_UI::instance()->video_timeline->save_undo();
2136 XMLNode &after = ARDOUR_UI::instance()->video_timeline->get_state();
2137 _editor->session()->add_command(new MementoCommand<VideoTimeLine>(*(ARDOUR_UI::instance()->video_timeline), &before, &after));
2139 for (list<AVDraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
2140 i->view->drag_end();
2141 i->view->region()->resume_property_changes ();
2143 _editor->session()->add_command (new StatefulDiffCommand (i->view->region()));
2146 _editor->session()->maybe_update_session_range(
2147 std::max(ARDOUR_UI::instance()->video_timeline->get_offset(), (ARDOUR::frameoffset_t) 0),
2148 std::max(ARDOUR_UI::instance()->video_timeline->get_offset() + ARDOUR_UI::instance()->video_timeline->get_duration(), (ARDOUR::frameoffset_t) 0)
2152 _editor->commit_reversible_command ();
2156 VideoTimeLineDrag::aborted (bool)
2158 if (ARDOUR_UI::instance()->video_timeline->is_offset_locked()) {
2161 ARDOUR_UI::instance()->video_timeline->set_offset(_startdrag_video_offset);
2162 ARDOUR_UI::instance()->flush_videotimeline_cache(true);
2164 for (list<AVDraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
2165 i->view->region()->resume_property_changes ();
2166 i->view->region()->set_position(i->initial_position);
2170 TrimDrag::TrimDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v, bool preserve_fade_anchor)
2171 : RegionDrag (e, i, p, v)
2172 , _preserve_fade_anchor (preserve_fade_anchor)
2173 , _jump_position_when_done (false)
2175 DEBUG_TRACE (DEBUG::Drags, "New TrimDrag\n");
2179 TrimDrag::start_grab (GdkEvent* event, Gdk::Cursor*)
2182 TimeAxisView* tvp = &_primary->get_time_axis_view ();
2183 RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*>(tvp);
2185 if (tv && tv->is_track()) {
2186 speed = tv->track()->speed();
2189 framepos_t const region_start = (framepos_t) (_primary->region()->position() / speed);
2190 framepos_t const region_end = (framepos_t) (_primary->region()->last_frame() / speed);
2191 framecnt_t const region_length = (framecnt_t) (_primary->region()->length() / speed);
2193 framepos_t const pf = adjusted_current_frame (event);
2195 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
2196 /* Move the contents of the region around without changing the region bounds */
2197 _operation = ContentsTrim;
2198 Drag::start_grab (event, _editor->cursors()->trimmer);
2200 /* These will get overridden for a point trim.*/
2201 if (pf < (region_start + region_length/2)) {
2202 /* closer to front */
2203 _operation = StartTrim;
2205 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
2206 Drag::start_grab (event, _editor->cursors()->anchored_left_side_trim);
2208 Drag::start_grab (event, _editor->cursors()->left_side_trim);
2212 _operation = EndTrim;
2213 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
2214 Drag::start_grab (event, _editor->cursors()->anchored_right_side_trim);
2216 Drag::start_grab (event, _editor->cursors()->right_side_trim);
2221 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
2222 _jump_position_when_done = true;
2225 switch (_operation) {
2227 show_verbose_cursor_time (region_start);
2228 for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
2229 i->view->trim_front_starting ();
2233 show_verbose_cursor_time (region_end);
2236 show_verbose_cursor_time (pf);
2240 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
2241 i->view->region()->suspend_property_changes ();
2246 TrimDrag::motion (GdkEvent* event, bool first_move)
2248 RegionView* rv = _primary;
2251 TimeAxisView* tvp = &_primary->get_time_axis_view ();
2252 RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*>(tvp);
2253 pair<set<boost::shared_ptr<Playlist> >::iterator,bool> insert_result;
2254 frameoffset_t frame_delta = 0;
2256 if (tv && tv->is_track()) {
2257 speed = tv->track()->speed();
2260 framecnt_t dt = adjusted_current_frame (event) - raw_grab_frame () + _pointer_frame_offset;
2266 switch (_operation) {
2268 trim_type = "Region start trim";
2271 trim_type = "Region end trim";
2274 trim_type = "Region content trim";
2281 _editor->begin_reversible_command (trim_type);
2283 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
2284 RegionView* rv = i->view;
2285 rv->enable_display (false);
2286 rv->region()->playlist()->clear_owned_changes ();
2288 AudioRegionView* const arv = dynamic_cast<AudioRegionView*> (rv);
2291 arv->temporarily_hide_envelope ();
2295 boost::shared_ptr<Playlist> pl = rv->region()->playlist();
2296 insert_result = _editor->motion_frozen_playlists.insert (pl);
2298 if (insert_result.second) {
2304 bool non_overlap_trim = false;
2306 if (event && Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
2307 non_overlap_trim = true;
2310 /* contstrain trim to fade length */
2311 if (_preserve_fade_anchor) {
2312 switch (_operation) {
2314 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
2315 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (i->view);
2317 boost::shared_ptr<AudioRegion> ar (arv->audio_region());
2318 if (ar->locked()) continue;
2319 framecnt_t len = ar->fade_in()->back()->when;
2320 if (len < dt) dt = min(dt, len);
2324 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
2325 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (i->view);
2327 boost::shared_ptr<AudioRegion> ar (arv->audio_region());
2328 if (ar->locked()) continue;
2329 framecnt_t len = ar->fade_out()->back()->when;
2330 if (len < -dt) dt = max(dt, -len);
2339 switch (_operation) {
2341 for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
2342 bool changed = i->view->trim_front (i->initial_position + dt, non_overlap_trim);
2343 if (changed && _preserve_fade_anchor) {
2344 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (i->view);
2346 boost::shared_ptr<AudioRegion> ar (arv->audio_region());
2347 framecnt_t len = ar->fade_in()->back()->when;
2348 framecnt_t diff = ar->first_frame() - i->initial_position;
2349 framepos_t new_length = len - diff;
2350 i->anchored_fade_length = min (ar->length(), new_length);
2351 //i->anchored_fade_length = ar->verify_xfade_bounds (new_length, true /*START*/ );
2352 arv->reset_fade_in_shape_width (ar, i->anchored_fade_length, true);
2359 for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
2360 bool changed = i->view->trim_end (i->initial_end + dt, non_overlap_trim);
2361 if (changed && _preserve_fade_anchor) {
2362 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (i->view);
2364 boost::shared_ptr<AudioRegion> ar (arv->audio_region());
2365 framecnt_t len = ar->fade_out()->back()->when;
2366 framecnt_t diff = 1 + ar->last_frame() - i->initial_end;
2367 framepos_t new_length = len + diff;
2368 i->anchored_fade_length = min (ar->length(), new_length);
2369 //i->anchored_fade_length = ar->verify_xfade_bounds (new_length, false /*END*/ );
2370 arv->reset_fade_out_shape_width (ar, i->anchored_fade_length, true);
2378 frame_delta = (last_pointer_frame() - adjusted_current_frame(event));
2380 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
2381 i->view->move_contents (frame_delta);
2387 switch (_operation) {
2389 show_verbose_cursor_time ((framepos_t) (rv->region()->position() / speed));
2392 show_verbose_cursor_time ((framepos_t) (rv->region()->last_frame() / speed));
2395 // show_verbose_cursor_time (frame_delta);
2402 TrimDrag::finished (GdkEvent* event, bool movement_occurred)
2404 if (movement_occurred) {
2405 motion (event, false);
2407 if (_operation == StartTrim) {
2408 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
2410 /* This must happen before the region's StatefulDiffCommand is created, as it may
2411 `correct' (ahem) the region's _start from being negative to being zero. It
2412 needs to be zero in the undo record.
2414 i->view->trim_front_ending ();
2416 if (_preserve_fade_anchor) {
2417 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (i->view);
2419 boost::shared_ptr<AudioRegion> ar (arv->audio_region());
2420 arv->reset_fade_in_shape_width (ar, i->anchored_fade_length);
2421 ar->set_fade_in_length(i->anchored_fade_length);
2422 ar->set_fade_in_active(true);
2425 if (_jump_position_when_done) {
2426 i->view->region()->set_position (i->initial_position);
2429 } else if (_operation == EndTrim) {
2430 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
2431 if (_preserve_fade_anchor) {
2432 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (i->view);
2434 boost::shared_ptr<AudioRegion> ar (arv->audio_region());
2435 arv->reset_fade_out_shape_width (ar, i->anchored_fade_length);
2436 ar->set_fade_out_length(i->anchored_fade_length);
2437 ar->set_fade_out_active(true);
2440 if (_jump_position_when_done) {
2441 i->view->region()->set_position (i->initial_end - i->view->region()->length());
2446 if (!_views.empty()) {
2447 if (_operation == StartTrim) {
2448 _editor->maybe_locate_with_edit_preroll(
2449 _views.begin()->view->region()->position());
2451 if (_operation == EndTrim) {
2452 _editor->maybe_locate_with_edit_preroll(
2453 _views.begin()->view->region()->position() +
2454 _views.begin()->view->region()->length());
2458 if (!_editor->selection->selected (_primary)) {
2459 _primary->thaw_after_trim ();
2462 set<boost::shared_ptr<Playlist> > diffed_playlists;
2464 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
2465 i->view->thaw_after_trim ();
2466 i->view->enable_display (true);
2468 /* Trimming one region may affect others on the playlist, so we need
2469 to get undo Commands from the whole playlist rather than just the
2470 region. Use diffed_playlists to make sure we don't diff a given
2471 playlist more than once.
2473 boost::shared_ptr<Playlist> p = i->view->region()->playlist ();
2474 if (diffed_playlists.find (p) == diffed_playlists.end()) {
2475 vector<Command*> cmds;
2477 _editor->session()->add_commands (cmds);
2478 diffed_playlists.insert (p);
2483 for (set<boost::shared_ptr<Playlist> >::iterator p = _editor->motion_frozen_playlists.begin(); p != _editor->motion_frozen_playlists.end(); ++p) {
2487 _editor->motion_frozen_playlists.clear ();
2488 _editor->commit_reversible_command();
2491 /* no mouse movement */
2492 _editor->point_trim (event, adjusted_current_frame (event));
2495 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
2496 if (_operation == StartTrim) {
2497 i->view->trim_front_ending ();
2500 i->view->region()->resume_property_changes ();
2505 TrimDrag::aborted (bool movement_occurred)
2507 /* Our motion method is changing model state, so use the Undo system
2508 to cancel. Perhaps not ideal, as this will leave an Undo point
2509 behind which may be slightly odd from the user's point of view.
2514 if (movement_occurred) {
2518 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
2519 i->view->region()->resume_property_changes ();
2524 TrimDrag::setup_pointer_frame_offset ()
2526 list<DraggingView>::iterator i = _views.begin ();
2527 while (i != _views.end() && i->view != _primary) {
2531 if (i == _views.end()) {
2535 switch (_operation) {
2537 _pointer_frame_offset = raw_grab_frame() - i->initial_position;
2540 _pointer_frame_offset = raw_grab_frame() - i->initial_end;
2547 MeterMarkerDrag::MeterMarkerDrag (Editor* e, ArdourCanvas::Item* i, bool c)
2551 DEBUG_TRACE (DEBUG::Drags, "New MeterMarkerDrag\n");
2552 _marker = reinterpret_cast<MeterMarker*> (_item->get_data ("marker"));
2557 MeterMarkerDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
2559 Drag::start_grab (event, cursor);
2560 show_verbose_cursor_time (adjusted_current_frame(event));
2564 MeterMarkerDrag::setup_pointer_frame_offset ()
2566 _pointer_frame_offset = raw_grab_frame() - _marker->meter().frame();
2570 MeterMarkerDrag::motion (GdkEvent* event, bool first_move)
2572 if (!_marker->meter().movable()) {
2578 // create a dummy marker for visual representation of moving the
2579 // section, because whether its a copy or not, we're going to
2580 // leave or lose the original marker (leave if its a copy; lose if its
2581 // not, because we'll remove it from the map).
2583 MeterSection section (_marker->meter());
2585 if (!section.movable()) {
2590 snprintf (name, sizeof(name), "%g/%g", _marker->meter().divisions_per_bar(), _marker->meter().note_divisor ());
2592 _marker = new MeterMarker (
2594 *_editor->meter_group,
2595 ARDOUR_UI::config()->get_MeterMarker(),
2597 *new MeterSection (_marker->meter())
2600 /* use the new marker for the grab */
2601 swap_grab (&_marker->the_item(), 0, GDK_CURRENT_TIME);
2604 TempoMap& map (_editor->session()->tempo_map());
2605 /* get current state */
2606 before_state = &map.get_state();
2607 /* remove the section while we drag it */
2608 map.remove_meter (section, true);
2612 framepos_t const pf = adjusted_current_frame (event);
2614 _marker->set_position (pf);
2615 show_verbose_cursor_time (pf);
2619 MeterMarkerDrag::finished (GdkEvent* event, bool movement_occurred)
2621 if (!movement_occurred) {
2622 if (was_double_click()) {
2623 _editor->edit_meter_marker (*_marker);
2628 if (!_marker->meter().movable()) {
2632 motion (event, false);
2634 Timecode::BBT_Time when;
2636 TempoMap& map (_editor->session()->tempo_map());
2637 map.bbt_time (last_pointer_frame(), when);
2639 if (_copy == true) {
2640 _editor->begin_reversible_command (_("copy meter mark"));
2641 XMLNode &before = map.get_state();
2642 map.add_meter (_marker->meter(), when);
2643 XMLNode &after = map.get_state();
2644 _editor->session()->add_command(new MementoCommand<TempoMap>(map, &before, &after));
2645 _editor->commit_reversible_command ();
2648 _editor->begin_reversible_command (_("move meter mark"));
2650 /* we removed it before, so add it back now */
2652 map.add_meter (_marker->meter(), when);
2653 XMLNode &after = map.get_state();
2654 _editor->session()->add_command(new MementoCommand<TempoMap>(map, before_state, &after));
2655 _editor->commit_reversible_command ();
2658 // delete the dummy marker we used for visual representation while moving.
2659 // a new visual marker will show up automatically.
2664 MeterMarkerDrag::aborted (bool moved)
2666 _marker->set_position (_marker->meter().frame ());
2669 TempoMap& map (_editor->session()->tempo_map());
2670 /* we removed it before, so add it back now */
2671 map.add_meter (_marker->meter(), _marker->meter().frame());
2672 // delete the dummy marker we used for visual representation while moving.
2673 // a new visual marker will show up automatically.
2678 TempoMarkerDrag::TempoMarkerDrag (Editor* e, ArdourCanvas::Item* i, bool c)
2682 DEBUG_TRACE (DEBUG::Drags, "New TempoMarkerDrag\n");
2684 _marker = reinterpret_cast<TempoMarker*> (_item->get_data ("marker"));
2689 TempoMarkerDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
2691 Drag::start_grab (event, cursor);
2692 show_verbose_cursor_time (adjusted_current_frame (event));
2696 TempoMarkerDrag::setup_pointer_frame_offset ()
2698 _pointer_frame_offset = raw_grab_frame() - _marker->tempo().frame();
2702 TempoMarkerDrag::motion (GdkEvent* event, bool first_move)
2704 if (!_marker->tempo().movable()) {
2710 // create a dummy marker for visual representation of moving the
2711 // section, because whether its a copy or not, we're going to
2712 // leave or lose the original marker (leave if its a copy; lose if its
2713 // not, because we'll remove it from the map).
2715 // create a dummy marker for visual representation of moving the copy.
2716 // The actual copying is not done before we reach the finish callback.
2719 snprintf (name, sizeof (name), "%.2f", _marker->tempo().beats_per_minute());
2721 TempoSection section (_marker->tempo());
2723 _marker = new TempoMarker (
2725 *_editor->tempo_group,
2726 ARDOUR_UI::config()->get_TempoMarker(),
2728 *new TempoSection (_marker->tempo())
2731 /* use the new marker for the grab */
2732 swap_grab (&_marker->the_item(), 0, GDK_CURRENT_TIME);
2735 TempoMap& map (_editor->session()->tempo_map());
2736 /* get current state */
2737 before_state = &map.get_state();
2738 /* remove the section while we drag it */
2739 map.remove_tempo (section, true);
2743 framepos_t const pf = adjusted_current_frame (event);
2744 _marker->set_position (pf);
2745 show_verbose_cursor_time (pf);
2749 TempoMarkerDrag::finished (GdkEvent* event, bool movement_occurred)
2751 if (!movement_occurred) {
2752 if (was_double_click()) {
2753 _editor->edit_tempo_marker (*_marker);
2758 if (!_marker->tempo().movable()) {
2762 motion (event, false);
2764 TempoMap& map (_editor->session()->tempo_map());
2765 framepos_t beat_time = map.round_to_beat (last_pointer_frame(), RoundNearest);
2766 Timecode::BBT_Time when;
2768 map.bbt_time (beat_time, when);
2770 if (_copy == true) {
2771 _editor->begin_reversible_command (_("copy tempo mark"));
2772 XMLNode &before = map.get_state();
2773 map.add_tempo (_marker->tempo(), when);
2774 XMLNode &after = map.get_state();
2775 _editor->session()->add_command (new MementoCommand<TempoMap>(map, &before, &after));
2776 _editor->commit_reversible_command ();
2779 _editor->begin_reversible_command (_("move tempo mark"));
2780 /* we removed it before, so add it back now */
2781 map.add_tempo (_marker->tempo(), when);
2782 XMLNode &after = map.get_state();
2783 _editor->session()->add_command (new MementoCommand<TempoMap>(map, before_state, &after));
2784 _editor->commit_reversible_command ();
2787 // delete the dummy marker we used for visual representation while moving.
2788 // a new visual marker will show up automatically.
2793 TempoMarkerDrag::aborted (bool moved)
2795 _marker->set_position (_marker->tempo().frame());
2797 TempoMap& map (_editor->session()->tempo_map());
2798 /* we removed it before, so add it back now */
2799 map.add_tempo (_marker->tempo(), _marker->tempo().start());
2800 // delete the dummy marker we used for visual representation while moving.
2801 // a new visual marker will show up automatically.
2806 CursorDrag::CursorDrag (Editor* e, EditorCursor& c, bool s)
2807 : Drag (e, &c.track_canvas_item(), false)
2811 DEBUG_TRACE (DEBUG::Drags, "New CursorDrag\n");
2814 /** Do all the things we do when dragging the playhead to make it look as though
2815 * we have located, without actually doing the locate (because that would cause
2816 * the diskstream buffers to be refilled, which is too slow).
2819 CursorDrag::fake_locate (framepos_t t)
2821 _editor->playhead_cursor->set_position (t);
2823 Session* s = _editor->session ();
2824 if (s->timecode_transmission_suspended ()) {
2825 framepos_t const f = _editor->playhead_cursor->current_frame ();
2826 /* This is asynchronous so it will be sent "now"
2828 s->send_mmc_locate (f);
2829 /* These are synchronous and will be sent during the next
2832 s->queue_full_time_code ();
2833 s->queue_song_position_pointer ();
2836 show_verbose_cursor_time (t);
2837 _editor->UpdateAllTransportClocks (t);
2841 CursorDrag::start_grab (GdkEvent* event, Gdk::Cursor* c)
2843 Drag::start_grab (event, c);
2845 _grab_zoom = _editor->samples_per_pixel;
2847 framepos_t where = _editor->canvas_event_sample (event);
2849 _editor->snap_to_with_modifier (where, event);
2851 _editor->_dragging_playhead = true;
2853 Session* s = _editor->session ();
2855 /* grab the track canvas item as well */
2857 _cursor.track_canvas_item().grab();
2860 if (_was_rolling && _stop) {
2864 if (s->is_auditioning()) {
2865 s->cancel_audition ();
2869 if (AudioEngine::instance()->connected()) {
2871 /* do this only if we're the engine is connected
2872 * because otherwise this request will never be
2873 * serviced and we'll busy wait forever. likewise,
2874 * notice if we are disconnected while waiting for the
2875 * request to be serviced.
2878 s->request_suspend_timecode_transmission ();
2879 while (AudioEngine::instance()->connected() && !s->timecode_transmission_suspended ()) {
2880 /* twiddle our thumbs */
2885 fake_locate (where);
2889 CursorDrag::motion (GdkEvent* event, bool)
2891 framepos_t const adjusted_frame = adjusted_current_frame (event);
2892 if (adjusted_frame != last_pointer_frame()) {
2893 fake_locate (adjusted_frame);
2898 CursorDrag::finished (GdkEvent* event, bool movement_occurred)
2900 _editor->_dragging_playhead = false;
2902 _cursor.track_canvas_item().ungrab();
2904 if (!movement_occurred && _stop) {
2908 motion (event, false);
2910 Session* s = _editor->session ();
2912 s->request_locate (_editor->playhead_cursor->current_frame (), _was_rolling);
2913 _editor->_pending_locate_request = true;
2914 s->request_resume_timecode_transmission ();
2919 CursorDrag::aborted (bool)
2921 _cursor.track_canvas_item().ungrab();
2923 if (_editor->_dragging_playhead) {
2924 _editor->session()->request_resume_timecode_transmission ();
2925 _editor->_dragging_playhead = false;
2928 _editor->playhead_cursor->set_position (adjusted_frame (grab_frame (), 0, false));
2931 FadeInDrag::FadeInDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v)
2932 : RegionDrag (e, i, p, v)
2934 DEBUG_TRACE (DEBUG::Drags, "New FadeInDrag\n");
2938 FadeInDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
2940 Drag::start_grab (event, cursor);
2942 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (_primary);
2943 boost::shared_ptr<AudioRegion> const r = arv->audio_region ();
2945 show_verbose_cursor_duration (r->position(), r->position() + r->fade_in()->back()->when, 32);
2949 FadeInDrag::setup_pointer_frame_offset ()
2951 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (_primary);
2952 boost::shared_ptr<AudioRegion> const r = arv->audio_region ();
2953 _pointer_frame_offset = raw_grab_frame() - ((framecnt_t) r->fade_in()->back()->when + r->position());
2957 FadeInDrag::motion (GdkEvent* event, bool)
2959 framecnt_t fade_length;
2961 framepos_t const pos = adjusted_current_frame (event);
2963 boost::shared_ptr<Region> region = _primary->region ();
2965 if (pos < (region->position() + 64)) {
2966 fade_length = 64; // this should be a minimum defined somewhere
2967 } else if (pos > region->last_frame()) {
2968 fade_length = region->length();
2970 fade_length = pos - region->position();
2973 for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
2975 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (i->view);
2981 tmp->reset_fade_in_shape_width (tmp->audio_region(), fade_length);
2984 show_verbose_cursor_duration (region->position(), region->position() + fade_length, 32);
2988 FadeInDrag::finished (GdkEvent* event, bool movement_occurred)
2990 if (!movement_occurred) {
2994 framecnt_t fade_length;
2996 framepos_t const pos = adjusted_current_frame (event);
2998 boost::shared_ptr<Region> region = _primary->region ();
3000 if (pos < (region->position() + 64)) {
3001 fade_length = 64; // this should be a minimum defined somewhere
3002 } else if (pos > region->last_frame()) {
3003 fade_length = region->length();
3005 fade_length = pos - region->position();
3008 _editor->begin_reversible_command (_("change fade in length"));
3010 for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
3012 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (i->view);
3018 boost::shared_ptr<AutomationList> alist = tmp->audio_region()->fade_in();
3019 XMLNode &before = alist->get_state();
3021 tmp->audio_region()->set_fade_in_length (fade_length);
3022 tmp->audio_region()->set_fade_in_active (true);
3024 XMLNode &after = alist->get_state();
3025 _editor->session()->add_command(new MementoCommand<AutomationList>(*alist.get(), &before, &after));
3028 _editor->commit_reversible_command ();
3032 FadeInDrag::aborted (bool)
3034 for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
3035 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (i->view);
3041 tmp->reset_fade_in_shape_width (tmp->audio_region(), tmp->audio_region()->fade_in()->back()->when);
3045 FadeOutDrag::FadeOutDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v)
3046 : RegionDrag (e, i, p, v)
3048 DEBUG_TRACE (DEBUG::Drags, "New FadeOutDrag\n");
3052 FadeOutDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
3054 Drag::start_grab (event, cursor);
3056 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (_primary);
3057 boost::shared_ptr<AudioRegion> r = arv->audio_region ();
3059 show_verbose_cursor_duration (r->last_frame() - r->fade_out()->back()->when, r->last_frame());
3063 FadeOutDrag::setup_pointer_frame_offset ()
3065 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (_primary);
3066 boost::shared_ptr<AudioRegion> r = arv->audio_region ();
3067 _pointer_frame_offset = raw_grab_frame() - (r->length() - (framecnt_t) r->fade_out()->back()->when + r->position());
3071 FadeOutDrag::motion (GdkEvent* event, bool)
3073 framecnt_t fade_length;
3075 framepos_t const pos = adjusted_current_frame (event);
3077 boost::shared_ptr<Region> region = _primary->region ();
3079 if (pos > (region->last_frame() - 64)) {
3080 fade_length = 64; // this should really be a minimum fade defined somewhere
3082 else if (pos < region->position()) {
3083 fade_length = region->length();
3086 fade_length = region->last_frame() - pos;
3089 for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
3091 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (i->view);
3097 tmp->reset_fade_out_shape_width (tmp->audio_region(), fade_length);
3100 show_verbose_cursor_duration (region->last_frame() - fade_length, region->last_frame());
3104 FadeOutDrag::finished (GdkEvent* event, bool movement_occurred)
3106 if (!movement_occurred) {
3110 framecnt_t fade_length;
3112 framepos_t const pos = adjusted_current_frame (event);
3114 boost::shared_ptr<Region> region = _primary->region ();
3116 if (pos > (region->last_frame() - 64)) {
3117 fade_length = 64; // this should really be a minimum fade defined somewhere
3119 else if (pos < region->position()) {
3120 fade_length = region->length();
3123 fade_length = region->last_frame() - pos;
3126 _editor->begin_reversible_command (_("change fade out length"));
3128 for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
3130 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (i->view);
3136 boost::shared_ptr<AutomationList> alist = tmp->audio_region()->fade_out();
3137 XMLNode &before = alist->get_state();
3139 tmp->audio_region()->set_fade_out_length (fade_length);
3140 tmp->audio_region()->set_fade_out_active (true);
3142 XMLNode &after = alist->get_state();
3143 _editor->session()->add_command(new MementoCommand<AutomationList>(*alist.get(), &before, &after));
3146 _editor->commit_reversible_command ();
3150 FadeOutDrag::aborted (bool)
3152 for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
3153 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (i->view);
3159 tmp->reset_fade_out_shape_width (tmp->audio_region(), tmp->audio_region()->fade_out()->back()->when);
3163 MarkerDrag::MarkerDrag (Editor* e, ArdourCanvas::Item* i)
3166 DEBUG_TRACE (DEBUG::Drags, "New MarkerDrag\n");
3168 _marker = reinterpret_cast<Marker*> (_item->get_data ("marker"));
3171 _points.push_back (ArdourCanvas::Duple (0, 0));
3172 _points.push_back (ArdourCanvas::Duple (0, physical_screen_height (_editor->get_window())));
3175 MarkerDrag::~MarkerDrag ()
3177 for (CopiedLocationInfo::iterator i = _copied_locations.begin(); i != _copied_locations.end(); ++i) {
3182 MarkerDrag::CopiedLocationMarkerInfo::CopiedLocationMarkerInfo (Location* l, Marker* m)
3184 location = new Location (*l);
3185 markers.push_back (m);
3190 MarkerDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
3192 Drag::start_grab (event, cursor);
3196 Location *location = _editor->find_location_from_marker (_marker, is_start);
3197 _editor->_dragging_edit_point = true;
3199 update_item (location);
3201 // _drag_line->show();
3202 // _line->raise_to_top();
3205 show_verbose_cursor_time (location->start());
3207 show_verbose_cursor_time (location->end());
3210 Selection::Operation op = ArdourKeyboard::selection_type (event->button.state);
3213 case Selection::Toggle:
3214 /* we toggle on the button release */
3216 case Selection::Set:
3217 if (!_editor->selection->selected (_marker)) {
3218 _editor->selection->set (_marker);
3221 case Selection::Extend:
3223 Locations::LocationList ll;
3224 list<Marker*> to_add;
3226 _editor->selection->markers.range (s, e);
3227 s = min (_marker->position(), s);
3228 e = max (_marker->position(), e);
3231 if (e < max_framepos) {
3234 _editor->session()->locations()->find_all_between (s, e, ll, Location::Flags (0));
3235 for (Locations::LocationList::iterator i = ll.begin(); i != ll.end(); ++i) {
3236 Editor::LocationMarkers* lm = _editor->find_location_markers (*i);
3239 to_add.push_back (lm->start);
3242 to_add.push_back (lm->end);
3246 if (!to_add.empty()) {
3247 _editor->selection->add (to_add);
3251 case Selection::Add:
3252 _editor->selection->add (_marker);
3256 /* Set up copies for us to manipulate during the drag
3259 for (MarkerSelection::iterator i = _editor->selection->markers.begin(); i != _editor->selection->markers.end(); ++i) {
3261 Location* l = _editor->find_location_from_marker (*i, is_start);
3268 _copied_locations.push_back (CopiedLocationMarkerInfo (l, *i));
3270 /* range: check that the other end of the range isn't
3273 CopiedLocationInfo::iterator x;
3274 for (x = _copied_locations.begin(); x != _copied_locations.end(); ++x) {
3275 if (*(*x).location == *l) {
3279 if (x == _copied_locations.end()) {
3280 _copied_locations.push_back (CopiedLocationMarkerInfo (l, *i));
3282 (*x).markers.push_back (*i);
3283 (*x).move_both = true;
3291 MarkerDrag::setup_pointer_frame_offset ()
3294 Location *location = _editor->find_location_from_marker (_marker, is_start);
3295 _pointer_frame_offset = raw_grab_frame() - (is_start ? location->start() : location->end());
3299 MarkerDrag::motion (GdkEvent* event, bool)
3301 framecnt_t f_delta = 0;
3303 bool move_both = false;
3304 Location *real_location;
3305 Location *copy_location = 0;
3307 framepos_t const newframe = adjusted_current_frame (event);
3308 framepos_t next = newframe;
3310 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
3314 CopiedLocationInfo::iterator x;
3316 /* find the marker we're dragging, and compute the delta */
3318 for (x = _copied_locations.begin(); x != _copied_locations.end(); ++x) {
3320 copy_location = (*x).location;
3322 if (find (x->markers.begin(), x->markers.end(), _marker) != x->markers.end()) {
3324 /* this marker is represented by this
3325 * CopiedLocationMarkerInfo
3328 if ((real_location = _editor->find_location_from_marker (_marker, is_start)) == 0) {
3333 if (real_location->is_mark()) {
3334 f_delta = newframe - copy_location->start();
3338 switch (_marker->type()) {
3339 case Marker::SessionStart:
3340 case Marker::RangeStart:
3341 case Marker::LoopStart:
3342 case Marker::PunchIn:
3343 f_delta = newframe - copy_location->start();
3346 case Marker::SessionEnd:
3347 case Marker::RangeEnd:
3348 case Marker::LoopEnd:
3349 case Marker::PunchOut:
3350 f_delta = newframe - copy_location->end();
3353 /* what kind of marker is this ? */
3362 if (x == _copied_locations.end()) {
3363 /* hmm, impossible - we didn't find the dragged marker */
3367 /* now move them all */
3369 for (x = _copied_locations.begin(); x != _copied_locations.end(); ++x) {
3371 copy_location = x->location;
3373 /* call this to find out if its the start or end */
3375 if ((real_location = _editor->find_location_from_marker (x->markers.front(), is_start)) == 0) {
3379 if (real_location->locked()) {
3383 if (copy_location->is_mark()) {
3387 copy_location->set_start (copy_location->start() + f_delta);
3391 framepos_t new_start = copy_location->start() + f_delta;
3392 framepos_t new_end = copy_location->end() + f_delta;
3394 if (is_start) { // start-of-range marker
3396 if (move_both || (*x).move_both) {
3397 copy_location->set_start (new_start);
3398 copy_location->set_end (new_end);
3399 } else if (new_start < copy_location->end()) {
3400 copy_location->set_start (new_start);
3401 } else if (newframe > 0) {
3402 _editor->snap_to (next, RoundUpAlways, true);
3403 copy_location->set_end (next);
3404 copy_location->set_start (newframe);
3407 } else { // end marker
3409 if (move_both || (*x).move_both) {
3410 copy_location->set_end (new_end);
3411 copy_location->set_start (new_start);
3412 } else if (new_end > copy_location->start()) {
3413 copy_location->set_end (new_end);
3414 } else if (newframe > 0) {
3415 _editor->snap_to (next, RoundDownAlways, true);
3416 copy_location->set_start (next);
3417 copy_location->set_end (newframe);
3422 update_item (copy_location);
3424 /* now lookup the actual GUI items used to display this
3425 * location and move them to wherever the copy of the location
3426 * is now. This means that the logic in ARDOUR::Location is
3427 * still enforced, even though we are not (yet) modifying
3428 * the real Location itself.
3431 Editor::LocationMarkers* lm = _editor->find_location_markers (real_location);
3434 lm->set_position (copy_location->start(), copy_location->end());
3439 assert (!_copied_locations.empty());
3441 show_verbose_cursor_time (newframe);
3445 MarkerDrag::finished (GdkEvent* event, bool movement_occurred)
3447 if (!movement_occurred) {
3449 if (was_double_click()) {
3450 _editor->rename_marker (_marker);
3454 /* just a click, do nothing but finish
3455 off the selection process
3458 Selection::Operation op = ArdourKeyboard::selection_type (event->button.state);
3461 case Selection::Set:
3462 if (_editor->selection->selected (_marker) && _editor->selection->markers.size() > 1) {
3463 _editor->selection->set (_marker);
3467 case Selection::Toggle:
3468 /* we toggle on the button release, click only */
3469 _editor->selection->toggle (_marker);
3472 case Selection::Extend:
3473 case Selection::Add:
3480 _editor->_dragging_edit_point = false;
3482 _editor->begin_reversible_command ( _("move marker") );
3483 XMLNode &before = _editor->session()->locations()->get_state();
3485 MarkerSelection::iterator i;
3486 CopiedLocationInfo::iterator x;
3489 for (i = _editor->selection->markers.begin(), x = _copied_locations.begin();
3490 x != _copied_locations.end() && i != _editor->selection->markers.end();
3493 Location * location = _editor->find_location_from_marker (*i, is_start);
3497 if (location->locked()) {
3501 if (location->is_mark()) {
3502 location->set_start (((*x).location)->start());
3504 location->set (((*x).location)->start(), ((*x).location)->end());
3509 XMLNode &after = _editor->session()->locations()->get_state();
3510 _editor->session()->add_command(new MementoCommand<Locations>(*(_editor->session()->locations()), &before, &after));
3511 _editor->commit_reversible_command ();
3515 MarkerDrag::aborted (bool)
3521 MarkerDrag::update_item (Location*)
3526 ControlPointDrag::ControlPointDrag (Editor* e, ArdourCanvas::Item* i)
3528 _cumulative_x_drag (0),
3529 _cumulative_y_drag (0)
3531 if (_zero_gain_fraction < 0.0) {
3532 _zero_gain_fraction = gain_to_slider_position_with_max (dB_to_coefficient (0.0), Config->get_max_gain());
3535 DEBUG_TRACE (DEBUG::Drags, "New ControlPointDrag\n");
3537 _point = reinterpret_cast<ControlPoint*> (_item->get_data ("control_point"));
3543 ControlPointDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*cursor*/)
3545 Drag::start_grab (event, _editor->cursors()->fader);
3547 // start the grab at the center of the control point so
3548 // the point doesn't 'jump' to the mouse after the first drag
3549 _fixed_grab_x = _point->get_x();
3550 _fixed_grab_y = _point->get_y();
3552 float const fraction = 1 - (_point->get_y() / _point->line().height());
3554 _point->line().start_drag_single (_point, _fixed_grab_x, fraction);
3556 show_verbose_cursor_text (_point->line().get_verbose_cursor_string (fraction));
3558 _pushing = Keyboard::modifier_state_contains (event->button.state, Keyboard::PrimaryModifier);
3560 if (!_point->can_slide ()) {
3561 _x_constrained = true;
3566 ControlPointDrag::motion (GdkEvent* event, bool)
3568 double dx = _drags->current_pointer_x() - last_pointer_x();
3569 double dy = current_pointer_y() - last_pointer_y();
3571 if (event->button.state & Keyboard::SecondaryModifier) {
3576 /* coordinate in pixels relative to the start of the region (for region-based automation)
3577 or track (for track-based automation) */
3578 double cx = _fixed_grab_x + _cumulative_x_drag + dx;
3579 double cy = _fixed_grab_y + _cumulative_y_drag + dy;
3581 // calculate zero crossing point. back off by .01 to stay on the
3582 // positive side of zero
3583 double const zero_gain_y = (1.0 - _zero_gain_fraction) * _point->line().height() - .01;
3585 // make sure we hit zero when passing through
3586 if ((cy < zero_gain_y && (cy - dy) > zero_gain_y) || (cy > zero_gain_y && (cy - dy) < zero_gain_y)) {
3590 if (_x_constrained) {
3593 if (_y_constrained) {
3597 _cumulative_x_drag = cx - _fixed_grab_x;
3598 _cumulative_y_drag = cy - _fixed_grab_y;
3602 cy = min ((double) _point->line().height(), cy);
3604 framepos_t cx_frames = _editor->pixel_to_sample (cx);
3606 if (!_x_constrained) {
3607 _editor->snap_to_with_modifier (cx_frames, event);
3610 cx_frames = min (cx_frames, _point->line().maximum_time());
3612 float const fraction = 1.0 - (cy / _point->line().height());
3614 _point->line().drag_motion (_editor->sample_to_pixel_unrounded (cx_frames), fraction, false, _pushing, _final_index);
3616 show_verbose_cursor_text (_point->line().get_verbose_cursor_string (fraction));
3620 ControlPointDrag::finished (GdkEvent* event, bool movement_occurred)
3622 if (!movement_occurred) {
3626 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
3627 _editor->reset_point_selection ();
3631 motion (event, false);
3634 _point->line().end_drag (_pushing, _final_index);
3635 _editor->session()->commit_reversible_command ();
3639 ControlPointDrag::aborted (bool)
3641 _point->line().reset ();
3645 ControlPointDrag::active (Editing::MouseMode m)
3647 if (m == Editing::MouseGain) {
3648 /* always active in mouse gain */
3652 /* otherwise active if the point is on an automation line (ie not if its on a region gain line) */
3653 return dynamic_cast<AutomationLine*> (&(_point->line())) != 0;
3656 LineDrag::LineDrag (Editor* e, ArdourCanvas::Item* i)
3659 _cumulative_y_drag (0)
3661 DEBUG_TRACE (DEBUG::Drags, "New LineDrag\n");
3665 LineDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*cursor*/)
3667 _line = reinterpret_cast<AutomationLine*> (_item->get_data ("line"));
3670 _item = &_line->grab_item ();
3672 /* need to get x coordinate in terms of parent (TimeAxisItemView)
3673 origin, and ditto for y.
3676 double cx = event->button.x;
3677 double cy = event->button.y;
3679 _line->parent_group().canvas_to_item (cx, cy);
3681 framecnt_t const frame_within_region = (framecnt_t) floor (cx * _editor->samples_per_pixel);
3686 if (!_line->control_points_adjacent (frame_within_region, before, after)) {
3687 /* no adjacent points */
3691 Drag::start_grab (event, _editor->cursors()->fader);
3693 /* store grab start in parent frame */
3698 double fraction = 1.0 - (cy / _line->height());
3700 _line->start_drag_line (before, after, fraction);
3702 show_verbose_cursor_text (_line->get_verbose_cursor_string (fraction));
3706 LineDrag::motion (GdkEvent* event, bool)
3708 double dy = current_pointer_y() - last_pointer_y();
3710 if (event->button.state & Keyboard::SecondaryModifier) {
3714 double cy = _fixed_grab_y + _cumulative_y_drag + dy;
3716 _cumulative_y_drag = cy - _fixed_grab_y;
3719 cy = min ((double) _line->height(), cy);
3721 double const fraction = 1.0 - (cy / _line->height());
3724 /* we are ignoring x position for this drag, so we can just pass in anything */
3725 _line->drag_motion (0, fraction, true, false, ignored);
3727 show_verbose_cursor_text (_line->get_verbose_cursor_string (fraction));
3731 LineDrag::finished (GdkEvent* event, bool movement_occured)
3733 if (movement_occured) {
3734 motion (event, false);
3735 _line->end_drag (false, 0);
3737 /* add a new control point on the line */
3739 AutomationTimeAxisView* atv;
3741 _line->end_drag (false, 0);
3743 if ((atv = dynamic_cast<AutomationTimeAxisView*>(_editor->clicked_axisview)) != 0) {
3744 framepos_t where = _editor->window_event_sample (event, 0, 0);
3745 atv->add_automation_event (event, where, event->button.y, false);
3749 _editor->session()->commit_reversible_command ();
3753 LineDrag::aborted (bool)
3758 FeatureLineDrag::FeatureLineDrag (Editor* e, ArdourCanvas::Item* i)
3761 _cumulative_x_drag (0)
3763 DEBUG_TRACE (DEBUG::Drags, "New FeatureLineDrag\n");
3767 FeatureLineDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*cursor*/)
3769 Drag::start_grab (event);
3771 _line = reinterpret_cast<Line*> (_item);
3774 /* need to get x coordinate in terms of parent (AudioRegionView) origin. */
3776 double cx = event->button.x;
3777 double cy = event->button.y;
3779 _item->parent()->canvas_to_item (cx, cy);
3781 /* store grab start in parent frame */
3782 _region_view_grab_x = cx;
3784 _before = *(float*) _item->get_data ("position");
3786 _arv = reinterpret_cast<AudioRegionView*> (_item->get_data ("regionview"));
3788 _max_x = _editor->sample_to_pixel(_arv->get_duration());
3792 FeatureLineDrag::motion (GdkEvent*, bool)
3794 double dx = _drags->current_pointer_x() - last_pointer_x();
3796 double cx = _region_view_grab_x + _cumulative_x_drag + dx;
3798 _cumulative_x_drag += dx;
3800 /* Clamp the min and max extent of the drag to keep it within the region view bounds */
3809 boost::optional<ArdourCanvas::Rect> bbox = _line->bounding_box ();
3811 _line->set (ArdourCanvas::Duple (cx, 2.0), ArdourCanvas::Duple (cx, bbox.get().height ()));
3813 float *pos = new float;
3816 _line->set_data ("position", pos);
3822 FeatureLineDrag::finished (GdkEvent*, bool)
3824 _arv = reinterpret_cast<AudioRegionView*> (_item->get_data ("regionview"));
3825 _arv->update_transient(_before, _before);
3829 FeatureLineDrag::aborted (bool)
3834 RubberbandSelectDrag::RubberbandSelectDrag (Editor* e, ArdourCanvas::Item* i)
3836 , _vertical_only (false)
3838 DEBUG_TRACE (DEBUG::Drags, "New RubberbandSelectDrag\n");
3842 RubberbandSelectDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
3844 Drag::start_grab (event);
3845 show_verbose_cursor_time (adjusted_current_frame (event));
3849 RubberbandSelectDrag::motion (GdkEvent* event, bool)
3856 framepos_t const pf = adjusted_current_frame (event, Config->get_rubberbanding_snaps_to_grid ());
3858 framepos_t grab = grab_frame ();
3859 if (Config->get_rubberbanding_snaps_to_grid ()) {
3860 _editor->snap_to_with_modifier (grab, event);
3863 /* base start and end on initial click position */
3873 if (current_pointer_y() < grab_y()) {
3874 y1 = current_pointer_y();
3877 y2 = current_pointer_y();
3881 if (start != end || y1 != y2) {
3883 double x1 = _editor->sample_to_pixel (start);
3884 double x2 = _editor->sample_to_pixel (end);
3885 const double min_dimension = 2.0;
3887 if (_vertical_only) {
3888 /* fixed 10 pixel width */
3892 x2 = min (x1 - min_dimension, x2);
3894 x2 = max (x1 + min_dimension, x2);
3899 y2 = min (y1 - min_dimension, y2);
3901 y2 = max (y1 + min_dimension, y2);
3904 /* translate rect into item space and set */
3906 ArdourCanvas::Rect r (x1, y1, x2, y2);
3908 /* this drag is a _trackview_only == true drag, so the y1 and
3909 * y2 (computed using current_pointer_y() and grab_y()) will be
3910 * relative to the top of the trackview group). The
3911 * rubberband rect has the same parent/scroll offset as the
3912 * the trackview group, so we can use the "r" rect directly
3913 * to set the shape of the rubberband.
3916 _editor->rubberband_rect->set (r);
3917 _editor->rubberband_rect->show();
3918 _editor->rubberband_rect->raise_to_top();
3920 show_verbose_cursor_time (pf);
3922 do_select_things (event, true);
3927 RubberbandSelectDrag::do_select_things (GdkEvent* event, bool drag_in_progress)
3932 if (grab_frame() < last_pointer_frame()) {
3934 x2 = last_pointer_frame ();
3937 x1 = last_pointer_frame ();
3943 if (current_pointer_y() < grab_y()) {
3944 y1 = current_pointer_y();
3947 y2 = current_pointer_y();
3951 select_things (event->button.state, x1, x2, y1, y2, drag_in_progress);
3955 RubberbandSelectDrag::finished (GdkEvent* event, bool movement_occurred)
3957 if (movement_occurred) {
3959 motion (event, false);
3960 do_select_things (event, false);
3966 bool do_deselect = true;
3967 MidiTimeAxisView* mtv;
3969 if ((mtv = dynamic_cast<MidiTimeAxisView*>(_editor->clicked_axisview)) != 0) {
3971 if (_editor->selection->empty() && _editor->mouse_mode == MouseDraw) {
3972 /* nothing selected */
3973 add_midi_region (mtv);
3974 do_deselect = false;
3978 /* do not deselect if Primary or Tertiary (toggle-select or
3979 * extend-select are pressed.
3982 if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::PrimaryModifier) &&
3983 !Keyboard::modifier_state_contains (event->button.state, Keyboard::TertiaryModifier) &&
3990 _editor->rubberband_rect->hide();
3994 RubberbandSelectDrag::aborted (bool)
3996 _editor->rubberband_rect->hide ();
3999 TimeFXDrag::TimeFXDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, std::list<RegionView*> const & v)
4000 : RegionDrag (e, i, p, v)
4002 DEBUG_TRACE (DEBUG::Drags, "New TimeFXDrag\n");
4006 TimeFXDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
4008 Drag::start_grab (event, cursor);
4010 show_verbose_cursor_time (adjusted_current_frame (event));
4014 TimeFXDrag::motion (GdkEvent* event, bool)
4016 RegionView* rv = _primary;
4017 StreamView* cv = rv->get_time_axis_view().view ();
4019 pair<TimeAxisView*, double> const tv = _editor->trackview_by_y_position (grab_y());
4020 int layer = tv.first->layer_display() == Overlaid ? 0 : tv.second;
4021 int layers = tv.first->layer_display() == Overlaid ? 1 : cv->layers();
4023 framepos_t const pf = adjusted_current_frame (event);
4025 if (pf > rv->region()->position()) {
4026 rv->get_time_axis_view().show_timestretch (rv->region()->position(), pf, layers, layer);
4029 show_verbose_cursor_time (pf);
4033 TimeFXDrag::finished (GdkEvent* /*event*/, bool movement_occurred)
4035 _primary->get_time_axis_view().hide_timestretch ();
4037 if (!movement_occurred) {
4041 if (last_pointer_frame() < _primary->region()->position()) {
4042 /* backwards drag of the left edge - not usable */
4046 framecnt_t newlen = last_pointer_frame() - _primary->region()->position();
4048 float percentage = (double) newlen / (double) _primary->region()->length();
4050 #ifndef USE_RUBBERBAND
4051 // Soundtouch uses percentage / 100 instead of normal (/ 1)
4052 if (_primary->region()->data_type() == DataType::AUDIO) {
4053 percentage = (float) ((double) newlen - (double) _primary->region()->length()) / ((double) newlen) * 100.0f;
4057 if (!_editor->get_selection().regions.empty()) {
4058 /* primary will already be included in the selection, and edit
4059 group shared editing will propagate selection across
4060 equivalent regions, so just use the current region
4064 if (_editor->time_stretch (_editor->get_selection().regions, percentage) == -1) {
4065 error << _("An error occurred while executing time stretch operation") << endmsg;
4071 TimeFXDrag::aborted (bool)
4073 _primary->get_time_axis_view().hide_timestretch ();
4076 ScrubDrag::ScrubDrag (Editor* e, ArdourCanvas::Item* i)
4079 DEBUG_TRACE (DEBUG::Drags, "New ScrubDrag\n");
4083 ScrubDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
4085 Drag::start_grab (event);
4089 ScrubDrag::motion (GdkEvent* /*event*/, bool)
4091 _editor->scrub (adjusted_current_frame (0, false), _drags->current_pointer_x ());
4095 ScrubDrag::finished (GdkEvent* /*event*/, bool movement_occurred)
4097 if (movement_occurred && _editor->session()) {
4098 /* make sure we stop */
4099 _editor->session()->request_transport_speed (0.0);
4104 ScrubDrag::aborted (bool)
4109 SelectionDrag::SelectionDrag (Editor* e, ArdourCanvas::Item* i, Operation o)
4113 , _original_pointer_time_axis (-1)
4114 , _time_selection_at_start (!_editor->get_selection().time.empty())
4116 DEBUG_TRACE (DEBUG::Drags, "New SelectionDrag\n");
4118 if (_time_selection_at_start) {
4119 start_at_start = _editor->get_selection().time.start();
4120 end_at_start = _editor->get_selection().time.end_frame();
4125 SelectionDrag::start_grab (GdkEvent* event, Gdk::Cursor*)
4127 if (_editor->session() == 0) {
4131 Gdk::Cursor* cursor = 0;
4133 switch (_operation) {
4134 case CreateSelection:
4135 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::CopyModifier)) {
4140 cursor = _editor->cursors()->selector;
4141 Drag::start_grab (event, cursor);
4144 case SelectionStartTrim:
4145 if (_editor->clicked_axisview) {
4146 _editor->clicked_axisview->order_selection_trims (_item, true);
4148 Drag::start_grab (event, _editor->cursors()->left_side_trim);
4151 case SelectionEndTrim:
4152 if (_editor->clicked_axisview) {
4153 _editor->clicked_axisview->order_selection_trims (_item, false);
4155 Drag::start_grab (event, _editor->cursors()->right_side_trim);
4159 Drag::start_grab (event, cursor);
4162 case SelectionExtend:
4163 Drag::start_grab (event, cursor);
4167 if (_operation == SelectionMove) {
4168 show_verbose_cursor_time (_editor->selection->time[_editor->clicked_selection].start);
4170 show_verbose_cursor_time (adjusted_current_frame (event));
4173 _original_pointer_time_axis = _editor->trackview_by_y_position (current_pointer_y ()).first->order ();
4177 SelectionDrag::setup_pointer_frame_offset ()
4179 switch (_operation) {
4180 case CreateSelection:
4181 _pointer_frame_offset = 0;
4184 case SelectionStartTrim:
4186 _pointer_frame_offset = raw_grab_frame() - _editor->selection->time[_editor->clicked_selection].start;
4189 case SelectionEndTrim:
4190 _pointer_frame_offset = raw_grab_frame() - _editor->selection->time[_editor->clicked_selection].end;
4193 case SelectionExtend:
4199 SelectionDrag::motion (GdkEvent* event, bool first_move)
4201 framepos_t start = 0;
4203 framecnt_t length = 0;
4204 framecnt_t distance = 0;
4206 framepos_t const pending_position = adjusted_current_frame (event);
4208 if (_operation != CreateSelection && pending_position == last_pointer_frame()) {
4212 switch (_operation) {
4213 case CreateSelection:
4215 framepos_t grab = grab_frame ();
4218 grab = adjusted_current_frame (event, false);
4219 if (grab < pending_position) {
4220 _editor->snap_to (grab, RoundDownMaybe);
4222 _editor->snap_to (grab, RoundUpMaybe);
4226 if (pending_position < grab) {
4227 start = pending_position;
4230 end = pending_position;
4234 /* first drag: Either add to the selection
4235 or create a new selection
4242 /* adding to the selection */
4243 _editor->set_selected_track_as_side_effect (Selection::Add);
4244 _editor->clicked_selection = _editor->selection->add (start, end);
4251 if (_editor->clicked_axisview && !_editor->selection->selected (_editor->clicked_axisview)) {
4252 _editor->set_selected_track_as_side_effect (Selection::Set);
4255 _editor->clicked_selection = _editor->selection->set (start, end);
4259 //if user is selecting a range on an automation track, bail out here before we get to the grouped stuff,
4260 // because the grouped stuff will start working on tracks (routeTAVs), and end up removing this
4261 AutomationTimeAxisView *atest = dynamic_cast<AutomationTimeAxisView *>(_editor->clicked_axisview);
4263 _editor->selection->add (atest);
4267 /* select all tracks within the rectangle that we've marked out so far */
4268 TrackViewList new_selection;
4269 TrackViewList& all_tracks (_editor->track_views);
4271 ArdourCanvas::Coord const top = grab_y();
4272 ArdourCanvas::Coord const bottom = current_pointer_y();
4274 if (top >= 0 && bottom >= 0) {
4276 //first, find the tracks that are covered in the y range selection
4277 for (TrackViewList::const_iterator i = all_tracks.begin(); i != all_tracks.end(); ++i) {
4278 if ((*i)->covered_by_y_range (top, bottom)) {
4279 new_selection.push_back (*i);
4283 //now find any tracks that are GROUPED with the tracks we selected
4284 TrackViewList grouped_add = new_selection;
4285 for (TrackViewList::const_iterator i = new_selection.begin(); i != new_selection.end(); ++i) {
4286 RouteTimeAxisView *n = dynamic_cast<RouteTimeAxisView *>(*i);
4287 if ( n && n->route()->route_group() && n->route()->route_group()->is_active() && n->route()->route_group()->enabled_property (ARDOUR::Properties::select.property_id) ) {
4288 for (TrackViewList::const_iterator j = all_tracks.begin(); j != all_tracks.end(); ++j) {
4289 RouteTimeAxisView *check = dynamic_cast<RouteTimeAxisView *>(*j);
4290 if ( check && (n != check) && (check->route()->route_group() == n->route()->route_group()) )
4291 grouped_add.push_back (*j);
4296 //now compare our list with the current selection, and add or remove as necessary
4297 //( NOTE: most mouse moves don't change the selection so we can't just SET it for every mouse move; it gets clunky )
4298 TrackViewList tracks_to_add;
4299 TrackViewList tracks_to_remove;
4300 for (TrackViewList::const_iterator i = grouped_add.begin(); i != grouped_add.end(); ++i)
4301 if ( !_editor->selection->tracks.contains ( *i ) )
4302 tracks_to_add.push_back ( *i );
4303 for (TrackViewList::const_iterator i = _editor->selection->tracks.begin(); i != _editor->selection->tracks.end(); ++i)
4304 if ( !grouped_add.contains ( *i ) )
4305 tracks_to_remove.push_back ( *i );
4306 _editor->selection->add(tracks_to_add);
4307 _editor->selection->remove(tracks_to_remove);
4313 case SelectionStartTrim:
4315 start = _editor->selection->time[_editor->clicked_selection].start;
4316 end = _editor->selection->time[_editor->clicked_selection].end;
4318 if (pending_position > end) {
4321 start = pending_position;
4325 case SelectionEndTrim:
4327 start = _editor->selection->time[_editor->clicked_selection].start;
4328 end = _editor->selection->time[_editor->clicked_selection].end;
4330 if (pending_position < start) {
4333 end = pending_position;
4340 start = _editor->selection->time[_editor->clicked_selection].start;
4341 end = _editor->selection->time[_editor->clicked_selection].end;
4343 length = end - start;
4344 distance = pending_position - start;
4345 start = pending_position;
4346 _editor->snap_to (start);
4348 end = start + length;
4352 case SelectionExtend:
4357 switch (_operation) {
4359 if (_time_selection_at_start) {
4360 _editor->selection->move_time (distance);
4364 _editor->selection->replace (_editor->clicked_selection, start, end);
4368 if (_operation == SelectionMove) {
4369 show_verbose_cursor_time(start);
4371 show_verbose_cursor_time(pending_position);
4376 SelectionDrag::finished (GdkEvent* event, bool movement_occurred)
4378 Session* s = _editor->session();
4380 if (movement_occurred) {
4381 motion (event, false);
4382 /* XXX this is not object-oriented programming at all. ick */
4383 if (_editor->selection->time.consolidate()) {
4384 _editor->selection->TimeChanged ();
4387 /* XXX what if its a music time selection? */
4389 if ( s->get_play_range() && s->transport_rolling() ) {
4390 s->request_play_range (&_editor->selection->time, true);
4392 if (Config->get_follow_edits() && !s->transport_rolling()) {
4393 if (_operation == SelectionEndTrim)
4394 _editor->maybe_locate_with_edit_preroll( _editor->get_selection().time.end_frame());
4396 s->request_locate (_editor->get_selection().time.start());
4402 /* just a click, no pointer movement.
4405 if (_operation == SelectionExtend) {
4406 if (_time_selection_at_start) {
4407 framepos_t pos = adjusted_current_frame (event, false);
4408 framepos_t start = min (pos, start_at_start);
4409 framepos_t end = max (pos, end_at_start);
4410 _editor->selection->set (start, end);
4413 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::CopyModifier)) {
4414 if (_editor->clicked_selection) {
4415 _editor->selection->remove (_editor->clicked_selection);
4418 if (!_editor->clicked_selection) {
4419 _editor->selection->clear_time();
4424 if (_editor->clicked_axisview && !_editor->selection->selected (_editor->clicked_axisview)) {
4425 _editor->selection->set (_editor->clicked_axisview);
4428 if (s && s->get_play_range () && s->transport_rolling()) {
4429 s->request_stop (false, false);
4434 _editor->stop_canvas_autoscroll ();
4435 _editor->clicked_selection = 0;
4439 SelectionDrag::aborted (bool)
4444 RangeMarkerBarDrag::RangeMarkerBarDrag (Editor* e, ArdourCanvas::Item* i, Operation o)
4445 : Drag (e, i, false),
4449 DEBUG_TRACE (DEBUG::Drags, "New RangeMarkerBarDrag\n");
4451 _drag_rect = new ArdourCanvas::Rectangle (_editor->time_line_group,
4452 ArdourCanvas::Rect (0.0, 0.0, 0.0,
4453 physical_screen_height (_editor->get_window())));
4454 _drag_rect->hide ();
4456 _drag_rect->set_fill_color (ARDOUR_UI::config()->get_RangeDragRect());
4457 _drag_rect->set_outline_color (ARDOUR_UI::config()->get_RangeDragRect());
4461 RangeMarkerBarDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
4463 if (_editor->session() == 0) {
4467 Gdk::Cursor* cursor = 0;
4469 if (!_editor->temp_location) {
4470 _editor->temp_location = new Location (*_editor->session());
4473 switch (_operation) {
4474 case CreateSkipMarker:
4475 case CreateRangeMarker:
4476 case CreateTransportMarker:
4477 case CreateCDMarker:
4479 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
4484 cursor = _editor->cursors()->selector;
4488 Drag::start_grab (event, cursor);
4490 show_verbose_cursor_time (adjusted_current_frame (event));
4494 RangeMarkerBarDrag::motion (GdkEvent* event, bool first_move)
4496 framepos_t start = 0;
4498 ArdourCanvas::Rectangle *crect;
4500 switch (_operation) {
4501 case CreateSkipMarker:
4502 crect = _editor->range_bar_drag_rect;
4504 case CreateRangeMarker:
4505 crect = _editor->range_bar_drag_rect;
4507 case CreateTransportMarker:
4508 crect = _editor->transport_bar_drag_rect;
4510 case CreateCDMarker:
4511 crect = _editor->cd_marker_bar_drag_rect;
4514 error << string_compose (_("programming_error: %1"), "Error: unknown range marker op passed to Editor::drag_range_markerbar_op ()") << endmsg;
4519 framepos_t const pf = adjusted_current_frame (event);
4521 if (_operation == CreateSkipMarker || _operation == CreateRangeMarker || _operation == CreateTransportMarker || _operation == CreateCDMarker) {
4522 framepos_t grab = grab_frame ();
4523 _editor->snap_to (grab);
4525 if (pf < grab_frame()) {
4533 /* first drag: Either add to the selection
4534 or create a new selection.
4539 _editor->temp_location->set (start, end);
4543 update_item (_editor->temp_location);
4545 //_drag_rect->raise_to_top();
4551 _editor->temp_location->set (start, end);
4553 double x1 = _editor->sample_to_pixel (start);
4554 double x2 = _editor->sample_to_pixel (end);
4558 update_item (_editor->temp_location);
4561 show_verbose_cursor_time (pf);
4566 RangeMarkerBarDrag::finished (GdkEvent* event, bool movement_occurred)
4568 Location * newloc = 0;
4572 if (movement_occurred) {
4573 motion (event, false);
4576 switch (_operation) {
4577 case CreateSkipMarker:
4578 case CreateRangeMarker:
4579 case CreateCDMarker:
4581 XMLNode &before = _editor->session()->locations()->get_state();
4582 if (_operation == CreateSkipMarker) {
4583 _editor->begin_reversible_command (_("new skip marker"));
4584 _editor->session()->locations()->next_available_name(rangename,_("skip"));
4585 flags = Location::IsRangeMarker | Location::IsSkip;
4586 _editor->range_bar_drag_rect->hide();
4587 } else if (_operation == CreateCDMarker) {
4588 _editor->session()->locations()->next_available_name(rangename, _("CD"));
4589 _editor->begin_reversible_command (_("new CD marker"));
4590 flags = Location::IsRangeMarker | Location::IsCDMarker;
4591 _editor->cd_marker_bar_drag_rect->hide();
4593 _editor->begin_reversible_command (_("new skip marker"));
4594 _editor->session()->locations()->next_available_name(rangename, _("unnamed"));
4595 flags = Location::IsRangeMarker;
4596 _editor->range_bar_drag_rect->hide();
4598 newloc = new Location (
4599 *_editor->session(), _editor->temp_location->start(), _editor->temp_location->end(), rangename, (Location::Flags) flags
4602 _editor->session()->locations()->add (newloc, true);
4603 XMLNode &after = _editor->session()->locations()->get_state();
4604 _editor->session()->add_command(new MementoCommand<Locations>(*(_editor->session()->locations()), &before, &after));
4605 _editor->commit_reversible_command ();
4609 case CreateTransportMarker:
4610 // popup menu to pick loop or punch
4611 _editor->new_transport_marker_context_menu (&event->button, _item);
4617 /* just a click, no pointer movement. remember that context menu stuff was handled elsewhere */
4619 if (_operation == CreateTransportMarker) {
4621 /* didn't drag, so just locate */
4623 _editor->session()->request_locate (grab_frame(), _editor->session()->transport_rolling());
4625 } else if (_operation == CreateCDMarker) {
4627 /* didn't drag, but mark is already created so do
4630 } else { /* operation == CreateRangeMarker || CreateSkipMarker */
4636 _editor->session()->locations()->marks_either_side (grab_frame(), start, end);
4638 if (end == max_framepos) {
4639 end = _editor->session()->current_end_frame ();
4642 if (start == max_framepos) {
4643 start = _editor->session()->current_start_frame ();
4646 switch (_editor->mouse_mode) {
4648 /* find the two markers on either side and then make the selection from it */
4649 _editor->select_all_within (start, end, 0.0f, FLT_MAX, _editor->track_views, Selection::Set, false);
4653 /* find the two markers on either side of the click and make the range out of it */
4654 _editor->selection->set (start, end);
4663 _editor->stop_canvas_autoscroll ();
4667 RangeMarkerBarDrag::aborted (bool)
4673 RangeMarkerBarDrag::update_item (Location* location)
4675 double const x1 = _editor->sample_to_pixel (location->start());
4676 double const x2 = _editor->sample_to_pixel (location->end());
4678 _drag_rect->set_x0 (x1);
4679 _drag_rect->set_x1 (x2);
4682 NoteDrag::NoteDrag (Editor* e, ArdourCanvas::Item* i)
4684 , _cumulative_dx (0)
4685 , _cumulative_dy (0)
4687 DEBUG_TRACE (DEBUG::Drags, "New NoteDrag\n");
4689 _primary = reinterpret_cast<NoteBase*> (_item->get_data ("notebase"));
4691 _region = &_primary->region_view ();
4692 _note_height = _region->midi_stream_view()->note_height ();
4696 NoteDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
4698 Drag::start_grab (event);
4700 if (!(_was_selected = _primary->selected())) {
4702 /* tertiary-click means extend selection - we'll do that on button release,
4703 so don't add it here, because otherwise we make it hard to figure
4704 out the "extend-to" range.
4707 bool extend = Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier);
4710 bool add = Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier);
4713 _region->note_selected (_primary, true);
4715 _region->unique_select (_primary);
4721 /** @return Current total drag x change in frames */
4723 NoteDrag::total_dx () const
4726 frameoffset_t const dx = _editor->pixel_to_sample (_drags->current_pointer_x() - grab_x());
4728 /* primary note time */
4729 frameoffset_t const n = _region->source_beats_to_absolute_frames (_primary->note()->time ());
4731 /* new time of the primary note in session frames */
4732 frameoffset_t st = n + dx;
4734 framepos_t const rp = _region->region()->position ();
4736 /* prevent the note being dragged earlier than the region's position */
4739 /* snap and return corresponding delta */
4740 return _region->snap_frame_to_frame (st - rp) + rp - n;
4743 /** @return Current total drag y change in note number */
4745 NoteDrag::total_dy () const
4747 MidiStreamView* msv = _region->midi_stream_view ();
4748 double const y = _region->midi_view()->y_position ();
4749 /* new current note */
4750 uint8_t n = msv->y_to_note (current_pointer_y () - y);
4752 n = max (msv->lowest_note(), n);
4753 n = min (msv->highest_note(), n);
4754 /* and work out delta */
4755 return n - msv->y_to_note (grab_y() - y);
4759 NoteDrag::motion (GdkEvent *, bool)
4761 /* Total change in x and y since the start of the drag */
4762 frameoffset_t const dx = total_dx ();
4763 int8_t const dy = total_dy ();
4765 /* Now work out what we have to do to the note canvas items to set this new drag delta */
4766 double const tdx = _editor->sample_to_pixel (dx) - _cumulative_dx;
4767 double const tdy = -dy * _note_height - _cumulative_dy;
4770 _cumulative_dx += tdx;
4771 _cumulative_dy += tdy;
4773 int8_t note_delta = total_dy();
4775 _region->move_selection (tdx, tdy, note_delta);
4777 /* the new note value may be the same as the old one, but we
4778 * don't know what that means because the selection may have
4779 * involved more than one note and we might be doing something
4780 * odd with them. so show the note value anyway, always.
4784 uint8_t new_note = min (max (_primary->note()->note() + note_delta, 0), 127);
4786 snprintf (buf, sizeof (buf), "%s (%d)", Evoral::midi_note_name (new_note).c_str(),
4787 (int) floor ((double)new_note));
4789 show_verbose_cursor_text (buf);
4794 NoteDrag::finished (GdkEvent* ev, bool moved)
4797 /* no motion - select note */
4799 if (_editor->current_mouse_mode() == Editing::MouseObject ||
4800 _editor->current_mouse_mode() == Editing::MouseDraw) {
4802 if (_was_selected) {
4803 bool add = Keyboard::modifier_state_equals (ev->button.state, Keyboard::PrimaryModifier);
4805 _region->note_deselected (_primary);
4808 bool extend = Keyboard::modifier_state_equals (ev->button.state, Keyboard::TertiaryModifier);
4809 bool add = Keyboard::modifier_state_equals (ev->button.state, Keyboard::PrimaryModifier);
4811 if (!extend && !add && _region->selection_size() > 1) {
4812 _region->unique_select (_primary);
4813 } else if (extend) {
4814 _region->note_selected (_primary, true, true);
4816 /* it was added during button press */
4821 _region->note_dropped (_primary, total_dx(), total_dy());
4826 NoteDrag::aborted (bool)
4831 /** Make an AutomationRangeDrag for lines in an AutomationTimeAxisView */
4832 AutomationRangeDrag::AutomationRangeDrag (Editor* editor, AutomationTimeAxisView* atv, list<AudioRange> const & r)
4833 : Drag (editor, atv->base_item ())
4835 , _nothing_to_drag (false)
4837 DEBUG_TRACE (DEBUG::Drags, "New AutomationRangeDrag\n");
4838 y_origin = atv->y_position();
4839 setup (atv->lines ());
4842 /** Make an AutomationRangeDrag for region gain lines */
4843 AutomationRangeDrag::AutomationRangeDrag (Editor* editor, AudioRegionView* rv, list<AudioRange> const & r)
4844 : Drag (editor, rv->get_canvas_group ())
4846 , _nothing_to_drag (false)
4848 DEBUG_TRACE (DEBUG::Drags, "New AutomationRangeDrag\n");
4850 list<boost::shared_ptr<AutomationLine> > lines;
4851 lines.push_back (rv->get_gain_line ());
4852 y_origin = rv->get_time_axis_view().y_position();
4856 /** @param lines AutomationLines to drag.
4857 * @param offset Offset from the session start to the points in the AutomationLines.
4860 AutomationRangeDrag::setup (list<boost::shared_ptr<AutomationLine> > const & lines)
4862 /* find the lines that overlap the ranges being dragged */
4863 list<boost::shared_ptr<AutomationLine> >::const_iterator i = lines.begin ();
4864 while (i != lines.end ()) {
4865 list<boost::shared_ptr<AutomationLine> >::const_iterator j = i;
4868 pair<framepos_t, framepos_t> r = (*i)->get_point_x_range ();
4870 /* check this range against all the AudioRanges that we are using */
4871 list<AudioRange>::const_iterator k = _ranges.begin ();
4872 while (k != _ranges.end()) {
4873 if (k->coverage (r.first, r.second) != Evoral::OverlapNone) {
4879 /* add it to our list if it overlaps at all */
4880 if (k != _ranges.end()) {
4885 _lines.push_back (n);
4891 /* Now ::lines contains the AutomationLines that somehow overlap our drag */
4895 AutomationRangeDrag::y_fraction (boost::shared_ptr<AutomationLine> line, double global_y) const
4897 return 1.0 - ((global_y - y_origin) / line->height());
4901 AutomationRangeDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
4903 Drag::start_grab (event, cursor);
4905 /* Get line states before we start changing things */
4906 for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
4907 i->state = &i->line->get_state ();
4908 i->original_fraction = y_fraction (i->line, current_pointer_y());
4911 if (_ranges.empty()) {
4913 /* No selected time ranges: drag all points */
4914 for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
4915 uint32_t const N = i->line->npoints ();
4916 for (uint32_t j = 0; j < N; ++j) {
4917 i->points.push_back (i->line->nth (j));
4923 for (list<AudioRange>::const_iterator i = _ranges.begin(); i != _ranges.end(); ++i) {
4925 framecnt_t const half = (i->start + i->end) / 2;
4927 /* find the line that this audio range starts in */
4928 list<Line>::iterator j = _lines.begin();
4929 while (j != _lines.end() && (j->range.first > i->start || j->range.second < i->start)) {
4933 if (j != _lines.end()) {
4934 boost::shared_ptr<AutomationList> the_list = j->line->the_list ();
4936 /* j is the line that this audio range starts in; fade into it;
4937 64 samples length plucked out of thin air.
4940 framepos_t a = i->start + 64;
4945 double const p = j->line->time_converter().from (i->start - j->line->time_converter().origin_b ());
4946 double const q = j->line->time_converter().from (a - j->line->time_converter().origin_b ());
4948 the_list->editor_add (p, the_list->eval (p));
4949 the_list->editor_add (q, the_list->eval (q));
4952 /* same thing for the end */
4955 while (j != _lines.end() && (j->range.first > i->end || j->range.second < i->end)) {
4959 if (j != _lines.end()) {
4960 boost::shared_ptr<AutomationList> the_list = j->line->the_list ();
4962 /* j is the line that this audio range starts in; fade out of it;
4963 64 samples length plucked out of thin air.
4966 framepos_t b = i->end - 64;
4971 double const p = j->line->time_converter().from (b - j->line->time_converter().origin_b ());
4972 double const q = j->line->time_converter().from (i->end - j->line->time_converter().origin_b ());
4974 the_list->editor_add (p, the_list->eval (p));
4975 the_list->editor_add (q, the_list->eval (q));
4979 _nothing_to_drag = true;
4981 /* Find all the points that should be dragged and put them in the relevant
4982 points lists in the Line structs.
4985 for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
4987 uint32_t const N = i->line->npoints ();
4988 for (uint32_t j = 0; j < N; ++j) {
4990 /* here's a control point on this line */
4991 ControlPoint* p = i->line->nth (j);
4992 double const w = i->line->time_converter().to ((*p->model())->when) + i->line->time_converter().origin_b ();
4994 /* see if it's inside a range */
4995 list<AudioRange>::const_iterator k = _ranges.begin ();
4996 while (k != _ranges.end() && (k->start >= w || k->end <= w)) {
5000 if (k != _ranges.end()) {
5001 /* dragging this point */
5002 _nothing_to_drag = false;
5003 i->points.push_back (p);
5009 if (_nothing_to_drag) {
5013 for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
5014 i->line->start_drag_multiple (i->points, y_fraction (i->line, current_pointer_y()), i->state);
5019 AutomationRangeDrag::motion (GdkEvent*, bool /*first_move*/)
5021 if (_nothing_to_drag) {
5025 for (list<Line>::iterator l = _lines.begin(); l != _lines.end(); ++l) {
5026 float const f = y_fraction (l->line, current_pointer_y());
5027 /* we are ignoring x position for this drag, so we can just pass in anything */
5029 l->line->drag_motion (0, f, true, false, ignored);
5030 show_verbose_cursor_text (l->line->get_verbose_cursor_relative_string (l->original_fraction, f));
5035 AutomationRangeDrag::finished (GdkEvent* event, bool)
5037 if (_nothing_to_drag) {
5041 motion (event, false);
5042 for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
5043 i->line->end_drag (false, 0);
5046 _editor->session()->commit_reversible_command ();
5050 AutomationRangeDrag::aborted (bool)
5052 for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
5057 DraggingView::DraggingView (RegionView* v, RegionDrag* parent, TimeAxisView* itav)
5059 , initial_time_axis_view (itav)
5061 /* note that time_axis_view may be null if the regionview was created
5062 * as part of a copy operation.
5064 time_axis_view = parent->find_time_axis_view (&v->get_time_axis_view ());
5065 layer = v->region()->layer ();
5066 initial_y = v->get_canvas_group()->position().y;
5067 initial_playlist = v->region()->playlist ();
5068 initial_position = v->region()->position ();
5069 initial_end = v->region()->position () + v->region()->length ();
5072 PatchChangeDrag::PatchChangeDrag (Editor* e, PatchChange* i, MidiRegionView* r)
5073 : Drag (e, i->canvas_item ())
5076 , _cumulative_dx (0)
5078 DEBUG_TRACE (DEBUG::Drags, string_compose ("New PatchChangeDrag, patch @ %1, grab @ %2\n",
5079 _region_view->source_beats_to_absolute_frames (_patch_change->patch()->time()),
5084 PatchChangeDrag::motion (GdkEvent* ev, bool)
5086 framepos_t f = adjusted_current_frame (ev);
5087 boost::shared_ptr<Region> r = _region_view->region ();
5088 f = max (f, r->position ());
5089 f = min (f, r->last_frame ());
5091 framecnt_t const dxf = f - grab_frame(); // permitted dx in frames
5092 double const dxu = _editor->sample_to_pixel (dxf); // permitted fx in units
5093 _patch_change->move (ArdourCanvas::Duple (dxu - _cumulative_dx, 0));
5094 _cumulative_dx = dxu;
5098 PatchChangeDrag::finished (GdkEvent* ev, bool movement_occurred)
5100 if (!movement_occurred) {
5104 boost::shared_ptr<Region> r (_region_view->region ());
5105 framepos_t f = adjusted_current_frame (ev);
5106 f = max (f, r->position ());
5107 f = min (f, r->last_frame ());
5109 _region_view->move_patch_change (
5111 _region_view->region_frames_to_region_beats (f - (r->position() - r->start()))
5116 PatchChangeDrag::aborted (bool)
5118 _patch_change->move (ArdourCanvas::Duple (-_cumulative_dx, 0));
5122 PatchChangeDrag::setup_pointer_frame_offset ()
5124 boost::shared_ptr<Region> region = _region_view->region ();
5125 _pointer_frame_offset = raw_grab_frame() - _region_view->source_beats_to_absolute_frames (_patch_change->patch()->time());
5128 MidiRubberbandSelectDrag::MidiRubberbandSelectDrag (Editor* e, MidiRegionView* rv)
5129 : RubberbandSelectDrag (e, rv->get_canvas_group ())
5136 MidiRubberbandSelectDrag::select_things (int button_state, framepos_t x1, framepos_t x2, double y1, double y2, bool /*drag_in_progress*/)
5138 _region_view->update_drag_selection (
5140 Keyboard::modifier_state_contains (button_state, Keyboard::TertiaryModifier));
5144 MidiRubberbandSelectDrag::deselect_things ()
5149 MidiVerticalSelectDrag::MidiVerticalSelectDrag (Editor* e, MidiRegionView* rv)
5150 : RubberbandSelectDrag (e, rv->get_canvas_group ())
5153 _vertical_only = true;
5157 MidiVerticalSelectDrag::select_things (int button_state, framepos_t /*x1*/, framepos_t /*x2*/, double y1, double y2, bool /*drag_in_progress*/)
5159 double const y = _region_view->midi_view()->y_position ();
5161 y1 = max (0.0, y1 - y);
5162 y2 = max (0.0, y2 - y);
5164 _region_view->update_vertical_drag_selection (
5167 Keyboard::modifier_state_contains (button_state, Keyboard::TertiaryModifier)
5172 MidiVerticalSelectDrag::deselect_things ()
5177 EditorRubberbandSelectDrag::EditorRubberbandSelectDrag (Editor* e, ArdourCanvas::Item* i)
5178 : RubberbandSelectDrag (e, i)
5184 EditorRubberbandSelectDrag::select_things (int button_state, framepos_t x1, framepos_t x2, double y1, double y2, bool drag_in_progress)
5186 if (drag_in_progress) {
5187 /* We just want to select things at the end of the drag, not during it */
5191 Selection::Operation op = ArdourKeyboard::selection_type (button_state);
5193 _editor->begin_reversible_command (_("rubberband selection"));
5194 _editor->select_all_within (x1, x2 - 1, y1, y2, _editor->track_views, op, false);
5195 _editor->commit_reversible_command ();
5199 EditorRubberbandSelectDrag::deselect_things ()
5201 if (!getenv("ARDOUR_SAE")) {
5202 _editor->selection->clear_tracks();
5204 _editor->selection->clear_regions();
5205 _editor->selection->clear_points ();
5206 _editor->selection->clear_lines ();
5209 NoteCreateDrag::NoteCreateDrag (Editor* e, ArdourCanvas::Item* i, MidiRegionView* rv)
5217 NoteCreateDrag::~NoteCreateDrag ()
5223 NoteCreateDrag::grid_frames (framepos_t t) const
5226 Evoral::MusicalTime grid_beats = _editor->get_grid_type_as_beats (success, t);
5228 grid_beats = Evoral::MusicalTime(1);
5231 return _region_view->region_beats_to_region_frames (grid_beats);
5235 NoteCreateDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
5237 Drag::start_grab (event, cursor);
5239 _drag_rect = new ArdourCanvas::Rectangle (_region_view->get_canvas_group ());
5241 framepos_t pf = _drags->current_pointer_frame ();
5242 framecnt_t const g = grid_frames (pf);
5244 /* Hack so that we always snap to the note that we are over, instead of snapping
5245 to the next one if we're more than halfway through the one we're over.
5247 if (_editor->snap_mode() == SnapNormal && pf > g / 2) {
5251 _note[0] = adjusted_frame (pf, event) - _region_view->region()->position ();
5253 MidiStreamView* sv = _region_view->midi_stream_view ();
5254 double const x = _editor->sample_to_pixel (_note[0]);
5255 double const y = sv->note_to_y (sv->y_to_note (y_to_region (event->button.y)));
5257 _drag_rect->set (ArdourCanvas::Rect (x, y, x, y + floor (_region_view->midi_stream_view()->note_height ())));
5258 _drag_rect->set_outline_all ();
5259 _drag_rect->set_outline_color (0xffffff99);
5260 _drag_rect->set_fill_color (0xffffff66);
5264 NoteCreateDrag::motion (GdkEvent* event, bool)
5266 _note[1] = max ((framepos_t)0, adjusted_current_frame (event) - _region_view->region()->position ());
5267 double const x0 = _editor->sample_to_pixel (_note[0]);
5268 double const x1 = _editor->sample_to_pixel (_note[1]);
5269 _drag_rect->set_x0 (std::min(x0, x1));
5270 _drag_rect->set_x1 (std::max(x0, x1));
5274 NoteCreateDrag::finished (GdkEvent*, bool had_movement)
5276 if (!had_movement) {
5280 framepos_t const start = min (_note[0], _note[1]);
5281 framecnt_t length = (framecnt_t) fabs ((double)(_note[0] - _note[1]));
5283 framecnt_t const g = grid_frames (start);
5284 Evoral::MusicalTime const one_tick = Evoral::MusicalTime::ticks(1);
5286 if (_editor->snap_mode() == SnapNormal && length < g) {
5290 Evoral::MusicalTime length_beats = max (
5291 one_tick, _region_view->region_frames_to_region_beats (length) - one_tick);
5293 _region_view->create_note_at (start, _drag_rect->y0(), length_beats, false);
5297 NoteCreateDrag::y_to_region (double y) const
5300 _region_view->get_canvas_group()->canvas_to_item (x, y);
5305 NoteCreateDrag::aborted (bool)
5310 CrossfadeEdgeDrag::CrossfadeEdgeDrag (Editor* e, AudioRegionView* rv, ArdourCanvas::Item* i, bool start_yn)
5315 std::cout << ("CrossfadeEdgeDrag is DEPRECATED. See TrimDrag::preserve_fade_anchor") << endl;
5319 CrossfadeEdgeDrag::start_grab (GdkEvent* event, Gdk::Cursor *cursor)
5321 Drag::start_grab (event, cursor);
5325 CrossfadeEdgeDrag::motion (GdkEvent*, bool)
5331 boost::shared_ptr<AudioRegion> ar (arv->audio_region());
5334 distance = _drags->current_pointer_x() - grab_x();
5335 len = ar->fade_in()->back()->when;
5337 distance = grab_x() - _drags->current_pointer_x();
5338 len = ar->fade_out()->back()->when;
5341 /* how long should it be ? */
5343 new_length = len + _editor->pixel_to_sample (distance);
5345 /* now check with the region that this is legal */
5347 new_length = ar->verify_xfade_bounds (new_length, start);
5350 arv->reset_fade_in_shape_width (ar, new_length);
5352 arv->reset_fade_out_shape_width (ar, new_length);
5357 CrossfadeEdgeDrag::finished (GdkEvent*, bool)
5363 boost::shared_ptr<AudioRegion> ar (arv->audio_region());
5366 distance = _drags->current_pointer_x() - grab_x();
5367 len = ar->fade_in()->back()->when;
5369 distance = grab_x() - _drags->current_pointer_x();
5370 len = ar->fade_out()->back()->when;
5373 new_length = ar->verify_xfade_bounds (len + _editor->pixel_to_sample (distance), start);
5375 _editor->begin_reversible_command ("xfade trim");
5376 ar->playlist()->clear_owned_changes ();
5379 ar->set_fade_in_length (new_length);
5381 ar->set_fade_out_length (new_length);
5384 /* Adjusting the xfade may affect other regions in the playlist, so we need
5385 to get undo Commands from the whole playlist rather than just the
5389 vector<Command*> cmds;
5390 ar->playlist()->rdiff (cmds);
5391 _editor->session()->add_commands (cmds);
5392 _editor->commit_reversible_command ();
5397 CrossfadeEdgeDrag::aborted (bool)
5400 arv->redraw_start_xfade ();
5402 arv->redraw_end_xfade ();
5406 RegionCutDrag::RegionCutDrag (Editor* e, ArdourCanvas::Item* item, framepos_t pos)
5407 : Drag (e, item, true)
5408 , line (new EditorCursor (*e))
5410 line->set_position (pos);
5414 RegionCutDrag::~RegionCutDrag ()
5420 RegionCutDrag::motion (GdkEvent*, bool)
5422 framepos_t where = _drags->current_pointer_frame();
5423 _editor->snap_to (where);
5425 line->set_position (where);
5429 RegionCutDrag::finished (GdkEvent*, bool)
5431 _editor->get_track_canvas()->canvas()->re_enter();
5433 framepos_t pos = _drags->current_pointer_frame();
5437 RegionSelection rs = _editor->get_regions_from_selection_and_mouse (pos);
5443 _editor->split_regions_at (pos, rs);
5447 RegionCutDrag::aborted (bool)