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"
26 #include "pbd/memento_command.h"
27 #include "pbd/basename.h"
28 #include "pbd/stateful_diff_command.h"
30 #include "gtkmm2ext/utils.h"
32 #include "ardour/audioengine.h"
33 #include "ardour/audioregion.h"
34 #include "ardour/dB.h"
35 #include "ardour/midi_region.h"
36 #include "ardour/operations.h"
37 #include "ardour/region_factory.h"
38 #include "ardour/session.h"
43 #include "audio_region_view.h"
44 #include "midi_region_view.h"
45 #include "ardour_ui.h"
46 #include "gui_thread.h"
47 #include "control_point.h"
49 #include "region_gain_line.h"
50 #include "editor_drag.h"
51 #include "audio_time_axis.h"
52 #include "midi_time_axis.h"
53 #include "canvas-note.h"
54 #include "selection.h"
55 #include "midi_selection.h"
56 #include "automation_time_axis.h"
58 #include "editor_cursors.h"
59 #include "mouse_cursors.h"
60 #include "verbose_cursor.h"
63 using namespace ARDOUR;
66 using namespace Gtkmm2ext;
67 using namespace Editing;
68 using namespace ArdourCanvas;
70 using Gtkmm2ext::Keyboard;
72 double ControlPointDrag::_zero_gain_fraction = -1.0;
74 DragManager::DragManager (Editor* e)
77 , _current_pointer_frame (0)
81 DragManager::~DragManager ()
86 /** Call abort for each active drag */
92 for (list<Drag*>::const_iterator i = _drags.begin(); i != _drags.end(); ++i) {
97 if (!_drags.empty ()) {
98 _editor->set_follow_playhead (_old_follow_playhead, false);
107 DragManager::add (Drag* d)
109 d->set_manager (this);
110 _drags.push_back (d);
114 DragManager::set (Drag* d, GdkEvent* e, Gdk::Cursor* c)
116 d->set_manager (this);
117 _drags.push_back (d);
122 DragManager::start_grab (GdkEvent* e, Gdk::Cursor* c)
124 /* Prevent follow playhead during the drag to be nice to the user */
125 _old_follow_playhead = _editor->follow_playhead ();
126 _editor->set_follow_playhead (false);
128 _current_pointer_frame = _editor->event_frame (e, &_current_pointer_x, &_current_pointer_y);
130 for (list<Drag*>::const_iterator i = _drags.begin(); i != _drags.end(); ++i) {
131 (*i)->start_grab (e, c);
135 /** Call end_grab for each active drag.
136 * @return true if any drag reported movement having occurred.
139 DragManager::end_grab (GdkEvent* e)
144 for (list<Drag*>::iterator i = _drags.begin(); i != _drags.end(); ++i) {
145 bool const t = (*i)->end_grab (e);
156 _editor->set_follow_playhead (_old_follow_playhead, false);
162 DragManager::motion_handler (GdkEvent* e, bool from_autoscroll)
166 _current_pointer_frame = _editor->event_frame (e, &_current_pointer_x, &_current_pointer_y);
168 for (list<Drag*>::iterator i = _drags.begin(); i != _drags.end(); ++i) {
169 bool const t = (*i)->motion_handler (e, from_autoscroll);
180 DragManager::have_item (ArdourCanvas::Item* i) const
182 list<Drag*>::const_iterator j = _drags.begin ();
183 while (j != _drags.end() && (*j)->item () != i) {
187 return j != _drags.end ();
190 Drag::Drag (Editor* e, ArdourCanvas::Item* i)
193 , _pointer_frame_offset (0)
194 , _move_threshold_passed (false)
195 , _raw_grab_frame (0)
197 , _last_pointer_frame (0)
203 Drag::swap_grab (ArdourCanvas::Item* new_item, Gdk::Cursor* cursor, uint32_t time)
209 _item->grab (Gdk::POINTER_MOTION_MASK | Gdk::BUTTON_PRESS_MASK | Gdk::BUTTON_RELEASE_MASK, time);
211 _item->grab (Gdk::POINTER_MOTION_MASK | Gdk::BUTTON_PRESS_MASK | Gdk::BUTTON_RELEASE_MASK, *cursor, time);
216 Drag::start_grab (GdkEvent* event, Gdk::Cursor *cursor)
218 // if dragging with button2, the motion is x constrained, with Alt-button2 it is y constrained
220 if (Keyboard::is_button2_event (&event->button)) {
221 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::SecondaryModifier)) {
222 _y_constrained = true;
223 _x_constrained = false;
225 _y_constrained = false;
226 _x_constrained = true;
229 _x_constrained = false;
230 _y_constrained = false;
233 _raw_grab_frame = _editor->event_frame (event, &_grab_x, &_grab_y);
234 setup_pointer_frame_offset ();
235 _grab_frame = adjusted_frame (_raw_grab_frame, event);
236 _last_pointer_frame = _grab_frame;
237 _last_pointer_x = _grab_x;
238 _last_pointer_y = _grab_y;
241 _item->grab (Gdk::POINTER_MOTION_MASK|Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK,
244 _item->grab (Gdk::POINTER_MOTION_MASK|Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK,
249 if (_editor->session() && _editor->session()->transport_rolling()) {
252 _was_rolling = false;
255 switch (_editor->snap_type()) {
256 case SnapToRegionStart:
257 case SnapToRegionEnd:
258 case SnapToRegionSync:
259 case SnapToRegionBoundary:
260 _editor->build_region_boundary_cache ();
267 /** Call to end a drag `successfully'. Ungrabs item and calls
268 * subclass' finished() method.
270 * @param event GDK event, or 0.
271 * @return true if some movement occurred, otherwise false.
274 Drag::end_grab (GdkEvent* event)
276 _editor->stop_canvas_autoscroll ();
278 _item->ungrab (event ? event->button.time : 0);
280 finished (event, _move_threshold_passed);
282 _editor->verbose_cursor()->hide ();
284 return _move_threshold_passed;
288 Drag::adjusted_frame (framepos_t f, GdkEvent const * event, bool snap) const
292 if (f > _pointer_frame_offset) {
293 pos = f - _pointer_frame_offset;
297 _editor->snap_to_with_modifier (pos, event);
304 Drag::adjusted_current_frame (GdkEvent const * event, bool snap) const
306 return adjusted_frame (_drags->current_pointer_frame (), event, snap);
310 Drag::motion_handler (GdkEvent* event, bool from_autoscroll)
312 /* check to see if we have moved in any way that matters since the last motion event */
313 if (_move_threshold_passed &&
314 (!x_movement_matters() || _last_pointer_frame == adjusted_current_frame (event)) &&
315 (!y_movement_matters() || _last_pointer_y == _drags->current_pointer_y ()) ) {
319 pair<framecnt_t, int> const threshold = move_threshold ();
321 bool const old_move_threshold_passed = _move_threshold_passed;
323 if (!from_autoscroll && !_move_threshold_passed) {
325 bool const xp = (::llabs (_drags->current_pointer_frame () - _raw_grab_frame) >= threshold.first);
326 bool const yp = (::fabs ((_drags->current_pointer_y () - _grab_y)) >= threshold.second);
328 _move_threshold_passed = ((xp && x_movement_matters()) || (yp && y_movement_matters()));
331 if (active (_editor->mouse_mode) && _move_threshold_passed) {
333 if (event->motion.state & Gdk::BUTTON1_MASK || event->motion.state & Gdk::BUTTON2_MASK) {
334 if (!from_autoscroll) {
335 bool const moving_left = _drags->current_pointer_x() < _last_pointer_x;
336 bool const moving_up = _drags->current_pointer_y() < _last_pointer_y;
337 _editor->maybe_autoscroll (true, allow_vertical_autoscroll (), moving_left, moving_up);
340 motion (event, _move_threshold_passed != old_move_threshold_passed);
342 _last_pointer_x = _drags->current_pointer_x ();
343 _last_pointer_y = _drags->current_pointer_y ();
344 _last_pointer_frame = adjusted_current_frame (event);
352 /** Call to abort a drag. Ungrabs item and calls subclass's aborted () */
360 aborted (_move_threshold_passed);
362 _editor->stop_canvas_autoscroll ();
363 _editor->verbose_cursor()->hide ();
367 Drag::show_verbose_cursor_time (framepos_t frame)
369 _editor->verbose_cursor()->set_time (
371 _drags->current_pointer_x() + 10 - _editor->horizontal_position(),
372 _drags->current_pointer_y() + 10 - _editor->vertical_adjustment.get_value() + _editor->canvas_timebars_vsize
375 _editor->verbose_cursor()->show ();
379 Drag::show_verbose_cursor_duration (framepos_t start, framepos_t end, double xoffset)
381 _editor->verbose_cursor()->show (xoffset);
383 _editor->verbose_cursor()->set_duration (
385 _drags->current_pointer_x() + 10 - _editor->horizontal_position(),
386 _drags->current_pointer_y() + 10 - _editor->vertical_adjustment.get_value() + _editor->canvas_timebars_vsize
391 Drag::show_verbose_cursor_text (string const & text)
393 _editor->verbose_cursor()->show ();
395 _editor->verbose_cursor()->set (
397 _drags->current_pointer_x() + 10 - _editor->horizontal_position(),
398 _drags->current_pointer_y() + 10 - _editor->vertical_adjustment.get_value() + _editor->canvas_timebars_vsize
402 boost::shared_ptr<Region>
403 Drag::add_midi_region (MidiTimeAxisView* view)
405 if (_editor->session()) {
406 const TempoMap& map (_editor->session()->tempo_map());
407 framecnt_t pos = grab_frame();
408 const Meter& m = map.meter_at (pos);
409 /* not that the frame rate used here can be affected by pull up/down which
412 framecnt_t len = m.frames_per_bar (map.tempo_at (pos), _editor->session()->frame_rate());
413 return view->add_region (grab_frame(), len, true);
416 return boost::shared_ptr<Region>();
419 struct EditorOrderTimeAxisViewSorter {
420 bool operator() (TimeAxisView* a, TimeAxisView* b) {
421 RouteTimeAxisView* ra = dynamic_cast<RouteTimeAxisView*> (a);
422 RouteTimeAxisView* rb = dynamic_cast<RouteTimeAxisView*> (b);
424 return ra->route()->order_key (EditorSort) < rb->route()->order_key (EditorSort);
428 RegionDrag::RegionDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v)
432 _editor->visible_order_range (&_visible_y_low, &_visible_y_high);
434 /* Make a list of tracks to refer to during the drag; we include hidden tracks,
435 as some of the regions we are dragging may be on such tracks.
438 TrackViewList track_views = _editor->track_views;
439 track_views.sort (EditorOrderTimeAxisViewSorter ());
441 for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
442 _time_axis_views.push_back (*i);
444 TimeAxisView::Children children_list = (*i)->get_child_list ();
445 for (TimeAxisView::Children::iterator j = children_list.begin(); j != children_list.end(); ++j) {
446 _time_axis_views.push_back (j->get());
450 /* the list of views can be empty at this point if this is a region list-insert drag
453 for (list<RegionView*>::const_iterator i = v.begin(); i != v.end(); ++i) {
454 _views.push_back (DraggingView (*i, this));
457 RegionView::RegionViewGoingAway.connect (death_connection, invalidator (*this), boost::bind (&RegionDrag::region_going_away, this, _1), gui_context());
461 RegionDrag::region_going_away (RegionView* v)
463 list<DraggingView>::iterator i = _views.begin ();
464 while (i != _views.end() && i->view != v) {
468 if (i != _views.end()) {
473 /** Given a TimeAxisView, return the index of it into the _time_axis_views vector,
474 * or -1 if it is not found.
477 RegionDrag::find_time_axis_view (TimeAxisView* t) const
480 int const N = _time_axis_views.size ();
481 while (i < N && _time_axis_views[i] != t) {
492 RegionMotionDrag::RegionMotionDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v, bool b)
493 : RegionDrag (e, i, p, v),
502 RegionMotionDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
504 Drag::start_grab (event, cursor);
506 show_verbose_cursor_time (_last_frame_position);
508 pair<TimeAxisView*, double> const tv = _editor->trackview_by_y_position (_drags->current_pointer_y ());
509 _last_pointer_time_axis_view = find_time_axis_view (tv.first);
510 _last_pointer_layer = tv.first->layer_display() == Overlaid ? 0 : tv.second;
514 RegionMotionDrag::compute_x_delta (GdkEvent const * event, framepos_t* pending_region_position)
516 /* compute the amount of pointer motion in frames, and where
517 the region would be if we moved it by that much.
519 *pending_region_position = adjusted_current_frame (event);
521 framepos_t sync_frame;
522 framecnt_t sync_offset;
525 sync_offset = _primary->region()->sync_offset (sync_dir);
527 /* we don't handle a sync point that lies before zero.
529 if (sync_dir >= 0 || (sync_dir < 0 && *pending_region_position >= sync_offset)) {
531 sync_frame = *pending_region_position + (sync_dir*sync_offset);
533 _editor->snap_to_with_modifier (sync_frame, event);
535 *pending_region_position = _primary->region()->adjust_to_sync (sync_frame);
538 *pending_region_position = _last_frame_position;
541 if (*pending_region_position > max_framepos - _primary->region()->length()) {
542 *pending_region_position = _last_frame_position;
547 /* in locked edit mode, reverse the usual meaning of _x_constrained */
548 bool const x_move_allowed = Config->get_edit_mode() == Lock ? _x_constrained : !_x_constrained;
550 if ((*pending_region_position != _last_frame_position) && x_move_allowed) {
552 /* x movement since last time (in pixels) */
553 dx = (static_cast<double> (*pending_region_position) - _last_frame_position) / _editor->frames_per_unit;
555 /* total x movement */
556 framecnt_t total_dx = *pending_region_position;
557 if (regions_came_from_canvas()) {
558 total_dx = total_dx - grab_frame ();
561 /* check that no regions have gone off the start of the session */
562 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
563 if ((i->view->region()->position() + total_dx) < 0) {
565 *pending_region_position = _last_frame_position;
570 _last_frame_position = *pending_region_position;
577 RegionMotionDrag::y_movement_allowed (int delta_track, double delta_layer) const
579 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
580 int const n = i->time_axis_view + delta_track;
581 if (n < 0 || n >= int (_time_axis_views.size())) {
582 /* off the top or bottom track */
586 RouteTimeAxisView const * to = dynamic_cast<RouteTimeAxisView const *> (_time_axis_views[n]);
587 if (to == 0 || !to->is_track() || to->track()->data_type() != i->view->region()->data_type()) {
588 /* not a track, or the wrong type */
592 double const l = i->layer + delta_layer;
594 /* Note that we allow layer to be up to 0.5 below zero, as this is used by `Expanded'
595 mode to allow the user to place a region below another on layer 0.
597 if (delta_track == 0 && (l < -0.5 || l >= int (to->view()->layers()))) {
598 /* Off the top or bottom layer; note that we only refuse if the track hasn't changed.
599 If it has, the layers will be munged later anyway, so it's ok.
605 /* all regions being dragged are ok with this change */
610 RegionMotionDrag::motion (GdkEvent* event, bool first_move)
612 assert (!_views.empty ());
614 /* Find the TimeAxisView that the pointer is now over */
615 pair<TimeAxisView*, double> const tv = _editor->trackview_by_y_position (_drags->current_pointer_y ());
617 if (first_move && tv.first->view()->layer_display() == Stacked) {
618 tv.first->view()->set_layer_display (Expanded);
621 /* Bail early if we're not over a track */
622 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tv.first);
623 if (!rtv || !rtv->is_track()) {
624 _editor->verbose_cursor()->hide ();
628 /* Note: time axis views in this method are often expressed as an index into the _time_axis_views vector */
630 /* Here's the current pointer position in terms of time axis view and layer */
631 int const current_pointer_time_axis_view = find_time_axis_view (tv.first);
632 double const current_pointer_layer = tv.first->layer_display() == Overlaid ? 0 : tv.second;
634 /* Work out the change in x */
635 framepos_t pending_region_position;
636 double const x_delta = compute_x_delta (event, &pending_region_position);
638 /* Work out the change in y */
639 int delta_time_axis_view = current_pointer_time_axis_view - _last_pointer_time_axis_view;
640 double delta_layer = current_pointer_layer - _last_pointer_layer;
642 if (!y_movement_allowed (delta_time_axis_view, delta_layer)) {
643 /* this y movement is not allowed, so do no y movement this time */
644 delta_time_axis_view = 0;
648 if (x_delta == 0 && delta_time_axis_view == 0 && delta_layer == 0 && !first_move) {
649 /* haven't reached next snap point, and we're not switching
650 trackviews nor layers. nothing to do.
655 pair<set<boost::shared_ptr<Playlist> >::iterator,bool> insert_result;
657 for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
659 RegionView* rv = i->view;
661 if (rv->region()->locked()) {
669 /* Absolutely no idea why this is necessary, but it is; without
670 it, the region view disappears after the reparent.
672 _editor->update_canvas_now ();
674 /* Reparent to a non scrolling group so that we can keep the
675 region selection above all time axis views.
676 Reparenting means that we will have to move the region view
677 later, as the two parent groups have different coordinates.
680 rv->get_canvas_group()->reparent (*(_editor->_region_motion_group));
682 rv->fake_set_opaque (true);
685 /* If we have moved tracks, we'll fudge the layer delta so that the
686 region gets moved back onto layer 0 on its new track; this avoids
687 confusion when dragging regions from non-zero layers onto different
690 double this_delta_layer = delta_layer;
691 if (delta_time_axis_view != 0) {
692 this_delta_layer = - i->layer;
695 /* The TimeAxisView that this region is now on */
696 TimeAxisView* tv = _time_axis_views[i->time_axis_view + delta_time_axis_view];
698 /* Ensure it is moved from stacked -> expanded if appropriate */
699 if (tv->view()->layer_display() == Stacked) {
700 tv->view()->set_layer_display (Expanded);
703 /* We're only allowed to go -ve in layer on Expanded views */
704 if (tv->view()->layer_display() != Expanded && (i->layer + this_delta_layer) < 0) {
705 this_delta_layer = - i->layer;
709 rv->set_height (tv->view()->child_height ());
711 /* Update show/hidden status as the region view may have come from a hidden track,
712 or have moved to one.
715 rv->get_canvas_group()->hide ();
717 rv->get_canvas_group()->show ();
720 /* Update the DraggingView */
721 i->time_axis_view += delta_time_axis_view;
722 i->layer += this_delta_layer;
725 _editor->mouse_brush_insert_region (rv, pending_region_position);
730 /* Get the y coordinate of the top of the track that this region is now on */
731 tv->canvas_display()->i2w (x, y);
732 y += _editor->get_trackview_group_vertical_offset();
734 /* And adjust for the layer that it should be on */
735 StreamView* cv = tv->view ();
736 switch (cv->layer_display ()) {
740 y += (cv->layers() - i->layer - 1) * cv->child_height ();
743 y += (cv->layers() - i->layer - 0.5) * 2 * cv->child_height ();
747 /* Now move the region view */
748 rv->move (x_delta, y - rv->get_canvas_group()->property_y());
751 } /* foreach region */
753 _total_x_delta += x_delta;
756 _editor->cursor_group->raise_to_top();
759 if (x_delta != 0 && !_brushing) {
760 show_verbose_cursor_time (_last_frame_position);
763 _last_pointer_time_axis_view += delta_time_axis_view;
764 _last_pointer_layer += delta_layer;
768 RegionMoveDrag::motion (GdkEvent* event, bool first_move)
770 if (_copy && first_move) {
772 /* duplicate the regionview(s) and region(s) */
774 list<DraggingView> new_regionviews;
776 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
778 RegionView* rv = i->view;
779 AudioRegionView* arv = dynamic_cast<AudioRegionView*>(rv);
780 MidiRegionView* mrv = dynamic_cast<MidiRegionView*>(rv);
782 const boost::shared_ptr<const Region> original = rv->region();
783 boost::shared_ptr<Region> region_copy = RegionFactory::create (original, true);
784 region_copy->set_position (original->position());
788 boost::shared_ptr<AudioRegion> audioregion_copy
789 = boost::dynamic_pointer_cast<AudioRegion>(region_copy);
791 nrv = new AudioRegionView (*arv, audioregion_copy);
793 boost::shared_ptr<MidiRegion> midiregion_copy
794 = boost::dynamic_pointer_cast<MidiRegion>(region_copy);
795 nrv = new MidiRegionView (*mrv, midiregion_copy);
800 nrv->get_canvas_group()->show ();
801 new_regionviews.push_back (DraggingView (nrv, this));
803 /* swap _primary to the copy */
805 if (rv == _primary) {
809 /* ..and deselect the one we copied */
811 rv->set_selected (false);
814 if (!new_regionviews.empty()) {
816 /* reflect the fact that we are dragging the copies */
818 _views = new_regionviews;
820 swap_grab (new_regionviews.front().view->get_canvas_group (), 0, event ? event->motion.time : 0);
823 sync the canvas to what we think is its current state
824 without it, the canvas seems to
825 "forget" to update properly after the upcoming reparent()
826 ..only if the mouse is in rapid motion at the time of the grab.
827 something to do with regionview creation taking so long?
829 _editor->update_canvas_now();
833 RegionMotionDrag::motion (event, first_move);
837 RegionMotionDrag::finished (GdkEvent *, bool)
839 for (vector<TimeAxisView*>::iterator i = _time_axis_views.begin(); i != _time_axis_views.end(); ++i) {
844 if ((*i)->view()->layer_display() == Expanded) {
845 (*i)->view()->set_layer_display (Stacked);
851 RegionMoveDrag::finished (GdkEvent* ev, bool movement_occurred)
853 RegionMotionDrag::finished (ev, movement_occurred);
855 if (!movement_occurred) {
860 /* reverse this here so that we have the correct logic to finalize
864 if (Config->get_edit_mode() == Lock) {
865 _x_constrained = !_x_constrained;
868 assert (!_views.empty ());
870 /* We might have hidden region views so that they weren't visible during the drag
871 (when they have been reparented). Now everything can be shown again, as region
872 views are back in their track parent groups.
874 for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
875 i->view->get_canvas_group()->show ();
878 bool const changed_position = (_last_frame_position != _primary->region()->position());
879 bool const changed_tracks = (_time_axis_views[_views.front().time_axis_view] != &_views.front().view->get_time_axis_view());
880 framecnt_t const drag_delta = _primary->region()->position() - _last_frame_position;
882 _editor->update_canvas_now ();
902 if (_editor->session() && Config->get_always_play_range()) {
903 _editor->session()->request_locate (_editor->get_selection().regions.start());
908 RegionMoveDrag::finished_copy (bool const changed_position, bool const /*changed_tracks*/, framecnt_t const drag_delta)
910 RegionSelection new_views;
911 PlaylistSet modified_playlists;
912 list<RegionView*> views_to_delete;
915 /* all changes were made during motion event handlers */
917 for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
921 _editor->commit_reversible_command ();
925 if (_x_constrained) {
926 _editor->begin_reversible_command (Operations::fixed_time_region_copy);
928 _editor->begin_reversible_command (Operations::region_copy);
931 /* insert the regions into their new playlists */
932 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
934 if (i->view->region()->locked()) {
940 if (changed_position && !_x_constrained) {
941 where = i->view->region()->position() - drag_delta;
943 where = i->view->region()->position();
946 RegionView* new_view = insert_region_into_playlist (
947 i->view->region(), dynamic_cast<RouteTimeAxisView*> (_time_axis_views[i->time_axis_view]), i->layer, where, modified_playlists
954 new_views.push_back (new_view);
956 /* we don't need the copied RegionView any more */
957 views_to_delete.push_back (i->view);
960 /* Delete views that are no longer needed; we can't do this directly in the iteration over _views
961 because when views are deleted they are automagically removed from _views, which messes
964 for (list<RegionView*>::iterator i = views_to_delete.begin(); i != views_to_delete.end(); ++i) {
968 /* If we've created new regions either by copying or moving
969 to a new track, we want to replace the old selection with the new ones
972 if (new_views.size() > 0) {
973 _editor->selection->set (new_views);
976 /* write commands for the accumulated diffs for all our modified playlists */
977 add_stateful_diff_commands_for_playlists (modified_playlists);
979 _editor->commit_reversible_command ();
983 RegionMoveDrag::finished_no_copy (
984 bool const changed_position,
985 bool const changed_tracks,
986 framecnt_t const drag_delta
989 RegionSelection new_views;
990 PlaylistSet modified_playlists;
991 PlaylistSet frozen_playlists;
992 set<RouteTimeAxisView*> views_to_update;
995 /* all changes were made during motion event handlers */
996 _editor->commit_reversible_command ();
1000 if (_x_constrained) {
1001 _editor->begin_reversible_command (_("fixed time region drag"));
1003 _editor->begin_reversible_command (Operations::region_drag);
1006 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ) {
1008 RegionView* rv = i->view;
1010 RouteTimeAxisView* const dest_rtv = dynamic_cast<RouteTimeAxisView*> (_time_axis_views[i->time_axis_view]);
1011 double const dest_layer = i->layer;
1013 if (rv->region()->locked()) {
1018 views_to_update.insert (dest_rtv);
1022 if (changed_position && !_x_constrained) {
1023 where = rv->region()->position() - drag_delta;
1025 where = rv->region()->position();
1028 if (changed_tracks) {
1030 /* insert into new playlist */
1032 RegionView* new_view = insert_region_into_playlist (
1033 RegionFactory::create (rv->region (), true), dest_rtv, dest_layer, where, modified_playlists
1036 if (new_view == 0) {
1041 new_views.push_back (new_view);
1043 /* remove from old playlist */
1045 /* the region that used to be in the old playlist is not
1046 moved to the new one - we use a copy of it. as a result,
1047 any existing editor for the region should no longer be
1050 rv->hide_region_editor();
1051 rv->fake_set_opaque (false);
1053 remove_region_from_playlist (rv->region(), i->initial_playlist, modified_playlists);
1057 rv->region()->clear_changes ();
1060 motion on the same track. plonk the previously reparented region
1061 back to its original canvas group (its streamview).
1062 No need to do anything for copies as they are fake regions which will be deleted.
1065 rv->get_canvas_group()->reparent (*dest_rtv->view()->canvas_item());
1066 rv->get_canvas_group()->property_y() = i->initial_y;
1069 /* just change the model */
1071 boost::shared_ptr<Playlist> playlist = dest_rtv->playlist();
1073 if (dest_rtv->view()->layer_display() == Stacked || dest_rtv->view()->layer_display() == Expanded) {
1074 playlist->set_layer (rv->region(), dest_layer);
1077 /* freeze playlist to avoid lots of relayering in the case of a multi-region drag */
1079 pair<PlaylistSet::iterator, bool> r = frozen_playlists.insert (playlist);
1082 playlist->freeze ();
1085 /* this movement may result in a crossfade being modified, so we need to get undo
1086 data from the playlist as well as the region.
1089 r = modified_playlists.insert (playlist);
1091 playlist->clear_changes ();
1094 rv->region()->set_position (where);
1096 _editor->session()->add_command (new StatefulDiffCommand (rv->region()));
1099 if (changed_tracks) {
1101 /* OK, this is where it gets tricky. If the playlist was being used by >1 tracks, and the region
1102 was selected in all of them, then removing it from a playlist will have removed all
1103 trace of it from _views (i.e. there were N regions selected, we removed 1,
1104 but since its the same playlist for N tracks, all N tracks updated themselves, removed the
1105 corresponding regionview, and _views is now empty).
1107 This could have invalidated any and all iterators into _views.
1109 The heuristic we use here is: if the region selection is empty, break out of the loop
1110 here. if the region selection is not empty, then restart the loop because we know that
1111 we must have removed at least the region(view) we've just been working on as well as any
1112 that we processed on previous iterations.
1114 EXCEPT .... if we are doing a copy drag, then _views hasn't been modified and
1115 we can just iterate.
1119 if (_views.empty()) {
1130 /* If we've created new regions either by copying or moving
1131 to a new track, we want to replace the old selection with the new ones
1134 if (new_views.size() > 0) {
1135 _editor->selection->set (new_views);
1138 for (set<boost::shared_ptr<Playlist> >::iterator p = frozen_playlists.begin(); p != frozen_playlists.end(); ++p) {
1142 /* write commands for the accumulated diffs for all our modified playlists */
1143 add_stateful_diff_commands_for_playlists (modified_playlists);
1145 _editor->commit_reversible_command ();
1147 /* We have futzed with the layering of canvas items on our streamviews.
1148 If any region changed layer, this will have resulted in the stream
1149 views being asked to set up their region views, and all will be well.
1150 If not, we might now have badly-ordered region views. Ask the StreamViews
1151 involved to sort themselves out, just in case.
1154 for (set<RouteTimeAxisView*>::iterator i = views_to_update.begin(); i != views_to_update.end(); ++i) {
1155 (*i)->view()->playlist_layered ((*i)->track ());
1159 /** Remove a region from a playlist, clearing the diff history of the playlist first if necessary.
1160 * @param region Region to remove.
1161 * @param playlist playlist To remove from.
1162 * @param modified_playlists The playlist will be added to this if it is not there already; used to ensure
1163 * that clear_changes () is only called once per playlist.
1166 RegionMoveDrag::remove_region_from_playlist (
1167 boost::shared_ptr<Region> region,
1168 boost::shared_ptr<Playlist> playlist,
1169 PlaylistSet& modified_playlists
1172 pair<set<boost::shared_ptr<Playlist> >::iterator, bool> r = modified_playlists.insert (playlist);
1175 playlist->clear_changes ();
1178 playlist->remove_region (region);
1182 /** Insert a region into a playlist, handling the recovery of the resulting new RegionView, and
1183 * clearing the playlist's diff history first if necessary.
1184 * @param region Region to insert.
1185 * @param dest_rtv Destination RouteTimeAxisView.
1186 * @param dest_layer Destination layer.
1187 * @param where Destination position.
1188 * @param modified_playlists The playlist will be added to this if it is not there already; used to ensure
1189 * that clear_changes () is only called once per playlist.
1190 * @return New RegionView, or 0 if no insert was performed.
1193 RegionMoveDrag::insert_region_into_playlist (
1194 boost::shared_ptr<Region> region,
1195 RouteTimeAxisView* dest_rtv,
1198 PlaylistSet& modified_playlists
1201 boost::shared_ptr<Playlist> dest_playlist = dest_rtv->playlist ();
1202 if (!dest_playlist) {
1206 /* arrange to collect the new region view that will be created as a result of our playlist insertion */
1207 _new_region_view = 0;
1208 sigc::connection c = dest_rtv->view()->RegionViewAdded.connect (sigc::mem_fun (*this, &RegionMoveDrag::collect_new_region_view));
1210 /* clear history for the playlist we are about to insert to, provided we haven't already done so */
1211 pair<PlaylistSet::iterator, bool> r = modified_playlists.insert (dest_playlist);
1213 dest_playlist->clear_changes ();
1216 dest_playlist->add_region (region, where);
1218 if (dest_rtv->view()->layer_display() == Stacked || dest_rtv->view()->layer_display() == Expanded) {
1219 dest_playlist->set_layer (region, dest_layer);
1224 assert (_new_region_view);
1226 return _new_region_view;
1230 RegionMoveDrag::collect_new_region_view (RegionView* rv)
1232 _new_region_view = rv;
1236 RegionMoveDrag::add_stateful_diff_commands_for_playlists (PlaylistSet const & playlists)
1238 for (PlaylistSet::const_iterator i = playlists.begin(); i != playlists.end(); ++i) {
1239 StatefulDiffCommand* c = new StatefulDiffCommand (*i);
1241 _editor->session()->add_command (c);
1250 RegionMoveDrag::aborted (bool movement_occurred)
1254 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
1261 RegionMotionDrag::aborted (movement_occurred);
1266 RegionMotionDrag::aborted (bool)
1268 for (vector<TimeAxisView*>::iterator i = _time_axis_views.begin(); i != _time_axis_views.end(); ++i) {
1269 if ((*i)->view()->layer_display() == Expanded) {
1270 (*i)->view()->set_layer_display (Stacked);
1274 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
1275 RegionView* rv = i->view;
1276 TimeAxisView* tv = &(rv->get_time_axis_view ());
1277 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tv);
1279 rv->get_canvas_group()->reparent (*rtv->view()->canvas_item());
1280 rv->get_canvas_group()->property_y() = 0;
1282 rv->fake_set_opaque (false);
1283 rv->move (-_total_x_delta, 0);
1284 rv->set_height (rtv->view()->child_height ());
1287 _editor->update_canvas_now ();
1290 /** @param b true to brush, otherwise false.
1291 * @param c true to make copies of the regions being moved, otherwise false.
1293 RegionMoveDrag::RegionMoveDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v, bool b, bool c)
1294 : RegionMotionDrag (e, i, p, v, b),
1297 DEBUG_TRACE (DEBUG::Drags, "New RegionMoveDrag\n");
1300 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (&_primary->get_time_axis_view ());
1301 if (rtv && rtv->is_track()) {
1302 speed = rtv->track()->speed ();
1305 _last_frame_position = static_cast<framepos_t> (_primary->region()->position() / speed);
1309 RegionMoveDrag::setup_pointer_frame_offset ()
1311 _pointer_frame_offset = raw_grab_frame() - _last_frame_position;
1314 RegionInsertDrag::RegionInsertDrag (Editor* e, boost::shared_ptr<Region> r, RouteTimeAxisView* v, framepos_t pos)
1315 : RegionMotionDrag (e, 0, 0, list<RegionView*> (), false)
1317 DEBUG_TRACE (DEBUG::Drags, "New RegionInsertDrag\n");
1319 assert ((boost::dynamic_pointer_cast<AudioRegion> (r) && dynamic_cast<AudioTimeAxisView*> (v)) ||
1320 (boost::dynamic_pointer_cast<MidiRegion> (r) && dynamic_cast<MidiTimeAxisView*> (v)));
1322 _primary = v->view()->create_region_view (r, false, false);
1324 _primary->get_canvas_group()->show ();
1325 _primary->set_position (pos, 0);
1326 _views.push_back (DraggingView (_primary, this));
1328 _last_frame_position = pos;
1330 _item = _primary->get_canvas_group ();
1334 RegionInsertDrag::finished (GdkEvent *, bool)
1336 _editor->update_canvas_now ();
1338 RouteTimeAxisView* dest_rtv = dynamic_cast<RouteTimeAxisView*> (_time_axis_views[_views.front().time_axis_view]);
1340 _primary->get_canvas_group()->reparent (*dest_rtv->view()->canvas_item());
1341 _primary->get_canvas_group()->property_y() = 0;
1343 boost::shared_ptr<Playlist> playlist = dest_rtv->playlist();
1345 _editor->begin_reversible_command (Operations::insert_region);
1346 playlist->clear_changes ();
1347 playlist->add_region (_primary->region (), _last_frame_position);
1348 _editor->session()->add_command (new StatefulDiffCommand (playlist));
1349 _editor->commit_reversible_command ();
1357 RegionInsertDrag::aborted (bool)
1364 RegionSpliceDrag::RegionSpliceDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v)
1365 : RegionMoveDrag (e, i, p, v, false, false)
1367 DEBUG_TRACE (DEBUG::Drags, "New RegionSpliceDrag\n");
1370 struct RegionSelectionByPosition {
1371 bool operator() (RegionView*a, RegionView* b) {
1372 return a->region()->position () < b->region()->position();
1377 RegionSpliceDrag::motion (GdkEvent* event, bool)
1379 /* Which trackview is this ? */
1381 pair<TimeAxisView*, double> const tvp = _editor->trackview_by_y_position (_drags->current_pointer_y ());
1382 RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*> (tvp.first);
1384 /* The region motion is only processed if the pointer is over
1388 if (!tv || !tv->is_track()) {
1389 /* To make sure we hide the verbose canvas cursor when the mouse is
1390 not held over and audiotrack.
1392 _editor->verbose_cursor()->hide ();
1398 if ((_drags->current_pointer_x() - last_pointer_x()) > 0) {
1404 RegionSelection copy (_editor->selection->regions);
1406 RegionSelectionByPosition cmp;
1409 framepos_t const pf = adjusted_current_frame (event);
1411 for (RegionSelection::iterator i = copy.begin(); i != copy.end(); ++i) {
1413 RouteTimeAxisView* atv = dynamic_cast<RouteTimeAxisView*> (&(*i)->get_time_axis_view());
1419 boost::shared_ptr<Playlist> playlist;
1421 if ((playlist = atv->playlist()) == 0) {
1425 if (!playlist->region_is_shuffle_constrained ((*i)->region())) {
1430 if (pf < (*i)->region()->last_frame() + 1) {
1434 if (pf > (*i)->region()->first_frame()) {
1440 playlist->shuffle ((*i)->region(), dir);
1445 RegionSpliceDrag::finished (GdkEvent* event, bool movement_occurred)
1447 RegionMoveDrag::finished (event, movement_occurred);
1451 RegionSpliceDrag::aborted (bool)
1456 RegionCreateDrag::RegionCreateDrag (Editor* e, ArdourCanvas::Item* i, TimeAxisView* v)
1458 _view (dynamic_cast<MidiTimeAxisView*> (v))
1460 DEBUG_TRACE (DEBUG::Drags, "New RegionCreateDrag\n");
1466 RegionCreateDrag::motion (GdkEvent* event, bool first_move)
1469 _region = add_midi_region (_view);
1470 _view->playlist()->freeze ();
1473 framepos_t const f = adjusted_current_frame (event);
1474 if (f < grab_frame()) {
1475 _region->set_position (f);
1478 /* Don't use a zero-length region, and subtract 1 frame from the snapped length
1479 so that if this region is duplicated, its duplicate starts on
1480 a snap point rather than 1 frame after a snap point. Otherwise things get
1481 a bit confusing as if a region starts 1 frame after a snap point, one cannot
1482 place snapped notes at the start of the region.
1485 framecnt_t const len = abs (f - grab_frame () - 1);
1486 _region->set_length (len < 1 ? 1 : len);
1492 RegionCreateDrag::finished (GdkEvent*, bool movement_occurred)
1494 if (!movement_occurred) {
1495 add_midi_region (_view);
1497 _view->playlist()->thaw ();
1502 RegionCreateDrag::aborted (bool)
1505 _view->playlist()->thaw ();
1511 NoteResizeDrag::NoteResizeDrag (Editor* e, ArdourCanvas::Item* i)
1515 DEBUG_TRACE (DEBUG::Drags, "New NoteResizeDrag\n");
1519 NoteResizeDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*ignored*/)
1521 Gdk::Cursor* cursor;
1522 ArdourCanvas::CanvasNoteEvent* cnote = dynamic_cast<ArdourCanvas::CanvasNoteEvent*>(_item);
1523 float x_fraction = cnote->mouse_x_fraction ();
1525 if (x_fraction > 0.0 && x_fraction < 0.25) {
1526 cursor = _editor->cursors()->left_side_trim;
1528 cursor = _editor->cursors()->right_side_trim;
1531 Drag::start_grab (event, cursor);
1533 region = &cnote->region_view();
1535 double const region_start = region->get_position_pixels();
1536 double const middle_point = region_start + cnote->x1() + (cnote->x2() - cnote->x1()) / 2.0L;
1538 if (grab_x() <= middle_point) {
1539 cursor = _editor->cursors()->left_side_trim;
1542 cursor = _editor->cursors()->right_side_trim;
1546 _item->grab(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK, *cursor, event->motion.time);
1548 if (event->motion.state & Keyboard::PrimaryModifier) {
1554 MidiRegionSelection& ms (_editor->get_selection().midi_regions);
1556 if (ms.size() > 1) {
1557 /* has to be relative, may make no sense otherwise */
1561 /* select this note; if it is already selected, preserve the existing selection,
1562 otherwise make this note the only one selected.
1564 region->note_selected (cnote, cnote->selected ());
1566 for (MidiRegionSelection::iterator r = ms.begin(); r != ms.end(); ) {
1567 MidiRegionSelection::iterator next;
1570 (*r)->begin_resizing (at_front);
1576 NoteResizeDrag::motion (GdkEvent* /*event*/, bool /*first_move*/)
1578 MidiRegionSelection& ms (_editor->get_selection().midi_regions);
1579 for (MidiRegionSelection::iterator r = ms.begin(); r != ms.end(); ++r) {
1580 (*r)->update_resizing (dynamic_cast<ArdourCanvas::CanvasNoteEvent*>(_item), at_front, _drags->current_pointer_x() - grab_x(), relative);
1585 NoteResizeDrag::finished (GdkEvent*, bool /*movement_occurred*/)
1587 MidiRegionSelection& ms (_editor->get_selection().midi_regions);
1588 for (MidiRegionSelection::iterator r = ms.begin(); r != ms.end(); ++r) {
1589 (*r)->commit_resizing (dynamic_cast<ArdourCanvas::CanvasNoteEvent*>(_item), at_front, _drags->current_pointer_x() - grab_x(), relative);
1594 NoteResizeDrag::aborted (bool)
1596 MidiRegionSelection& ms (_editor->get_selection().midi_regions);
1597 for (MidiRegionSelection::iterator r = ms.begin(); r != ms.end(); ++r) {
1598 (*r)->abort_resizing ();
1602 TrimDrag::TrimDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v)
1603 : RegionDrag (e, i, p, v)
1605 DEBUG_TRACE (DEBUG::Drags, "New TrimDrag\n");
1609 TrimDrag::start_grab (GdkEvent* event, Gdk::Cursor*)
1612 TimeAxisView* tvp = &_primary->get_time_axis_view ();
1613 RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*>(tvp);
1615 if (tv && tv->is_track()) {
1616 speed = tv->track()->speed();
1619 framepos_t const region_start = (framepos_t) (_primary->region()->position() / speed);
1620 framepos_t const region_end = (framepos_t) (_primary->region()->last_frame() / speed);
1621 framecnt_t const region_length = (framecnt_t) (_primary->region()->length() / speed);
1623 framepos_t const pf = adjusted_current_frame (event);
1625 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
1626 /* Move the contents of the region around without changing the region bounds */
1627 _operation = ContentsTrim;
1628 Drag::start_grab (event, _editor->cursors()->trimmer);
1630 /* These will get overridden for a point trim.*/
1631 if (pf < (region_start + region_length/2)) {
1632 /* closer to front */
1633 _operation = StartTrim;
1634 Drag::start_grab (event, _editor->cursors()->left_side_trim);
1637 _operation = EndTrim;
1638 Drag::start_grab (event, _editor->cursors()->right_side_trim);
1642 switch (_operation) {
1644 show_verbose_cursor_time (region_start);
1645 for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
1646 i->view->trim_front_starting ();
1650 show_verbose_cursor_time (region_end);
1653 show_verbose_cursor_time (pf);
1657 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
1658 i->view->region()->suspend_property_changes ();
1663 TrimDrag::motion (GdkEvent* event, bool first_move)
1665 RegionView* rv = _primary;
1668 TimeAxisView* tvp = &_primary->get_time_axis_view ();
1669 RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*>(tvp);
1670 pair<set<boost::shared_ptr<Playlist> >::iterator,bool> insert_result;
1672 if (tv && tv->is_track()) {
1673 speed = tv->track()->speed();
1676 framecnt_t const dt = adjusted_current_frame (event) - raw_grab_frame () + _pointer_frame_offset;
1682 switch (_operation) {
1684 trim_type = "Region start trim";
1687 trim_type = "Region end trim";
1690 trim_type = "Region content trim";
1694 _editor->begin_reversible_command (trim_type);
1696 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
1697 RegionView* rv = i->view;
1698 rv->fake_set_opaque (false);
1699 rv->enable_display (false);
1700 rv->region()->playlist()->clear_owned_changes ();
1702 AudioRegionView* const arv = dynamic_cast<AudioRegionView*> (rv);
1705 arv->temporarily_hide_envelope ();
1709 boost::shared_ptr<Playlist> pl = rv->region()->playlist();
1710 insert_result = _editor->motion_frozen_playlists.insert (pl);
1712 if (insert_result.second) {
1718 bool non_overlap_trim = false;
1720 if (event && Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
1721 non_overlap_trim = true;
1724 switch (_operation) {
1726 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
1727 i->view->trim_front (i->initial_position + dt, non_overlap_trim);
1732 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
1733 i->view->trim_end (i->initial_end + dt, non_overlap_trim);
1739 bool swap_direction = false;
1741 if (event && Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
1742 swap_direction = true;
1745 framecnt_t frame_delta = 0;
1747 bool left_direction = false;
1748 if (last_pointer_frame() > adjusted_current_frame(event)) {
1749 left_direction = true;
1752 if (left_direction) {
1753 frame_delta = (last_pointer_frame() - adjusted_current_frame(event));
1755 frame_delta = (adjusted_current_frame(event) - last_pointer_frame());
1758 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
1759 i->view->trim_contents (frame_delta, left_direction, swap_direction);
1765 switch (_operation) {
1767 show_verbose_cursor_time ((framepos_t) (rv->region()->position() / speed));
1770 show_verbose_cursor_time ((framepos_t) (rv->region()->last_frame() / speed));
1773 show_verbose_cursor_time (adjusted_current_frame (event));
1780 TrimDrag::finished (GdkEvent* event, bool movement_occurred)
1782 if (movement_occurred) {
1783 motion (event, false);
1785 /* This must happen before the region's StatefulDiffCommand is created, as it may
1786 `correct' (ahem) the region's _start from being negative to being zero. It
1787 needs to be zero in the undo record.
1789 if (_operation == StartTrim) {
1790 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
1791 i->view->trim_front_ending ();
1795 if (_operation == StartTrim) {
1796 _editor->maybe_locate_with_edit_preroll ( _views.begin()->view->region()->position() );
1798 if (_operation == EndTrim) {
1799 _editor->maybe_locate_with_edit_preroll ( _views.begin()->view->region()->position() + _views.begin()->view->region()->length() );
1802 if (!_editor->selection->selected (_primary)) {
1803 _primary->thaw_after_trim ();
1806 set<boost::shared_ptr<Playlist> > diffed_playlists;
1808 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
1809 i->view->thaw_after_trim ();
1810 i->view->enable_display (true);
1811 i->view->fake_set_opaque (true);
1813 /* Trimming one region may affect others on the playlist, so we need
1814 to get undo Commands from the whole playlist rather than just the
1815 region. Use diffed_playlists to make sure we don't diff a given
1816 playlist more than once.
1818 boost::shared_ptr<Playlist> p = i->view->region()->playlist ();
1819 if (diffed_playlists.find (p) == diffed_playlists.end()) {
1820 vector<Command*> cmds;
1822 _editor->session()->add_commands (cmds);
1823 diffed_playlists.insert (p);
1827 for (set<boost::shared_ptr<Playlist> >::iterator p = _editor->motion_frozen_playlists.begin(); p != _editor->motion_frozen_playlists.end(); ++p) {
1831 _editor->motion_frozen_playlists.clear ();
1832 _editor->commit_reversible_command();
1834 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
1835 i->view->drag_end ();
1839 /* no mouse movement */
1840 _editor->point_trim (event, adjusted_current_frame (event));
1843 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
1844 if (_operation == StartTrim) {
1845 i->view->trim_front_ending ();
1848 i->view->region()->resume_property_changes ();
1853 TrimDrag::aborted (bool movement_occurred)
1855 /* Our motion method is changing model state, so use the Undo system
1856 to cancel. Perhaps not ideal, as this will leave an Undo point
1857 behind which may be slightly odd from the user's point of view.
1862 if (movement_occurred) {
1866 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
1867 i->view->region()->resume_property_changes ();
1872 TrimDrag::setup_pointer_frame_offset ()
1874 list<DraggingView>::iterator i = _views.begin ();
1875 while (i != _views.end() && i->view != _primary) {
1879 if (i == _views.end()) {
1883 switch (_operation) {
1885 _pointer_frame_offset = raw_grab_frame() - i->initial_position;
1888 _pointer_frame_offset = raw_grab_frame() - i->initial_end;
1895 MeterMarkerDrag::MeterMarkerDrag (Editor* e, ArdourCanvas::Item* i, bool c)
1899 DEBUG_TRACE (DEBUG::Drags, "New MeterMarkerDrag\n");
1900 _marker = reinterpret_cast<MeterMarker*> (_item->get_data ("marker"));
1905 MeterMarkerDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
1907 Drag::start_grab (event, cursor);
1908 show_verbose_cursor_time (adjusted_current_frame(event));
1912 MeterMarkerDrag::setup_pointer_frame_offset ()
1914 _pointer_frame_offset = raw_grab_frame() - _marker->meter().frame();
1918 MeterMarkerDrag::motion (GdkEvent* event, bool first_move)
1922 // create a dummy marker for visual representation of moving the
1923 // section, because whether its a copy or not, we're going to
1924 // leave or lose the original marker (leave if its a copy; lose if its
1925 // not, because we'll remove it from the map).
1927 MeterSection section (_marker->meter());
1929 if (!section.movable()) {
1934 snprintf (name, sizeof(name), "%g/%g", _marker->meter().divisions_per_bar(), _marker->meter().note_divisor ());
1936 _marker = new MeterMarker (
1938 *_editor->meter_group,
1939 ARDOUR_UI::config()->canvasvar_MeterMarker.get(),
1941 *new MeterSection (_marker->meter())
1944 /* use the new marker for the grab */
1945 swap_grab (&_marker->the_item(), 0, GDK_CURRENT_TIME);
1948 TempoMap& map (_editor->session()->tempo_map());
1949 /* get current state */
1950 before_state = &map.get_state();
1951 /* remove the section while we drag it */
1952 map.remove_meter (section, true);
1956 framepos_t const pf = adjusted_current_frame (event);
1957 _marker->set_position (pf);
1958 show_verbose_cursor_time (pf);
1962 MeterMarkerDrag::finished (GdkEvent* event, bool movement_occurred)
1964 if (!movement_occurred) {
1968 motion (event, false);
1970 Timecode::BBT_Time when;
1972 TempoMap& map (_editor->session()->tempo_map());
1973 map.bbt_time (last_pointer_frame(), when);
1975 if (_copy == true) {
1976 _editor->begin_reversible_command (_("copy meter mark"));
1977 XMLNode &before = map.get_state();
1978 map.add_meter (_marker->meter(), when);
1979 XMLNode &after = map.get_state();
1980 _editor->session()->add_command(new MementoCommand<TempoMap>(map, &before, &after));
1981 _editor->commit_reversible_command ();
1984 _editor->begin_reversible_command (_("move meter mark"));
1986 /* we removed it before, so add it back now */
1988 map.add_meter (_marker->meter(), when);
1989 XMLNode &after = map.get_state();
1990 _editor->session()->add_command(new MementoCommand<TempoMap>(map, before_state, &after));
1991 _editor->commit_reversible_command ();
1994 // delete the dummy marker we used for visual representation while moving.
1995 // a new visual marker will show up automatically.
2000 MeterMarkerDrag::aborted (bool moved)
2002 _marker->set_position (_marker->meter().frame ());
2005 TempoMap& map (_editor->session()->tempo_map());
2006 /* we removed it before, so add it back now */
2007 map.add_meter (_marker->meter(), _marker->meter().frame());
2008 // delete the dummy marker we used for visual representation while moving.
2009 // a new visual marker will show up automatically.
2014 TempoMarkerDrag::TempoMarkerDrag (Editor* e, ArdourCanvas::Item* i, bool c)
2018 DEBUG_TRACE (DEBUG::Drags, "New TempoMarkerDrag\n");
2020 _marker = reinterpret_cast<TempoMarker*> (_item->get_data ("marker"));
2025 TempoMarkerDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
2027 Drag::start_grab (event, cursor);
2028 show_verbose_cursor_time (adjusted_current_frame (event));
2032 TempoMarkerDrag::setup_pointer_frame_offset ()
2034 _pointer_frame_offset = raw_grab_frame() - _marker->tempo().frame();
2038 TempoMarkerDrag::motion (GdkEvent* event, bool first_move)
2042 // create a dummy marker for visual representation of moving the
2043 // section, because whether its a copy or not, we're going to
2044 // leave or lose the original marker (leave if its a copy; lose if its
2045 // not, because we'll remove it from the map).
2047 // create a dummy marker for visual representation of moving the copy.
2048 // The actual copying is not done before we reach the finish callback.
2051 snprintf (name, sizeof (name), "%.2f", _marker->tempo().beats_per_minute());
2053 TempoSection section (_marker->tempo());
2055 _marker = new TempoMarker (
2057 *_editor->tempo_group,
2058 ARDOUR_UI::config()->canvasvar_TempoMarker.get(),
2060 *new TempoSection (_marker->tempo())
2063 /* use the new marker for the grab */
2064 swap_grab (&_marker->the_item(), 0, GDK_CURRENT_TIME);
2067 TempoMap& map (_editor->session()->tempo_map());
2068 /* get current state */
2069 before_state = &map.get_state();
2070 /* remove the section while we drag it */
2071 map.remove_tempo (section, true);
2075 framepos_t const pf = adjusted_current_frame (event);
2076 _marker->set_position (pf);
2077 show_verbose_cursor_time (pf);
2081 TempoMarkerDrag::finished (GdkEvent* event, bool movement_occurred)
2083 if (!movement_occurred) {
2087 motion (event, false);
2089 TempoMap& map (_editor->session()->tempo_map());
2090 framepos_t beat_time = map.round_to_beat (last_pointer_frame(), 0);
2091 Timecode::BBT_Time when;
2093 map.bbt_time (beat_time, when);
2095 if (_copy == true) {
2096 _editor->begin_reversible_command (_("copy tempo mark"));
2097 XMLNode &before = map.get_state();
2098 map.add_tempo (_marker->tempo(), when);
2099 XMLNode &after = map.get_state();
2100 _editor->session()->add_command (new MementoCommand<TempoMap>(map, &before, &after));
2101 _editor->commit_reversible_command ();
2104 _editor->begin_reversible_command (_("move tempo mark"));
2105 /* we removed it before, so add it back now */
2106 map.add_tempo (_marker->tempo(), when);
2107 XMLNode &after = map.get_state();
2108 _editor->session()->add_command (new MementoCommand<TempoMap>(map, before_state, &after));
2109 _editor->commit_reversible_command ();
2112 // delete the dummy marker we used for visual representation while moving.
2113 // a new visual marker will show up automatically.
2118 TempoMarkerDrag::aborted (bool moved)
2120 _marker->set_position (_marker->tempo().frame());
2122 TempoMap& map (_editor->session()->tempo_map());
2123 /* we removed it before, so add it back now */
2124 map.add_tempo (_marker->tempo(), _marker->tempo().start());
2125 // delete the dummy marker we used for visual representation while moving.
2126 // a new visual marker will show up automatically.
2131 CursorDrag::CursorDrag (Editor* e, ArdourCanvas::Item* i, bool s)
2135 DEBUG_TRACE (DEBUG::Drags, "New CursorDrag\n");
2138 /** Do all the things we do when dragging the playhead to make it look as though
2139 * we have located, without actually doing the locate (because that would cause
2140 * the diskstream buffers to be refilled, which is too slow).
2143 CursorDrag::fake_locate (framepos_t t)
2145 _editor->playhead_cursor->set_position (t);
2147 Session* s = _editor->session ();
2148 if (s->timecode_transmission_suspended ()) {
2149 framepos_t const f = _editor->playhead_cursor->current_frame;
2150 s->send_mmc_locate (f);
2151 s->send_full_time_code (f);
2154 show_verbose_cursor_time (t);
2155 _editor->UpdateAllTransportClocks (t);
2159 CursorDrag::start_grab (GdkEvent* event, Gdk::Cursor* c)
2161 Drag::start_grab (event, c);
2163 _grab_zoom = _editor->frames_per_unit;
2165 framepos_t where = _editor->event_frame (event, 0, 0);
2166 _editor->snap_to_with_modifier (where, event);
2168 _editor->_dragging_playhead = true;
2170 Session* s = _editor->session ();
2173 if (_was_rolling && _stop) {
2177 if (s->is_auditioning()) {
2178 s->cancel_audition ();
2182 if (AudioEngine::instance()->connected()) {
2184 /* do this only if we're the engine is connected
2185 * because otherwise this request will never be
2186 * serviced and we'll busy wait forever. likewise,
2187 * notice if we are disconnected while waiting for the
2188 * request to be serviced.
2191 s->request_suspend_timecode_transmission ();
2192 while (AudioEngine::instance()->connected() && !s->timecode_transmission_suspended ()) {
2193 /* twiddle our thumbs */
2198 fake_locate (where);
2202 CursorDrag::motion (GdkEvent* event, bool)
2204 framepos_t const adjusted_frame = adjusted_current_frame (event);
2205 if (adjusted_frame != last_pointer_frame()) {
2206 fake_locate (adjusted_frame);
2208 _editor->update_canvas_now ();
2214 CursorDrag::finished (GdkEvent* event, bool movement_occurred)
2216 _editor->_dragging_playhead = false;
2218 if (!movement_occurred && _stop) {
2222 motion (event, false);
2224 Session* s = _editor->session ();
2226 s->request_locate (_editor->playhead_cursor->current_frame, _was_rolling);
2227 _editor->_pending_locate_request = true;
2228 s->request_resume_timecode_transmission ();
2233 CursorDrag::aborted (bool)
2235 if (_editor->_dragging_playhead) {
2236 _editor->session()->request_resume_timecode_transmission ();
2237 _editor->_dragging_playhead = false;
2240 _editor->playhead_cursor->set_position (adjusted_frame (grab_frame (), 0, false));
2243 FadeInDrag::FadeInDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v)
2244 : RegionDrag (e, i, p, v)
2246 DEBUG_TRACE (DEBUG::Drags, "New FadeInDrag\n");
2250 FadeInDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
2252 Drag::start_grab (event, cursor);
2254 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (_primary);
2255 boost::shared_ptr<AudioRegion> const r = arv->audio_region ();
2257 show_verbose_cursor_duration (r->position(), r->position() + r->fade_in()->back()->when, 32);
2259 arv->show_fade_line((framepos_t) r->fade_in()->back()->when);
2263 FadeInDrag::setup_pointer_frame_offset ()
2265 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (_primary);
2266 boost::shared_ptr<AudioRegion> const r = arv->audio_region ();
2267 _pointer_frame_offset = raw_grab_frame() - ((framecnt_t) r->fade_in()->back()->when + r->position());
2271 FadeInDrag::motion (GdkEvent* event, bool)
2273 framecnt_t fade_length;
2275 framepos_t const pos = adjusted_current_frame (event);
2277 boost::shared_ptr<Region> region = _primary->region ();
2279 if (pos < (region->position() + 64)) {
2280 fade_length = 64; // this should be a minimum defined somewhere
2281 } else if (pos > region->last_frame()) {
2282 fade_length = region->length();
2284 fade_length = pos - region->position();
2287 for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
2289 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (i->view);
2295 tmp->reset_fade_in_shape_width (fade_length);
2296 tmp->show_fade_line((framecnt_t) fade_length);
2299 show_verbose_cursor_duration (region->position(), region->position() + fade_length, 32);
2303 FadeInDrag::finished (GdkEvent* event, bool movement_occurred)
2305 if (!movement_occurred) {
2309 framecnt_t fade_length;
2311 framepos_t const pos = adjusted_current_frame (event);
2313 boost::shared_ptr<Region> region = _primary->region ();
2315 if (pos < (region->position() + 64)) {
2316 fade_length = 64; // this should be a minimum defined somewhere
2317 } else if (pos > region->last_frame()) {
2318 fade_length = region->length();
2320 fade_length = pos - region->position();
2323 _editor->begin_reversible_command (_("change fade in length"));
2325 for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
2327 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (i->view);
2333 boost::shared_ptr<AutomationList> alist = tmp->audio_region()->fade_in();
2334 XMLNode &before = alist->get_state();
2336 tmp->audio_region()->set_fade_in_length (fade_length);
2337 tmp->audio_region()->set_fade_in_active (true);
2338 tmp->hide_fade_line();
2340 XMLNode &after = alist->get_state();
2341 _editor->session()->add_command(new MementoCommand<AutomationList>(*alist.get(), &before, &after));
2344 _editor->commit_reversible_command ();
2348 FadeInDrag::aborted (bool)
2350 for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
2351 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (i->view);
2357 tmp->reset_fade_in_shape_width (tmp->audio_region()->fade_in()->back()->when);
2358 tmp->hide_fade_line();
2362 FadeOutDrag::FadeOutDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v)
2363 : RegionDrag (e, i, p, v)
2365 DEBUG_TRACE (DEBUG::Drags, "New FadeOutDrag\n");
2369 FadeOutDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
2371 Drag::start_grab (event, cursor);
2373 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (_primary);
2374 boost::shared_ptr<AudioRegion> r = arv->audio_region ();
2376 show_verbose_cursor_duration (r->last_frame() - r->fade_out()->back()->when, r->last_frame());
2378 arv->show_fade_line(r->length() - r->fade_out()->back()->when);
2382 FadeOutDrag::setup_pointer_frame_offset ()
2384 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (_primary);
2385 boost::shared_ptr<AudioRegion> r = arv->audio_region ();
2386 _pointer_frame_offset = raw_grab_frame() - (r->length() - (framecnt_t) r->fade_out()->back()->when + r->position());
2390 FadeOutDrag::motion (GdkEvent* event, bool)
2392 framecnt_t fade_length;
2394 framepos_t const pos = adjusted_current_frame (event);
2396 boost::shared_ptr<Region> region = _primary->region ();
2398 if (pos > (region->last_frame() - 64)) {
2399 fade_length = 64; // this should really be a minimum fade defined somewhere
2401 else if (pos < region->position()) {
2402 fade_length = region->length();
2405 fade_length = region->last_frame() - pos;
2408 for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
2410 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (i->view);
2416 tmp->reset_fade_out_shape_width (fade_length);
2417 tmp->show_fade_line(region->length() - fade_length);
2420 show_verbose_cursor_duration (region->last_frame() - fade_length, region->last_frame());
2424 FadeOutDrag::finished (GdkEvent* event, bool movement_occurred)
2426 if (!movement_occurred) {
2430 framecnt_t fade_length;
2432 framepos_t const pos = adjusted_current_frame (event);
2434 boost::shared_ptr<Region> region = _primary->region ();
2436 if (pos > (region->last_frame() - 64)) {
2437 fade_length = 64; // this should really be a minimum fade defined somewhere
2439 else if (pos < region->position()) {
2440 fade_length = region->length();
2443 fade_length = region->last_frame() - pos;
2446 _editor->begin_reversible_command (_("change fade out length"));
2448 for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
2450 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (i->view);
2456 boost::shared_ptr<AutomationList> alist = tmp->audio_region()->fade_out();
2457 XMLNode &before = alist->get_state();
2459 tmp->audio_region()->set_fade_out_length (fade_length);
2460 tmp->audio_region()->set_fade_out_active (true);
2461 tmp->hide_fade_line();
2463 XMLNode &after = alist->get_state();
2464 _editor->session()->add_command(new MementoCommand<AutomationList>(*alist.get(), &before, &after));
2467 _editor->commit_reversible_command ();
2471 FadeOutDrag::aborted (bool)
2473 for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
2474 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (i->view);
2480 tmp->reset_fade_out_shape_width (tmp->audio_region()->fade_out()->back()->when);
2481 tmp->hide_fade_line();
2485 MarkerDrag::MarkerDrag (Editor* e, ArdourCanvas::Item* i)
2488 DEBUG_TRACE (DEBUG::Drags, "New MarkerDrag\n");
2490 _marker = reinterpret_cast<Marker*> (_item->get_data ("marker"));
2493 _points.push_back (Gnome::Art::Point (0, 0));
2494 _points.push_back (Gnome::Art::Point (0, physical_screen_height (_editor->get_window())));
2497 MarkerDrag::~MarkerDrag ()
2499 for (list<Location*>::iterator i = _copied_locations.begin(); i != _copied_locations.end(); ++i) {
2505 MarkerDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
2507 Drag::start_grab (event, cursor);
2511 Location *location = _editor->find_location_from_marker (_marker, is_start);
2512 _editor->_dragging_edit_point = true;
2514 update_item (location);
2516 // _drag_line->show();
2517 // _line->raise_to_top();
2520 show_verbose_cursor_time (location->start());
2522 show_verbose_cursor_time (location->end());
2525 Selection::Operation op = ArdourKeyboard::selection_type (event->button.state);
2528 case Selection::Toggle:
2529 _editor->selection->toggle (_marker);
2531 case Selection::Set:
2532 if (!_editor->selection->selected (_marker)) {
2533 _editor->selection->set (_marker);
2536 case Selection::Extend:
2538 Locations::LocationList ll;
2539 list<Marker*> to_add;
2541 _editor->selection->markers.range (s, e);
2542 s = min (_marker->position(), s);
2543 e = max (_marker->position(), e);
2546 if (e < max_framepos) {
2549 _editor->session()->locations()->find_all_between (s, e, ll, Location::Flags (0));
2550 for (Locations::LocationList::iterator i = ll.begin(); i != ll.end(); ++i) {
2551 Editor::LocationMarkers* lm = _editor->find_location_markers (*i);
2554 to_add.push_back (lm->start);
2557 to_add.push_back (lm->end);
2561 if (!to_add.empty()) {
2562 _editor->selection->add (to_add);
2566 case Selection::Add:
2567 _editor->selection->add (_marker);
2571 /* Set up copies for us to manipulate during the drag */
2573 for (MarkerSelection::iterator i = _editor->selection->markers.begin(); i != _editor->selection->markers.end(); ++i) {
2574 Location* l = _editor->find_location_from_marker (*i, is_start);
2575 _copied_locations.push_back (new Location (*l));
2580 MarkerDrag::setup_pointer_frame_offset ()
2583 Location *location = _editor->find_location_from_marker (_marker, is_start);
2584 _pointer_frame_offset = raw_grab_frame() - (is_start ? location->start() : location->end());
2588 MarkerDrag::motion (GdkEvent* event, bool)
2590 framecnt_t f_delta = 0;
2592 bool move_both = false;
2594 Location *real_location;
2595 Location *copy_location = 0;
2597 framepos_t const newframe = adjusted_current_frame (event);
2599 framepos_t next = newframe;
2601 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
2605 MarkerSelection::iterator i;
2606 list<Location*>::iterator x;
2608 /* find the marker we're dragging, and compute the delta */
2610 for (i = _editor->selection->markers.begin(), x = _copied_locations.begin();
2611 x != _copied_locations.end() && i != _editor->selection->markers.end();
2617 if (marker == _marker) {
2619 if ((real_location = _editor->find_location_from_marker (marker, is_start)) == 0) {
2624 if (real_location->is_mark()) {
2625 f_delta = newframe - copy_location->start();
2629 switch (marker->type()) {
2630 case Marker::SessionStart:
2631 case Marker::RangeStart:
2632 case Marker::LoopStart:
2633 case Marker::PunchIn:
2634 f_delta = newframe - copy_location->start();
2637 case Marker::SessionEnd:
2638 case Marker::RangeEnd:
2639 case Marker::LoopEnd:
2640 case Marker::PunchOut:
2641 f_delta = newframe - copy_location->end();
2644 /* what kind of marker is this ? */
2652 if (i == _editor->selection->markers.end()) {
2653 /* hmm, impossible - we didn't find the dragged marker */
2657 /* now move them all */
2659 for (i = _editor->selection->markers.begin(), x = _copied_locations.begin();
2660 x != _copied_locations.end() && i != _editor->selection->markers.end();
2666 /* call this to find out if its the start or end */
2668 if ((real_location = _editor->find_location_from_marker (marker, is_start)) == 0) {
2672 if (real_location->locked()) {
2676 if (copy_location->is_mark()) {
2680 copy_location->set_start (copy_location->start() + f_delta);
2684 framepos_t new_start = copy_location->start() + f_delta;
2685 framepos_t new_end = copy_location->end() + f_delta;
2687 if (is_start) { // start-of-range marker
2690 copy_location->set_start (new_start);
2691 copy_location->set_end (new_end);
2692 } else if (new_start < copy_location->end()) {
2693 copy_location->set_start (new_start);
2694 } else if (newframe > 0) {
2695 _editor->snap_to (next, 1, true);
2696 copy_location->set_end (next);
2697 copy_location->set_start (newframe);
2700 } else { // end marker
2703 copy_location->set_end (new_end);
2704 copy_location->set_start (new_start);
2705 } else if (new_end > copy_location->start()) {
2706 copy_location->set_end (new_end);
2707 } else if (newframe > 0) {
2708 _editor->snap_to (next, -1, true);
2709 copy_location->set_start (next);
2710 copy_location->set_end (newframe);
2715 update_item (copy_location);
2717 Editor::LocationMarkers* lm = _editor->find_location_markers (real_location);
2720 lm->set_position (copy_location->start(), copy_location->end());
2724 assert (!_copied_locations.empty());
2726 show_verbose_cursor_time (newframe);
2729 _editor->update_canvas_now ();
2734 MarkerDrag::finished (GdkEvent* event, bool movement_occurred)
2736 if (!movement_occurred) {
2738 /* just a click, do nothing but finish
2739 off the selection process
2742 Selection::Operation op = ArdourKeyboard::selection_type (event->button.state);
2745 case Selection::Set:
2746 if (_editor->selection->selected (_marker) && _editor->selection->markers.size() > 1) {
2747 _editor->selection->set (_marker);
2751 case Selection::Toggle:
2752 case Selection::Extend:
2753 case Selection::Add:
2760 _editor->_dragging_edit_point = false;
2762 _editor->begin_reversible_command ( _("move marker") );
2763 XMLNode &before = _editor->session()->locations()->get_state();
2765 MarkerSelection::iterator i;
2766 list<Location*>::iterator x;
2769 for (i = _editor->selection->markers.begin(), x = _copied_locations.begin();
2770 x != _copied_locations.end() && i != _editor->selection->markers.end();
2773 Location * location = _editor->find_location_from_marker (*i, is_start);
2777 if (location->locked()) {
2781 if (location->is_mark()) {
2782 location->set_start ((*x)->start());
2784 location->set ((*x)->start(), (*x)->end());
2789 XMLNode &after = _editor->session()->locations()->get_state();
2790 _editor->session()->add_command(new MementoCommand<Locations>(*(_editor->session()->locations()), &before, &after));
2791 _editor->commit_reversible_command ();
2795 MarkerDrag::aborted (bool)
2801 MarkerDrag::update_item (Location*)
2806 ControlPointDrag::ControlPointDrag (Editor* e, ArdourCanvas::Item* i)
2808 _cumulative_x_drag (0),
2809 _cumulative_y_drag (0)
2811 if (_zero_gain_fraction < 0.0) {
2812 _zero_gain_fraction = gain_to_slider_position_with_max (dB_to_coefficient (0.0), Config->get_max_gain());
2815 DEBUG_TRACE (DEBUG::Drags, "New ControlPointDrag\n");
2817 _point = reinterpret_cast<ControlPoint*> (_item->get_data ("control_point"));
2823 ControlPointDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*cursor*/)
2825 Drag::start_grab (event, _editor->cursors()->fader);
2827 // start the grab at the center of the control point so
2828 // the point doesn't 'jump' to the mouse after the first drag
2829 _fixed_grab_x = _point->get_x();
2830 _fixed_grab_y = _point->get_y();
2832 float const fraction = 1 - (_point->get_y() / _point->line().height());
2834 _point->line().start_drag_single (_point, _fixed_grab_x, fraction);
2836 _editor->verbose_cursor()->set (_point->line().get_verbose_cursor_string (fraction),
2837 event->button.x + 10, event->button.y + 10);
2839 _editor->verbose_cursor()->show ();
2841 if (!_point->can_slide ()) {
2842 _x_constrained = true;
2847 ControlPointDrag::motion (GdkEvent* event, bool)
2849 double dx = _drags->current_pointer_x() - last_pointer_x();
2850 double dy = _drags->current_pointer_y() - last_pointer_y();
2852 if (event->button.state & Keyboard::SecondaryModifier) {
2857 /* coordinate in pixels relative to the start of the region (for region-based automation)
2858 or track (for track-based automation) */
2859 double cx = _fixed_grab_x + _cumulative_x_drag + dx;
2860 double cy = _fixed_grab_y + _cumulative_y_drag + dy;
2862 // calculate zero crossing point. back off by .01 to stay on the
2863 // positive side of zero
2864 double const zero_gain_y = (1.0 - _zero_gain_fraction) * _point->line().height() - .01;
2866 // make sure we hit zero when passing through
2867 if ((cy < zero_gain_y && (cy - dy) > zero_gain_y) || (cy > zero_gain_y && (cy - dy) < zero_gain_y)) {
2871 if (_x_constrained) {
2874 if (_y_constrained) {
2878 _cumulative_x_drag = cx - _fixed_grab_x;
2879 _cumulative_y_drag = cy - _fixed_grab_y;
2883 cy = min ((double) _point->line().height(), cy);
2885 framepos_t cx_frames = _editor->unit_to_frame (cx);
2887 if (!_x_constrained) {
2888 _editor->snap_to_with_modifier (cx_frames, event);
2891 cx_frames = min (cx_frames, _point->line().maximum_time());
2893 float const fraction = 1.0 - (cy / _point->line().height());
2894 bool const push = Keyboard::modifier_state_contains (event->button.state, Keyboard::PrimaryModifier);
2896 _point->line().drag_motion (_editor->frame_to_unit_unrounded (cx_frames), fraction, false, push);
2898 _editor->verbose_cursor()->set_text (_point->line().get_verbose_cursor_string (fraction));
2902 ControlPointDrag::finished (GdkEvent* event, bool movement_occurred)
2904 if (!movement_occurred) {
2908 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
2909 _editor->reset_point_selection ();
2913 motion (event, false);
2916 _point->line().end_drag ();
2917 _editor->session()->commit_reversible_command ();
2921 ControlPointDrag::aborted (bool)
2923 _point->line().reset ();
2927 ControlPointDrag::active (Editing::MouseMode m)
2929 if (m == Editing::MouseGain) {
2930 /* always active in mouse gain */
2934 /* otherwise active if the point is on an automation line (ie not if its on a region gain line) */
2935 return dynamic_cast<AutomationLine*> (&(_point->line())) != 0;
2938 LineDrag::LineDrag (Editor* e, ArdourCanvas::Item* i)
2941 _cumulative_y_drag (0)
2943 DEBUG_TRACE (DEBUG::Drags, "New LineDrag\n");
2947 LineDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*cursor*/)
2949 _line = reinterpret_cast<AutomationLine*> (_item->get_data ("line"));
2952 _item = &_line->grab_item ();
2954 /* need to get x coordinate in terms of parent (TimeAxisItemView)
2955 origin, and ditto for y.
2958 double cx = event->button.x;
2959 double cy = event->button.y;
2961 _line->parent_group().w2i (cx, cy);
2963 framecnt_t const frame_within_region = (framecnt_t) floor (cx * _editor->frames_per_unit);
2968 if (!_line->control_points_adjacent (frame_within_region, before, after)) {
2969 /* no adjacent points */
2973 Drag::start_grab (event, _editor->cursors()->fader);
2975 /* store grab start in parent frame */
2980 double fraction = 1.0 - (cy / _line->height());
2982 _line->start_drag_line (before, after, fraction);
2984 _editor->verbose_cursor()->set (_line->get_verbose_cursor_string (fraction),
2985 event->button.x + 10, event->button.y + 10);
2987 _editor->verbose_cursor()->show ();
2991 LineDrag::motion (GdkEvent* event, bool)
2993 double dy = _drags->current_pointer_y() - last_pointer_y();
2995 if (event->button.state & Keyboard::SecondaryModifier) {
2999 double cy = _fixed_grab_y + _cumulative_y_drag + dy;
3001 _cumulative_y_drag = cy - _fixed_grab_y;
3004 cy = min ((double) _line->height(), cy);
3006 double const fraction = 1.0 - (cy / _line->height());
3007 bool const push = !Keyboard::modifier_state_contains (event->button.state, Keyboard::PrimaryModifier);
3009 /* we are ignoring x position for this drag, so we can just pass in anything */
3010 _line->drag_motion (0, fraction, true, push);
3012 _editor->verbose_cursor()->set_text (_line->get_verbose_cursor_string (fraction));
3016 LineDrag::finished (GdkEvent* event, bool)
3018 motion (event, false);
3020 _editor->session()->commit_reversible_command ();
3024 LineDrag::aborted (bool)
3029 FeatureLineDrag::FeatureLineDrag (Editor* e, ArdourCanvas::Item* i)
3032 _cumulative_x_drag (0)
3034 DEBUG_TRACE (DEBUG::Drags, "New FeatureLineDrag\n");
3038 FeatureLineDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*cursor*/)
3040 Drag::start_grab (event);
3042 _line = reinterpret_cast<Line*> (_item);
3045 /* need to get x coordinate in terms of parent (AudioRegionView) origin. */
3047 double cx = event->button.x;
3048 double cy = event->button.y;
3050 _item->property_parent().get_value()->w2i(cx, cy);
3052 /* store grab start in parent frame */
3053 _region_view_grab_x = cx;
3055 _before = *(float*) _item->get_data ("position");
3057 _arv = reinterpret_cast<AudioRegionView*> (_item->get_data ("regionview"));
3059 _max_x = _editor->frame_to_pixel(_arv->get_duration());
3063 FeatureLineDrag::motion (GdkEvent*, bool)
3065 double dx = _drags->current_pointer_x() - last_pointer_x();
3067 double cx = _region_view_grab_x + _cumulative_x_drag + dx;
3069 _cumulative_x_drag += dx;
3071 /* Clamp the min and max extent of the drag to keep it within the region view bounds */
3080 ArdourCanvas::Points points;
3082 double x1 = 0, x2 = 0, y1 = 0, y2 = 0;
3084 _line->get_bounds(x1, y2, x2, y2);
3086 points.push_back(Gnome::Art::Point(cx, 2.0)); // first x-coord needs to be a non-normal value
3087 points.push_back(Gnome::Art::Point(cx, y2 - y1));
3089 _line->property_points() = points;
3091 float *pos = new float;
3094 _line->set_data ("position", pos);
3100 FeatureLineDrag::finished (GdkEvent*, bool)
3102 _arv = reinterpret_cast<AudioRegionView*> (_item->get_data ("regionview"));
3103 _arv->update_transient(_before, _before);
3107 FeatureLineDrag::aborted (bool)
3112 RubberbandSelectDrag::RubberbandSelectDrag (Editor* e, ArdourCanvas::Item* i)
3114 , _vertical_only (false)
3116 DEBUG_TRACE (DEBUG::Drags, "New RubberbandSelectDrag\n");
3120 RubberbandSelectDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
3122 Drag::start_grab (event);
3123 show_verbose_cursor_time (adjusted_current_frame (event));
3127 RubberbandSelectDrag::motion (GdkEvent* event, bool)
3134 framepos_t const pf = adjusted_current_frame (event, Config->get_rubberbanding_snaps_to_grid ());
3136 framepos_t grab = grab_frame ();
3137 if (Config->get_rubberbanding_snaps_to_grid ()) {
3138 _editor->snap_to_with_modifier (grab, event);
3141 /* base start and end on initial click position */
3151 if (_drags->current_pointer_y() < grab_y()) {
3152 y1 = _drags->current_pointer_y();
3155 y2 = _drags->current_pointer_y();
3160 if (start != end || y1 != y2) {
3162 double x1 = _editor->frame_to_pixel (start);
3163 double x2 = _editor->frame_to_pixel (end);
3165 _editor->rubberband_rect->property_x1() = x1;
3166 if (_vertical_only) {
3167 /* fixed 10 pixel width */
3168 _editor->rubberband_rect->property_x2() = x1 + 10;
3170 _editor->rubberband_rect->property_x2() = x2;
3173 _editor->rubberband_rect->property_y1() = y1;
3174 _editor->rubberband_rect->property_y2() = y2;
3176 _editor->rubberband_rect->show();
3177 _editor->rubberband_rect->raise_to_top();
3179 show_verbose_cursor_time (pf);
3181 do_select_things (event, true);
3186 RubberbandSelectDrag::do_select_things (GdkEvent* event, bool drag_in_progress)
3191 if (grab_frame() < last_pointer_frame()) {
3193 x2 = last_pointer_frame ();
3196 x1 = last_pointer_frame ();
3202 if (_drags->current_pointer_y() < grab_y()) {
3203 y1 = _drags->current_pointer_y();
3206 y2 = _drags->current_pointer_y();
3210 select_things (event->button.state, x1, x2, y1, y2, drag_in_progress);
3214 RubberbandSelectDrag::finished (GdkEvent* event, bool movement_occurred)
3216 if (movement_occurred) {
3218 motion (event, false);
3219 do_select_things (event, false);
3225 bool do_deselect = true;
3226 MidiTimeAxisView* mtv;
3228 if ((mtv = dynamic_cast<MidiTimeAxisView*>(_editor->clicked_axisview)) != 0) {
3230 if (_editor->selection->empty()) {
3231 /* nothing selected */
3232 add_midi_region (mtv);
3233 do_deselect = false;
3243 _editor->rubberband_rect->hide();
3247 RubberbandSelectDrag::aborted (bool)
3249 _editor->rubberband_rect->hide ();
3252 TimeFXDrag::TimeFXDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, std::list<RegionView*> const & v)
3253 : RegionDrag (e, i, p, v)
3255 DEBUG_TRACE (DEBUG::Drags, "New TimeFXDrag\n");
3259 TimeFXDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
3261 Drag::start_grab (event, cursor);
3263 show_verbose_cursor_time (adjusted_current_frame (event));
3267 TimeFXDrag::motion (GdkEvent* event, bool)
3269 RegionView* rv = _primary;
3270 StreamView* cv = rv->get_time_axis_view().view ();
3272 pair<TimeAxisView*, double> const tv = _editor->trackview_by_y_position (grab_y());
3273 int layer = tv.first->layer_display() == Overlaid ? 0 : tv.second;
3274 int layers = tv.first->layer_display() == Overlaid ? 1 : cv->layers();
3276 framepos_t const pf = adjusted_current_frame (event);
3278 if (pf > rv->region()->position()) {
3279 rv->get_time_axis_view().show_timestretch (rv->region()->position(), pf, layers, layer);
3282 show_verbose_cursor_time (pf);
3286 TimeFXDrag::finished (GdkEvent* /*event*/, bool movement_occurred)
3288 _primary->get_time_axis_view().hide_timestretch ();
3290 if (!movement_occurred) {
3294 if (last_pointer_frame() < _primary->region()->position()) {
3295 /* backwards drag of the left edge - not usable */
3299 framecnt_t newlen = last_pointer_frame() - _primary->region()->position();
3301 float percentage = (double) newlen / (double) _primary->region()->length();
3303 #ifndef USE_RUBBERBAND
3304 // Soundtouch uses percentage / 100 instead of normal (/ 1)
3305 if (_primary->region()->data_type() == DataType::AUDIO) {
3306 percentage = (float) ((double) newlen - (double) _primary->region()->length()) / ((double) newlen) * 100.0f;
3310 if (!_editor->get_selection().regions.empty()) {
3311 /* primary will already be included in the selection, and edit
3312 group shared editing will propagate selection across
3313 equivalent regions, so just use the current region
3317 if (_editor->time_stretch (_editor->get_selection().regions, percentage) == -1) {
3318 error << _("An error occurred while executing time stretch operation") << endmsg;
3324 TimeFXDrag::aborted (bool)
3326 _primary->get_time_axis_view().hide_timestretch ();
3329 ScrubDrag::ScrubDrag (Editor* e, ArdourCanvas::Item* i)
3332 DEBUG_TRACE (DEBUG::Drags, "New ScrubDrag\n");
3336 ScrubDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
3338 Drag::start_grab (event);
3342 ScrubDrag::motion (GdkEvent* /*event*/, bool)
3344 _editor->scrub (adjusted_current_frame (0, false), _drags->current_pointer_x ());
3348 ScrubDrag::finished (GdkEvent* /*event*/, bool movement_occurred)
3350 if (movement_occurred && _editor->session()) {
3351 /* make sure we stop */
3352 _editor->session()->request_transport_speed (0.0);
3357 ScrubDrag::aborted (bool)
3362 SelectionDrag::SelectionDrag (Editor* e, ArdourCanvas::Item* i, Operation o)
3366 , _original_pointer_time_axis (-1)
3367 , _last_pointer_time_axis (-1)
3368 , _time_selection_at_start (!_editor->get_selection().time.empty())
3370 DEBUG_TRACE (DEBUG::Drags, "New SelectionDrag\n");
3374 SelectionDrag::start_grab (GdkEvent* event, Gdk::Cursor*)
3376 if (_editor->session() == 0) {
3380 Gdk::Cursor* cursor = 0;
3382 switch (_operation) {
3383 case CreateSelection:
3384 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
3389 cursor = _editor->cursors()->selector;
3390 Drag::start_grab (event, cursor);
3393 case SelectionStartTrim:
3394 if (_editor->clicked_axisview) {
3395 _editor->clicked_axisview->order_selection_trims (_item, true);
3397 Drag::start_grab (event, _editor->cursors()->left_side_trim);
3400 case SelectionEndTrim:
3401 if (_editor->clicked_axisview) {
3402 _editor->clicked_axisview->order_selection_trims (_item, false);
3404 Drag::start_grab (event, _editor->cursors()->right_side_trim);
3408 Drag::start_grab (event, cursor);
3412 if (_operation == SelectionMove) {
3413 show_verbose_cursor_time (_editor->selection->time[_editor->clicked_selection].start);
3415 show_verbose_cursor_time (adjusted_current_frame (event));
3418 _original_pointer_time_axis = _editor->trackview_by_y_position (_drags->current_pointer_y ()).first->order ();
3422 SelectionDrag::setup_pointer_frame_offset ()
3424 switch (_operation) {
3425 case CreateSelection:
3426 _pointer_frame_offset = 0;
3429 case SelectionStartTrim:
3431 _pointer_frame_offset = raw_grab_frame() - _editor->selection->time[_editor->clicked_selection].start;
3434 case SelectionEndTrim:
3435 _pointer_frame_offset = raw_grab_frame() - _editor->selection->time[_editor->clicked_selection].end;
3441 SelectionDrag::motion (GdkEvent* event, bool first_move)
3443 framepos_t start = 0;
3447 pair<TimeAxisView*, int> const pending_time_axis = _editor->trackview_by_y_position (_drags->current_pointer_y ());
3448 if (pending_time_axis.first == 0) {
3452 framepos_t const pending_position = adjusted_current_frame (event);
3454 /* only alter selection if things have changed */
3456 if (pending_time_axis.first->order() == _last_pointer_time_axis && pending_position == last_pointer_frame()) {
3460 switch (_operation) {
3461 case CreateSelection:
3463 framepos_t grab = grab_frame ();
3466 grab = adjusted_current_frame (event, false);
3467 if (grab < pending_position) {
3468 _editor->snap_to (grab, -1);
3470 _editor->snap_to (grab, 1);
3474 if (pending_position < grab) {
3475 start = pending_position;
3478 end = pending_position;
3482 /* first drag: Either add to the selection
3483 or create a new selection
3489 /* adding to the selection */
3490 _editor->set_selected_track_as_side_effect (Selection::Add);
3491 //_editor->selection->add (_editor->clicked_axisview);
3492 _editor->clicked_selection = _editor->selection->add (start, end);
3497 if (_editor->clicked_axisview && !_editor->selection->selected (_editor->clicked_axisview)) {
3498 //_editor->selection->set (_editor->clicked_axisview);
3499 _editor->set_selected_track_as_side_effect (Selection::Set);
3502 _editor->clicked_selection = _editor->selection->set (start, end);
3506 /* select the track that we're in */
3507 if (find (_added_time_axes.begin(), _added_time_axes.end(), pending_time_axis.first) == _added_time_axes.end()) {
3508 // _editor->set_selected_track_as_side_effect (Selection::Add);
3509 _editor->selection->add (pending_time_axis.first);
3510 _added_time_axes.push_back (pending_time_axis.first);
3513 /* deselect any tracks that this drag no longer includes, being careful to only deselect
3514 tracks that we selected in the first place.
3517 int min_order = min (_original_pointer_time_axis, pending_time_axis.first->order());
3518 int max_order = max (_original_pointer_time_axis, pending_time_axis.first->order());
3520 list<TimeAxisView*>::iterator i = _added_time_axes.begin();
3521 while (i != _added_time_axes.end()) {
3523 list<TimeAxisView*>::iterator tmp = i;
3526 if ((*i)->order() < min_order || (*i)->order() > max_order) {
3527 _editor->selection->remove (*i);
3528 _added_time_axes.remove (*i);
3537 case SelectionStartTrim:
3539 start = _editor->selection->time[_editor->clicked_selection].start;
3540 end = _editor->selection->time[_editor->clicked_selection].end;
3542 if (pending_position > end) {
3545 start = pending_position;
3549 case SelectionEndTrim:
3551 start = _editor->selection->time[_editor->clicked_selection].start;
3552 end = _editor->selection->time[_editor->clicked_selection].end;
3554 if (pending_position < start) {
3557 end = pending_position;
3564 start = _editor->selection->time[_editor->clicked_selection].start;
3565 end = _editor->selection->time[_editor->clicked_selection].end;
3567 length = end - start;
3569 start = pending_position;
3570 _editor->snap_to (start);
3572 end = start + length;
3577 if (event->button.x >= _editor->horizontal_position() + _editor->_canvas_width) {
3578 _editor->start_canvas_autoscroll (1, 0);
3582 _editor->selection->replace (_editor->clicked_selection, start, end);
3585 if (_operation == SelectionMove) {
3586 show_verbose_cursor_time(start);
3588 show_verbose_cursor_time(pending_position);
3593 SelectionDrag::finished (GdkEvent* event, bool movement_occurred)
3595 Session* s = _editor->session();
3597 if (movement_occurred) {
3598 motion (event, false);
3599 /* XXX this is not object-oriented programming at all. ick */
3600 if (_editor->selection->time.consolidate()) {
3601 _editor->selection->TimeChanged ();
3604 /* XXX what if its a music time selection? */
3606 if ((s->config.get_auto_play() || (s->get_play_range() && s->transport_rolling()))) {
3607 s->request_play_range (&_editor->selection->time, true);
3609 if (Config->get_always_play_range()) {
3610 s->request_locate (_editor->get_selection().time.start());
3616 /* just a click, no pointer movement.
3618 _editor->selection->clear_time();
3620 if (_editor->clicked_axisview && !_editor->selection->selected (_editor->clicked_axisview)) {
3621 _editor->selection->set (_editor->clicked_axisview);
3624 if (s && s->get_play_range () && s->transport_rolling()) {
3625 s->request_stop (false, false);
3630 _editor->stop_canvas_autoscroll ();
3634 SelectionDrag::aborted (bool)
3639 RangeMarkerBarDrag::RangeMarkerBarDrag (Editor* e, ArdourCanvas::Item* i, Operation o)
3644 DEBUG_TRACE (DEBUG::Drags, "New RangeMarkerBarDrag\n");
3646 _drag_rect = new ArdourCanvas::SimpleRect (*_editor->time_line_group, 0.0, 0.0, 0.0,
3647 physical_screen_height (_editor->get_window()));
3648 _drag_rect->hide ();
3650 _drag_rect->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_RangeDragRect.get();
3651 _drag_rect->property_outline_color_rgba() = ARDOUR_UI::config()->canvasvar_RangeDragRect.get();
3655 RangeMarkerBarDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
3657 if (_editor->session() == 0) {
3661 Gdk::Cursor* cursor = 0;
3663 if (!_editor->temp_location) {
3664 _editor->temp_location = new Location (*_editor->session());
3667 switch (_operation) {
3668 case CreateRangeMarker:
3669 case CreateTransportMarker:
3670 case CreateCDMarker:
3672 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
3677 cursor = _editor->cursors()->selector;
3681 Drag::start_grab (event, cursor);
3683 show_verbose_cursor_time (adjusted_current_frame (event));
3687 RangeMarkerBarDrag::motion (GdkEvent* event, bool first_move)
3689 framepos_t start = 0;
3691 ArdourCanvas::SimpleRect *crect;
3693 switch (_operation) {
3694 case CreateRangeMarker:
3695 crect = _editor->range_bar_drag_rect;
3697 case CreateTransportMarker:
3698 crect = _editor->transport_bar_drag_rect;
3700 case CreateCDMarker:
3701 crect = _editor->cd_marker_bar_drag_rect;
3704 error << string_compose (_("programming_error: %1"), "Error: unknown range marker op passed to Editor::drag_range_markerbar_op ()") << endmsg;
3709 framepos_t const pf = adjusted_current_frame (event);
3711 if (_operation == CreateRangeMarker || _operation == CreateTransportMarker || _operation == CreateCDMarker) {
3712 framepos_t grab = grab_frame ();
3713 _editor->snap_to (grab);
3715 if (pf < grab_frame()) {
3723 /* first drag: Either add to the selection
3724 or create a new selection.
3729 _editor->temp_location->set (start, end);
3733 update_item (_editor->temp_location);
3735 //_drag_rect->raise_to_top();
3740 if (event->button.x >= _editor->horizontal_position() + _editor->_canvas_width) {
3741 _editor->start_canvas_autoscroll (1, 0);
3745 _editor->temp_location->set (start, end);
3747 double x1 = _editor->frame_to_pixel (start);
3748 double x2 = _editor->frame_to_pixel (end);
3749 crect->property_x1() = x1;
3750 crect->property_x2() = x2;
3752 update_item (_editor->temp_location);
3755 show_verbose_cursor_time (pf);
3760 RangeMarkerBarDrag::finished (GdkEvent* event, bool movement_occurred)
3762 Location * newloc = 0;
3766 if (movement_occurred) {
3767 motion (event, false);
3770 switch (_operation) {
3771 case CreateRangeMarker:
3772 case CreateCDMarker:
3774 _editor->begin_reversible_command (_("new range marker"));
3775 XMLNode &before = _editor->session()->locations()->get_state();
3776 _editor->session()->locations()->next_available_name(rangename,"unnamed");
3777 if (_operation == CreateCDMarker) {
3778 flags = Location::IsRangeMarker | Location::IsCDMarker;
3779 _editor->cd_marker_bar_drag_rect->hide();
3782 flags = Location::IsRangeMarker;
3783 _editor->range_bar_drag_rect->hide();
3785 newloc = new Location (
3786 *_editor->session(), _editor->temp_location->start(), _editor->temp_location->end(), rangename, (Location::Flags) flags
3789 _editor->session()->locations()->add (newloc, true);
3790 XMLNode &after = _editor->session()->locations()->get_state();
3791 _editor->session()->add_command(new MementoCommand<Locations>(*(_editor->session()->locations()), &before, &after));
3792 _editor->commit_reversible_command ();
3796 case CreateTransportMarker:
3797 // popup menu to pick loop or punch
3798 _editor->new_transport_marker_context_menu (&event->button, _item);
3802 /* just a click, no pointer movement. remember that context menu stuff was handled elsewhere */
3804 if (Keyboard::no_modifier_keys_pressed (&event->button) && _operation != CreateCDMarker) {
3809 _editor->session()->locations()->marks_either_side (grab_frame(), start, end);
3811 if (end == max_framepos) {
3812 end = _editor->session()->current_end_frame ();
3815 if (start == max_framepos) {
3816 start = _editor->session()->current_start_frame ();
3819 switch (_editor->mouse_mode) {
3821 /* find the two markers on either side and then make the selection from it */
3822 _editor->select_all_within (start, end, 0.0f, FLT_MAX, _editor->track_views, Selection::Set, false);
3826 /* find the two markers on either side of the click and make the range out of it */
3827 _editor->selection->set (start, end);
3836 _editor->stop_canvas_autoscroll ();
3840 RangeMarkerBarDrag::aborted (bool)
3846 RangeMarkerBarDrag::update_item (Location* location)
3848 double const x1 = _editor->frame_to_pixel (location->start());
3849 double const x2 = _editor->frame_to_pixel (location->end());
3851 _drag_rect->property_x1() = x1;
3852 _drag_rect->property_x2() = x2;
3855 MouseZoomDrag::MouseZoomDrag (Editor* e, ArdourCanvas::Item* i)
3859 DEBUG_TRACE (DEBUG::Drags, "New MouseZoomDrag\n");
3863 MouseZoomDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
3865 if (Keyboard::the_keyboard().key_is_down (GDK_Control_L)) {
3866 Drag::start_grab (event, _editor->cursors()->zoom_out);
3869 Drag::start_grab (event, _editor->cursors()->zoom_in);
3873 show_verbose_cursor_time (adjusted_current_frame (event));
3877 MouseZoomDrag::motion (GdkEvent* event, bool first_move)
3882 framepos_t const pf = adjusted_current_frame (event);
3884 framepos_t grab = grab_frame ();
3885 _editor->snap_to_with_modifier (grab, event);
3887 /* base start and end on initial click position */
3899 _editor->zoom_rect->show();
3900 _editor->zoom_rect->raise_to_top();
3903 _editor->reposition_zoom_rect(start, end);
3905 show_verbose_cursor_time (pf);
3910 MouseZoomDrag::finished (GdkEvent* event, bool movement_occurred)
3912 if (movement_occurred) {
3913 motion (event, false);
3915 if (grab_frame() < last_pointer_frame()) {
3916 _editor->temporal_zoom_by_frame (grab_frame(), last_pointer_frame());
3918 _editor->temporal_zoom_by_frame (last_pointer_frame(), grab_frame());
3921 if (Keyboard::the_keyboard().key_is_down (GDK_Shift_L)) {
3922 _editor->tav_zoom_step (_zoom_out);
3924 _editor->temporal_zoom_to_frame (_zoom_out, grab_frame());
3928 _editor->zoom_rect->hide();
3932 MouseZoomDrag::aborted (bool)
3934 _editor->zoom_rect->hide ();
3937 NoteDrag::NoteDrag (Editor* e, ArdourCanvas::Item* i)
3939 , _cumulative_dx (0)
3940 , _cumulative_dy (0)
3942 DEBUG_TRACE (DEBUG::Drags, "New NoteDrag\n");
3944 _primary = dynamic_cast<CanvasNoteEvent*> (_item);
3945 _region = &_primary->region_view ();
3946 _note_height = _region->midi_stream_view()->note_height ();
3950 NoteDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
3952 Drag::start_grab (event);
3954 if (!(_was_selected = _primary->selected())) {
3956 /* tertiary-click means extend selection - we'll do that on button release,
3957 so don't add it here, because otherwise we make it hard to figure
3958 out the "extend-to" range.
3961 bool extend = Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier);
3964 bool add = Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier);
3967 _region->note_selected (_primary, true);
3969 _region->unique_select (_primary);
3975 /** @return Current total drag x change in frames */
3977 NoteDrag::total_dx () const
3980 frameoffset_t const dx = _editor->unit_to_frame (_drags->current_pointer_x() - grab_x());
3982 /* primary note time */
3983 frameoffset_t const n = _region->source_beats_to_absolute_frames (_primary->note()->time ());
3985 /* new time of the primary note in session frames */
3986 frameoffset_t st = n + dx;
3988 framepos_t const rp = _region->region()->position ();
3990 /* prevent the note being dragged earlier than the region's position */
3993 /* snap and return corresponding delta */
3994 return _region->snap_frame_to_frame (st - rp) + rp - n;
3997 /** @return Current total drag y change in note number */
3999 NoteDrag::total_dy () const
4001 MidiStreamView* msv = _region->midi_stream_view ();
4002 double const y = _region->midi_view()->y_position ();
4003 /* new current note */
4004 uint8_t n = msv->y_to_note (_drags->current_pointer_y () - y);
4006 n = max (msv->lowest_note(), n);
4007 n = min (msv->highest_note(), n);
4008 /* and work out delta */
4009 return n - msv->y_to_note (grab_y() - y);
4013 NoteDrag::motion (GdkEvent *, bool)
4015 /* Total change in x and y since the start of the drag */
4016 frameoffset_t const dx = total_dx ();
4017 int8_t const dy = total_dy ();
4019 /* Now work out what we have to do to the note canvas items to set this new drag delta */
4020 double const tdx = _editor->frame_to_unit (dx) - _cumulative_dx;
4021 double const tdy = -dy * _note_height - _cumulative_dy;
4024 _cumulative_dx += tdx;
4025 _cumulative_dy += tdy;
4027 int8_t note_delta = total_dy();
4029 _region->move_selection (tdx, tdy, note_delta);
4031 /* the new note value may be the same as the old one, but we
4032 * don't know what that means because the selection may have
4033 * involved more than one note and we might be doing something
4034 * odd with them. so show the note value anyway, always.
4038 uint8_t new_note = min (max (_primary->note()->note() + note_delta, 0), 127);
4040 snprintf (buf, sizeof (buf), "%s (%d)", Evoral::midi_note_name (new_note).c_str(),
4041 (int) floor (new_note));
4043 show_verbose_cursor_text (buf);
4048 NoteDrag::finished (GdkEvent* ev, bool moved)
4051 /* no motion - select note */
4053 if (_editor->current_mouse_mode() == Editing::MouseObject ||
4054 _editor->current_mouse_mode() == Editing::MouseDraw) {
4056 if (_was_selected) {
4057 bool add = Keyboard::modifier_state_equals (ev->button.state, Keyboard::PrimaryModifier);
4059 _region->note_deselected (_primary);
4062 bool extend = Keyboard::modifier_state_equals (ev->button.state, Keyboard::TertiaryModifier);
4063 bool add = Keyboard::modifier_state_equals (ev->button.state, Keyboard::PrimaryModifier);
4065 if (!extend && !add && _region->selection_size() > 1) {
4066 _region->unique_select (_primary);
4067 } else if (extend) {
4068 _region->note_selected (_primary, true, true);
4070 /* it was added during button press */
4075 _region->note_dropped (_primary, total_dx(), total_dy());
4080 NoteDrag::aborted (bool)
4085 /** Make an AutomationRangeDrag for lines in an AutomationTimeAxisView */
4086 AutomationRangeDrag::AutomationRangeDrag (Editor* editor, AutomationTimeAxisView* atv, list<AudioRange> const & r)
4087 : Drag (editor, atv->base_item ())
4089 , _nothing_to_drag (false)
4091 DEBUG_TRACE (DEBUG::Drags, "New AutomationRangeDrag\n");
4092 y_origin = atv->y_position();
4093 setup (atv->lines ());
4096 /** Make an AutomationRangeDrag for region gain lines */
4097 AutomationRangeDrag::AutomationRangeDrag (Editor* editor, AudioRegionView* rv, list<AudioRange> const & r)
4098 : Drag (editor, rv->get_canvas_group ())
4100 , _nothing_to_drag (false)
4102 DEBUG_TRACE (DEBUG::Drags, "New AutomationRangeDrag\n");
4104 list<boost::shared_ptr<AutomationLine> > lines;
4105 lines.push_back (rv->get_gain_line ());
4106 y_origin = rv->get_time_axis_view().y_position();
4110 /** @param lines AutomationLines to drag.
4111 * @param offset Offset from the session start to the points in the AutomationLines.
4114 AutomationRangeDrag::setup (list<boost::shared_ptr<AutomationLine> > const & lines)
4116 /* find the lines that overlap the ranges being dragged */
4117 list<boost::shared_ptr<AutomationLine> >::const_iterator i = lines.begin ();
4118 while (i != lines.end ()) {
4119 list<boost::shared_ptr<AutomationLine> >::const_iterator j = i;
4122 pair<framepos_t, framepos_t> r = (*i)->get_point_x_range ();
4124 /* check this range against all the AudioRanges that we are using */
4125 list<AudioRange>::const_iterator k = _ranges.begin ();
4126 while (k != _ranges.end()) {
4127 if (k->coverage (r.first, r.second) != Evoral::OverlapNone) {
4133 /* add it to our list if it overlaps at all */
4134 if (k != _ranges.end()) {
4139 _lines.push_back (n);
4145 /* Now ::lines contains the AutomationLines that somehow overlap our drag */
4149 AutomationRangeDrag::y_fraction (boost::shared_ptr<AutomationLine> line, double global_y) const
4151 return 1.0 - ((global_y - y_origin) / line->height());
4155 AutomationRangeDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
4157 Drag::start_grab (event, cursor);
4159 /* Get line states before we start changing things */
4160 for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
4161 i->state = &i->line->get_state ();
4162 i->original_fraction = y_fraction (i->line, _drags->current_pointer_y());
4165 if (_ranges.empty()) {
4167 /* No selected time ranges: drag all points */
4168 for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
4169 uint32_t const N = i->line->npoints ();
4170 for (uint32_t j = 0; j < N; ++j) {
4171 i->points.push_back (i->line->nth (j));
4177 for (list<AudioRange>::const_iterator i = _ranges.begin(); i != _ranges.end(); ++i) {
4179 framecnt_t const half = (i->start + i->end) / 2;
4181 /* find the line that this audio range starts in */
4182 list<Line>::iterator j = _lines.begin();
4183 while (j != _lines.end() && (j->range.first > i->start || j->range.second < i->start)) {
4187 if (j != _lines.end()) {
4188 boost::shared_ptr<AutomationList> the_list = j->line->the_list ();
4190 /* j is the line that this audio range starts in; fade into it;
4191 64 samples length plucked out of thin air.
4194 framepos_t a = i->start + 64;
4199 double const p = j->line->time_converter().from (i->start - j->line->time_converter().origin_b ());
4200 double const q = j->line->time_converter().from (a - j->line->time_converter().origin_b ());
4202 the_list->add (p, the_list->eval (p));
4203 the_list->add (q, the_list->eval (q));
4206 /* same thing for the end */
4209 while (j != _lines.end() && (j->range.first > i->end || j->range.second < i->end)) {
4213 if (j != _lines.end()) {
4214 boost::shared_ptr<AutomationList> the_list = j->line->the_list ();
4216 /* j is the line that this audio range starts in; fade out of it;
4217 64 samples length plucked out of thin air.
4220 framepos_t b = i->end - 64;
4225 double const p = j->line->time_converter().from (b - j->line->time_converter().origin_b ());
4226 double const q = j->line->time_converter().from (i->end - j->line->time_converter().origin_b ());
4228 the_list->add (p, the_list->eval (p));
4229 the_list->add (q, the_list->eval (q));
4233 _nothing_to_drag = true;
4235 /* Find all the points that should be dragged and put them in the relevant
4236 points lists in the Line structs.
4239 for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
4241 uint32_t const N = i->line->npoints ();
4242 for (uint32_t j = 0; j < N; ++j) {
4244 /* here's a control point on this line */
4245 ControlPoint* p = i->line->nth (j);
4246 double const w = i->line->time_converter().to ((*p->model())->when) + i->line->time_converter().origin_b ();
4248 /* see if it's inside a range */
4249 list<AudioRange>::const_iterator k = _ranges.begin ();
4250 while (k != _ranges.end() && (k->start >= w || k->end <= w)) {
4254 if (k != _ranges.end()) {
4255 /* dragging this point */
4256 _nothing_to_drag = false;
4257 i->points.push_back (p);
4263 if (_nothing_to_drag) {
4267 for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
4268 i->line->start_drag_multiple (i->points, y_fraction (i->line, _drags->current_pointer_y()), i->state);
4273 AutomationRangeDrag::motion (GdkEvent*, bool /*first_move*/)
4275 if (_nothing_to_drag) {
4279 for (list<Line>::iterator l = _lines.begin(); l != _lines.end(); ++l) {
4280 float const f = y_fraction (l->line, _drags->current_pointer_y());
4281 /* we are ignoring x position for this drag, so we can just pass in anything */
4282 l->line->drag_motion (0, f, true, false);
4283 show_verbose_cursor_text (l->line->get_verbose_cursor_relative_string (l->original_fraction, f));
4288 AutomationRangeDrag::finished (GdkEvent* event, bool)
4290 if (_nothing_to_drag) {
4294 motion (event, false);
4295 for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
4296 i->line->end_drag ();
4299 _editor->session()->commit_reversible_command ();
4303 AutomationRangeDrag::aborted (bool)
4305 for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
4310 DraggingView::DraggingView (RegionView* v, RegionDrag* parent)
4313 time_axis_view = parent->find_time_axis_view (&v->get_time_axis_view ());
4314 layer = v->region()->layer ();
4315 initial_y = v->get_canvas_group()->property_y ();
4316 initial_playlist = v->region()->playlist ();
4317 initial_position = v->region()->position ();
4318 initial_end = v->region()->position () + v->region()->length ();
4321 PatchChangeDrag::PatchChangeDrag (Editor* e, CanvasPatchChange* i, MidiRegionView* r)
4325 , _cumulative_dx (0)
4327 DEBUG_TRACE (DEBUG::Drags, string_compose ("New PatchChangeDrag, patch @ %1, grab @ %2\n",
4328 _region_view->source_beats_to_absolute_frames (_patch_change->patch()->time()),
4333 PatchChangeDrag::motion (GdkEvent* ev, bool)
4335 framepos_t f = adjusted_current_frame (ev);
4336 boost::shared_ptr<Region> r = _region_view->region ();
4337 f = max (f, r->position ());
4338 f = min (f, r->last_frame ());
4340 framecnt_t const dxf = f - grab_frame(); // permitted dx in frames
4341 double const dxu = _editor->frame_to_unit (dxf); // permitted fx in units
4342 _patch_change->move (dxu - _cumulative_dx, 0);
4343 _cumulative_dx = dxu;
4347 PatchChangeDrag::finished (GdkEvent* ev, bool movement_occurred)
4349 if (!movement_occurred) {
4353 boost::shared_ptr<Region> r (_region_view->region ());
4354 framepos_t f = adjusted_current_frame (ev);
4355 f = max (f, r->position ());
4356 f = min (f, r->last_frame ());
4358 _region_view->move_patch_change (
4360 _region_view->region_frames_to_region_beats (f - (r->position() - r->start()))
4365 PatchChangeDrag::aborted (bool)
4367 _patch_change->move (-_cumulative_dx, 0);
4371 PatchChangeDrag::setup_pointer_frame_offset ()
4373 boost::shared_ptr<Region> region = _region_view->region ();
4374 _pointer_frame_offset = raw_grab_frame() - _region_view->source_beats_to_absolute_frames (_patch_change->patch()->time());
4377 MidiRubberbandSelectDrag::MidiRubberbandSelectDrag (Editor* e, MidiRegionView* rv)
4378 : RubberbandSelectDrag (e, rv->get_canvas_frame ())
4385 MidiRubberbandSelectDrag::select_things (int button_state, framepos_t x1, framepos_t x2, double y1, double y2, bool /*drag_in_progress*/)
4387 framepos_t const p = _region_view->region()->position ();
4388 double const y = _region_view->midi_view()->y_position ();
4390 x1 = max ((framepos_t) 0, x1 - p);
4391 x2 = max ((framepos_t) 0, x2 - p);
4392 y1 = max (0.0, y1 - y);
4393 y2 = max (0.0, y2 - y);
4395 _region_view->update_drag_selection (
4396 _editor->frame_to_pixel (x1),
4397 _editor->frame_to_pixel (x2),
4400 Keyboard::modifier_state_contains (button_state, Keyboard::TertiaryModifier)
4405 MidiRubberbandSelectDrag::deselect_things ()
4410 MidiVerticalSelectDrag::MidiVerticalSelectDrag (Editor* e, MidiRegionView* rv)
4411 : RubberbandSelectDrag (e, rv->get_canvas_frame ())
4414 _vertical_only = true;
4418 MidiVerticalSelectDrag::select_things (int button_state, framepos_t /*x1*/, framepos_t /*x2*/, double y1, double y2, bool /*drag_in_progress*/)
4420 double const y = _region_view->midi_view()->y_position ();
4422 y1 = max (0.0, y1 - y);
4423 y2 = max (0.0, y2 - y);
4425 _region_view->update_vertical_drag_selection (
4428 Keyboard::modifier_state_contains (button_state, Keyboard::TertiaryModifier)
4433 MidiVerticalSelectDrag::deselect_things ()
4438 EditorRubberbandSelectDrag::EditorRubberbandSelectDrag (Editor* e, ArdourCanvas::Item* i)
4439 : RubberbandSelectDrag (e, i)
4445 EditorRubberbandSelectDrag::select_things (int button_state, framepos_t x1, framepos_t x2, double y1, double y2, bool drag_in_progress)
4447 if (drag_in_progress) {
4448 /* We just want to select things at the end of the drag, not during it */
4452 Selection::Operation op = ArdourKeyboard::selection_type (button_state);
4454 _editor->begin_reversible_command (_("rubberband selection"));
4455 _editor->select_all_within (x1, x2 - 1, y1, y2, _editor->track_views, op, false);
4456 _editor->commit_reversible_command ();
4460 EditorRubberbandSelectDrag::deselect_things ()
4462 if (!getenv("ARDOUR_SAE")) {
4463 _editor->selection->clear_tracks();
4465 _editor->selection->clear_regions();
4466 _editor->selection->clear_points ();
4467 _editor->selection->clear_lines ();
4470 NoteCreateDrag::NoteCreateDrag (Editor* e, ArdourCanvas::Item* i, MidiRegionView* rv)
4478 NoteCreateDrag::~NoteCreateDrag ()
4484 NoteCreateDrag::grid_frames (framepos_t t) const
4487 Evoral::MusicalTime grid_beats = _editor->get_grid_type_as_beats (success, t);
4492 return _region_view->region_beats_to_region_frames (grid_beats);
4496 NoteCreateDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
4498 Drag::start_grab (event, cursor);
4500 _drag_rect = new ArdourCanvas::SimpleRect (*_region_view->get_canvas_group ());
4502 framepos_t pf = _drags->current_pointer_frame ();
4503 framecnt_t const g = grid_frames (pf);
4505 /* Hack so that we always snap to the note that we are over, instead of snapping
4506 to the next one if we're more than halfway through the one we're over.
4508 if (_editor->snap_mode() == SnapNormal && pf > g / 2) {
4512 _note[0] = adjusted_frame (pf, event) - _region_view->region()->position ();
4514 MidiStreamView* sv = _region_view->midi_stream_view ();
4515 double const x = _editor->frame_to_pixel (_note[0]);
4516 double const y = sv->note_to_y (sv->y_to_note (y_to_region (event->button.y)));
4518 _drag_rect->property_x1() = x;
4519 _drag_rect->property_y1() = y;
4520 _drag_rect->property_x2() = x;
4521 _drag_rect->property_y2() = y + floor (_region_view->midi_stream_view()->note_height ());
4523 _drag_rect->property_outline_what() = 0xff;
4524 _drag_rect->property_outline_color_rgba() = 0xffffff99;
4525 _drag_rect->property_fill_color_rgba() = 0xffffff66;
4529 NoteCreateDrag::motion (GdkEvent* event, bool)
4531 _note[1] = max ((framepos_t)0, adjusted_current_frame (event) - _region_view->region()->position ());
4532 double const x = _editor->frame_to_pixel (_note[1]);
4533 if (_note[1] > _note[0]) {
4534 _drag_rect->property_x2() = x;
4536 _drag_rect->property_x1() = x;
4541 NoteCreateDrag::finished (GdkEvent*, bool had_movement)
4543 if (!had_movement) {
4547 framepos_t const start = min (_note[0], _note[1]);
4548 framecnt_t length = abs (_note[0] - _note[1]);
4550 framecnt_t const g = grid_frames (start);
4551 double const one_tick = 1 / Timecode::BBT_Time::ticks_per_beat;
4553 if (_editor->snap_mode() == SnapNormal && length < g) {
4554 length = g - one_tick;
4557 double const length_beats = max (one_tick, _region_view->region_frames_to_region_beats (length));
4559 _region_view->create_note_at (start, _drag_rect->property_y1(), length_beats, false);
4563 NoteCreateDrag::y_to_region (double y) const
4566 _region_view->get_canvas_group()->w2i (x, y);
4571 NoteCreateDrag::aborted (bool)
4576 CrossfadeEdgeDrag::CrossfadeEdgeDrag (Editor* e, AudioRegionView* rv, ArdourCanvas::Item* i, bool start_yn)
4584 CrossfadeEdgeDrag::start_grab (GdkEvent* event, Gdk::Cursor *cursor)
4586 Drag::start_grab (event, cursor);
4590 CrossfadeEdgeDrag::motion (GdkEvent*, bool)
4596 boost::shared_ptr<AudioRegion> ar (arv->audio_region());
4599 distance = _drags->current_pointer_x() - grab_x();
4600 len = ar->fade_in()->back()->when;
4602 distance = grab_x() - _drags->current_pointer_x();
4603 len = ar->fade_out()->back()->when;
4606 /* how long should it be ? */
4608 new_length = len + _editor->unit_to_frame (distance);
4610 /* now check with the region that this is legal */
4612 new_length = ar->verify_xfade_bounds (new_length, start);
4615 arv->redraw_start_xfade_to (ar, new_length);
4617 arv->redraw_end_xfade_to (ar, new_length);
4622 CrossfadeEdgeDrag::finished (GdkEvent*, bool)
4628 boost::shared_ptr<AudioRegion> ar (arv->audio_region());
4631 distance = _drags->current_pointer_x() - grab_x();
4632 len = ar->fade_in()->back()->when;
4634 distance = grab_x() - _drags->current_pointer_x();
4635 len = ar->fade_out()->back()->when;
4638 new_length = ar->verify_xfade_bounds (len + _editor->unit_to_frame (distance), start);
4640 _editor->begin_reversible_command ("xfade trim");
4641 ar->playlist()->clear_owned_changes ();
4644 ar->set_fade_in_length (new_length);
4646 ar->set_fade_out_length (new_length);
4649 /* Adjusting the xfade may affect other regions in the playlist, so we need
4650 to get undo Commands from the whole playlist rather than just the
4654 vector<Command*> cmds;
4655 ar->playlist()->rdiff (cmds);
4656 _editor->session()->add_commands (cmds);
4657 _editor->commit_reversible_command ();
4662 CrossfadeEdgeDrag::aborted (bool)
4665 arv->redraw_start_xfade ();
4667 arv->redraw_end_xfade ();