X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Feditor_drag.cc;h=8d6838eb7658d5bdd4603b75e22ae0a6439e69a3;hb=895bad1dcd817cb8ad32dc255a90271edd6659fb;hp=f09429013631f7d6bdaff23d0a2ad00244ff5954;hpb=478bab5380f586d3e022839a000a86c947a29f9c;p=ardour.git diff --git a/gtk2_ardour/editor_drag.cc b/gtk2_ardour/editor_drag.cc index f094290136..8d6838eb76 100644 --- a/gtk2_ardour/editor_drag.cc +++ b/gtk2_ardour/editor_drag.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2009 Paul Davis + Copyright (C) 2009 Paul Davis This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -17,9 +17,13 @@ */ +#define __STDC_LIMIT_MACROS 1 +#include #include "pbd/memento_command.h" #include "pbd/basename.h" +#include "pbd/stateful_diff_command.h" #include "ardour/diskstream.h" +#include "ardour/session.h" #include "ardour/dB.h" #include "ardour/region_factory.h" #include "ardour/midi_diskstream.h" @@ -29,31 +33,151 @@ #include "audio_region_view.h" #include "midi_region_view.h" #include "ardour_ui.h" +#include "gui_thread.h" #include "control_point.h" #include "utils.h" #include "region_gain_line.h" #include "editor_drag.h" #include "audio_time_axis.h" #include "midi_time_axis.h" +#include "canvas-note.h" +#include "selection.h" +#include "midi_selection.h" +#include "automation_time_axis.h" using namespace std; using namespace ARDOUR; using namespace PBD; -using namespace sigc; using namespace Gtk; using namespace Editing; +using namespace ArdourCanvas; + +using Gtkmm2ext::Keyboard; double const ControlPointDrag::_zero_gain_fraction = gain_to_slider_position (dB_to_coefficient (0.0)); -Drag::Drag (Editor* e, ArdourCanvas::Item* i) : - _editor (e), - _item (i), - _pointer_frame_offset (0), - _grab_frame (0), - _last_pointer_frame (0), - _current_pointer_frame (0), - _had_movement (false), - _move_threshold_passed (false) +DragManager::DragManager (Editor* e) + : _editor (e) + , _ending (false) + , _current_pointer_frame (0) +{ + +} + +DragManager::~DragManager () +{ + abort (); +} + +void +DragManager::abort () +{ + for (list::const_iterator i = _drags.begin(); i != _drags.end(); ++i) { + (*i)->end_grab (0); + delete *i; + } + + _drags.clear (); +} + +void +DragManager::break_drag () +{ + _ending = true; + + for (list::const_iterator i = _drags.begin(); i != _drags.end(); ++i) { + (*i)->break_drag (); + delete *i; + } + + _drags.clear (); + + _ending = false; +} + +void +DragManager::add (Drag* d) +{ + d->set_manager (this); + _drags.push_back (d); +} + +void +DragManager::set (Drag* d, GdkEvent* e, Gdk::Cursor* c) +{ + assert (_drags.empty ()); + d->set_manager (this); + _drags.push_back (d); + start_grab (e); +} + +void +DragManager::start_grab (GdkEvent* e) +{ + _current_pointer_frame = _editor->event_frame (e, &_current_pointer_x, &_current_pointer_y); + + for (list::const_iterator i = _drags.begin(); i != _drags.end(); ++i) { + (*i)->start_grab (e); + } +} + +bool +DragManager::end_grab (GdkEvent* e) +{ + _ending = true; + + bool r = false; + for (list::iterator i = _drags.begin(); i != _drags.end(); ++i) { + bool const t = (*i)->end_grab (e); + if (t) { + r = true; + } + delete *i; + } + + _drags.clear (); + + _ending = false; + + return r; +} + +bool +DragManager::motion_handler (GdkEvent* e, bool from_autoscroll) +{ + bool r = false; + + _current_pointer_frame = _editor->event_frame (e, &_current_pointer_x, &_current_pointer_y); + + for (list::iterator i = _drags.begin(); i != _drags.end(); ++i) { + bool const t = (*i)->motion_handler (e, from_autoscroll); + if (t) { + r = true; + } + + } + + return r; +} + +bool +DragManager::have_item (ArdourCanvas::Item* i) const +{ + list::const_iterator j = _drags.begin (); + while (j != _drags.end() && (*j)->item () != i) { + ++j; + } + + return j != _drags.end (); +} + +Drag::Drag (Editor* e, ArdourCanvas::Item* i) + : _editor (e) + , _item (i) + , _pointer_frame_offset (0) + , _move_threshold_passed (false) + , _grab_frame (0) + , _last_pointer_frame (0) { } @@ -94,28 +218,22 @@ Drag::start_grab (GdkEvent* event, Gdk::Cursor *cursor) } _grab_frame = _editor->event_frame (event, &_grab_x, &_grab_y); + _grab_frame = adjusted_frame (_grab_frame, event); _last_pointer_frame = _grab_frame; - _current_pointer_frame = _grab_frame; - _current_pointer_x = _grab_x; - _current_pointer_y = _grab_y; - _last_pointer_x = _current_pointer_x; - _last_pointer_y = _current_pointer_y; - - _original_x = 0; - _original_y = 0; - _item->i2w (_original_x, _original_y); + _last_pointer_x = _grab_x; + _last_pointer_y = _grab_y; _item->grab (Gdk::POINTER_MOTION_MASK|Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK, *cursor, event->button.time); - if (_editor->session && _editor->session->transport_rolling()) { + if (_editor->session() && _editor->session()->transport_rolling()) { _was_rolling = true; } else { _was_rolling = false; } - switch (_editor->snap_type) { + switch (_editor->snap_type()) { case SnapToRegionStart: case SnapToRegionEnd: case SnapToRegionSync: @@ -133,84 +251,73 @@ Drag::start_grab (GdkEvent* event, Gdk::Cursor *cursor) bool Drag::end_grab (GdkEvent* event) { - _ending = true; - _editor->stop_canvas_autoscroll (); _item->ungrab (event ? event->button.time : 0); - _last_pointer_x = _current_pointer_x; - _last_pointer_y = _current_pointer_y; - finished (event, _had_movement); + finished (event, _move_threshold_passed); _editor->hide_verbose_canvas_cursor(); - update_selection (); - - _ending = false; - - return _had_movement; + return _move_threshold_passed; } nframes64_t -Drag::adjusted_current_frame (GdkEvent* event) const +Drag::adjusted_frame (nframes64_t f, GdkEvent const * event, bool snap) const { nframes64_t pos = 0; - - if (_current_pointer_frame > _pointer_frame_offset) { - pos = _current_pointer_frame - _pointer_frame_offset; + + if (f > _pointer_frame_offset) { + pos = f - _pointer_frame_offset; } - if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) { - _editor->snap_to (pos); + if (snap) { + _editor->snap_to_with_modifier (pos, event); } - + return pos; } +nframes64_t +Drag::adjusted_current_frame (GdkEvent const * event, bool snap) const +{ + return adjusted_frame (_drags->current_pointer_frame (), event, snap); +} + bool Drag::motion_handler (GdkEvent* event, bool from_autoscroll) { - _last_pointer_x = _current_pointer_x; - _last_pointer_y = _current_pointer_y; - _current_pointer_frame = _editor->event_frame (event, &_current_pointer_x, &_current_pointer_y); + /* check to see if we have moved in any way that matters since the last motion event */ + if ( (!x_movement_matters() || _last_pointer_frame == adjusted_current_frame (event)) && + (!y_movement_matters() || _last_pointer_y == _drags->current_pointer_y ()) ) { + return false; + } - if (!from_autoscroll && !_move_threshold_passed) { - - bool const xp = (::llabs ((nframes64_t) (_current_pointer_x - _grab_x)) > 4LL); - bool const yp = (::llabs ((nframes64_t) (_current_pointer_y - _grab_y)) > 4LL); - - _move_threshold_passed = (xp || yp); + pair const threshold = move_threshold (); - if (apply_move_threshold() && _move_threshold_passed) { - - _grab_frame = _current_pointer_frame; - _grab_x = _current_pointer_x; - _grab_y = _current_pointer_y; - _last_pointer_frame = _grab_frame; - _pointer_frame_offset = _grab_frame - _last_frame_position; - - } - } + bool const old_move_threshold_passed = _move_threshold_passed; - bool old_had_movement = _had_movement; + if (!from_autoscroll && !_move_threshold_passed) { - /* a motion event has happened, so we've had movement... */ - _had_movement = true; + bool const xp = (::llabs (adjusted_current_frame (event) - _grab_frame) >= threshold.first); + bool const yp = (::fabs ((_drags->current_pointer_y () - _grab_y)) >= threshold.second); - /* ... unless we're using a move threshold and we've not yet passed it */ - if (apply_move_threshold() && !_move_threshold_passed) { - _had_movement = false; + _move_threshold_passed = ((xp && x_movement_matters()) || (yp && y_movement_matters())); } - if (active (_editor->mouse_mode)) { + if (active (_editor->mouse_mode) && _move_threshold_passed) { if (event->motion.state & Gdk::BUTTON1_MASK || event->motion.state & Gdk::BUTTON2_MASK) { if (!from_autoscroll) { _editor->maybe_autoscroll (&event->motion, allow_vertical_autoscroll ()); } - motion (event, _had_movement != old_had_movement); + motion (event, _move_threshold_passed != old_move_threshold_passed); + + _last_pointer_x = _drags->current_pointer_x (); + _last_pointer_y = _drags->current_pointer_y (); + _last_pointer_frame = adjusted_current_frame (event); + return true; } } @@ -218,56 +325,51 @@ Drag::motion_handler (GdkEvent* event, bool from_autoscroll) return false; } - void Drag::break_drag () { - _editor->stop_canvas_autoscroll (); - _editor->hide_verbose_canvas_cursor (); - if (_item) { _item->ungrab (0); + } - /* put it back where it came from */ + aborted (); - double cxw, cyw; - cxw = 0; - cyw = 0; - _item->i2w (cxw, cyw); - _item->move (_original_x - cxw, _original_y - cyw); - } + _editor->stop_canvas_autoscroll (); + _editor->hide_verbose_canvas_cursor (); } - RegionDrag::RegionDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list const & v) : Drag (e, i), - _primary (p), - _views (v) + _primary (p) { - RegionView::RegionViewGoingAway.connect (mem_fun (*this, &RegionDrag::region_going_away)); + for (list::const_iterator i = v.begin(); i != v.end(); ++i) { + _views.push_back (DraggingView (*i)); + } + + RegionView::RegionViewGoingAway.connect (death_connection, invalidator (*this), ui_bind (&RegionDrag::region_going_away, this, _1), gui_context()); } void RegionDrag::region_going_away (RegionView* v) { - _views.remove (v); -} + list::iterator i = _views.begin (); + while (i != _views.end() && i->view != v) { + ++i; + } -void -RegionDrag::update_selection () -{ - list s; - copy (_views.begin(), _views.end(), back_inserter (s)); - _editor->selection->set (s); + if (i != _views.end()) { + _views.erase (i); + } } RegionMotionDrag::RegionMotionDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list const & v, bool b) : RegionDrag (e, i, p, v), _dest_trackview (0), _dest_layer (0), - _brushing (b) + _brushing (b), + _total_x_delta (0) { - + } @@ -275,7 +377,7 @@ void RegionMotionDrag::start_grab (GdkEvent* event, Gdk::Cursor *) { Drag::start_grab (event); - + _editor->show_verbose_time_cursor (_last_frame_position, 10); } @@ -286,30 +388,30 @@ RegionMotionDrag::get_time_axis_view_summary () TimeAxisViewSummary sum; _editor->visible_order_range (&sum.visible_y_low, &sum.visible_y_high); - + /* get a bitmask representing the visible tracks */ - for (Editor::TrackViewList::iterator i = _editor->track_views.begin(); i != _editor->track_views.end(); ++i) { + for (TrackViewList::iterator i = _editor->track_views.begin(); i != _editor->track_views.end(); ++i) { RouteTimeAxisView* rtv = dynamic_cast (*i); TimeAxisView::Children children_list; - + /* zeroes are audio/MIDI tracks. ones are other types. */ - + if (!rtv->hidden()) { - + if (!rtv->is_track()) { /* not an audio nor MIDI track */ sum.tracks = sum.tracks |= (0x01 << rtv->order()); } - + sum.height_list[rtv->order()] = (*i)->current_height(); children = 1; if ((children_list = rtv->get_child_list()).size() > 0) { - for (TimeAxisView::Children::iterator j = children_list.begin(); j != children_list.end(); ++j) { + for (TimeAxisView::Children::iterator j = children_list.begin(); j != children_list.end(); ++j) { sum.tracks = sum.tracks |= (0x01 << (rtv->order() + children)); sum.height_list[rtv->order() + children] = (*j)->current_height(); - children++; + children++; } } } @@ -334,7 +436,7 @@ RegionMotionDrag::compute_y_delta ( } bool clamp_y_axis = false; - + /* the change in track order between this callback and the last */ *pointer_order_span = last_pointer_view->order() - current_pointer_view->order(); /* the change in layer between this callback and the last; @@ -362,9 +464,9 @@ RegionMotionDrag::compute_y_delta ( } } - for (list::const_iterator i = _views.begin(); i != _views.end(); ++i) { - - RegionView* rv = (*i); + for (list::const_iterator i = _views.begin(); i != _views.end(); ++i) { + + RegionView* rv = i->view; if (rv->region()->locked()) { continue; @@ -382,7 +484,7 @@ RegionMotionDrag::compute_y_delta ( /* XXX: not sure that we should be passing canvas_pointer_order_span in here, as surely this is a per-region thing... */ - + clamp_y_axis = y_movement_disallowed ( rtv->order(), last_pointer_view->order(), *canvas_pointer_order_span, tavs ); @@ -397,7 +499,7 @@ RegionMotionDrag::compute_y_delta ( if (current_pointer_layer == last_pointer_layer) { /* No movement; clamp */ clamp_y_axis = true; - } + } } if (!clamp_y_axis) { @@ -412,77 +514,66 @@ RegionMotionDrag::compute_y_delta ( double RegionMotionDrag::compute_x_delta (GdkEvent const * event, nframes64_t* pending_region_position) { - *pending_region_position = 0; - /* compute the amount of pointer motion in frames, and where the region would be if we moved it by that much. */ - if (_current_pointer_frame >= _pointer_frame_offset) { - - nframes64_t sync_frame; - nframes64_t sync_offset; - int32_t sync_dir; + *pending_region_position = adjusted_current_frame (event); + + nframes64_t sync_frame; + nframes64_t sync_offset; + int32_t sync_dir; + + sync_offset = _primary->region()->sync_offset (sync_dir); + + /* we don't handle a sync point that lies before zero. + */ + if (sync_dir >= 0 || (sync_dir < 0 && *pending_region_position >= sync_offset)) { - *pending_region_position = _current_pointer_frame - _pointer_frame_offset; + sync_frame = *pending_region_position + (sync_dir*sync_offset); - sync_offset = _primary->region()->sync_offset (sync_dir); + _editor->snap_to_with_modifier (sync_frame, event); - /* we don't handle a sync point that lies before zero. - */ - if (sync_dir >= 0 || (sync_dir < 0 && *pending_region_position >= sync_offset)) { - - sync_frame = *pending_region_position + (sync_dir*sync_offset); - - /* we snap if the snap modifier is not enabled. - */ - - if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) { - _editor->snap_to (sync_frame); - } - - *pending_region_position = _primary->region()->adjust_to_sync (sync_frame); - - } else { - *pending_region_position = _last_frame_position; - } + *pending_region_position = _primary->region()->adjust_to_sync (sync_frame); + } else { + *pending_region_position = _last_frame_position; } - + if (*pending_region_position > max_frames - _primary->region()->length()) { *pending_region_position = _last_frame_position; } double x_delta = 0; - + if ((*pending_region_position != _last_frame_position) && x_move_allowed ()) { - + /* now compute the canvas unit distance we need to move the regionview to make it appear at the new location. */ x_delta = (static_cast (*pending_region_position) - _last_frame_position) / _editor->frames_per_unit; - + if (*pending_region_position <= _last_frame_position) { - - for (list::const_iterator i = _views.begin(); i != _views.end(); ++i) { - - RegionView* rv = (*i); - + + for (list::const_iterator i = _views.begin(); i != _views.end(); ++i) { + + RegionView* rv = i->view; + // If any regionview is at zero, we need to know so we can stop further leftward motion. - + double ix1, ix2, iy1, iy2; rv->get_canvas_frame()->get_bounds (ix1, iy1, ix2, iy2); rv->get_canvas_frame()->i2w (ix1, iy1); - + if (-x_delta > ix1 + _editor->horizontal_adjustment.get_value()) { x_delta = 0; *pending_region_position = _last_frame_position; break; } } - + } - + _last_frame_position = *pending_region_position; } @@ -521,7 +612,7 @@ RegionMotionDrag::motion (GdkEvent* event, bool first_move) int32_t pointer_order_span; int32_t pointer_layer_span; int32_t canvas_pointer_order_span; - + bool const clamp_y_axis = compute_y_delta ( last_pointer_view, current_pointer_view, last_pointer_layer, current_pointer_layer, tavs, @@ -536,7 +627,7 @@ RegionMotionDrag::motion (GdkEvent* event, bool first_move) PREPARE TO MOVE ************************************************************/ - if (x_delta == 0 && pointer_order_span == 0 && pointer_layer_span == 0) { + if (x_delta == 0 && pointer_order_span == 0 && pointer_layer_span == 0 && !first_move) { /* haven't reached next snap point, and we're not switching trackviews nor layers. nothing to do. */ @@ -544,68 +635,68 @@ RegionMotionDrag::motion (GdkEvent* event, bool first_move) } /************************************************************* - MOTION + MOTION ************************************************************/ pair >::iterator,bool> insert_result; - - for (list::const_iterator i = _views.begin(); i != _views.end(); ++i) { - - RegionView* rv = (*i); - + + for (list::const_iterator i = _views.begin(); i != _views.end(); ++i) { + + RegionView* rv = i->view; + if (rv->region()->locked()) { continue; } - + /* here we are calculating the y distance from the top of the first track view to the top of the region area of the track view that we're working on */ - + /* this x value is just a dummy value so that we have something to pass to i2w () */ - + double ix1 = 0; - + /* distance from the top of this track view to the region area of our track view is always 1 */ - + double iy1 = 1; - + /* convert to world coordinates, ie distance from the top of the ruler section */ - + rv->get_canvas_frame()->i2w (ix1, iy1); - + /* compensate for the ruler section and the vertical scrollbar position */ iy1 += _editor->get_trackview_group_vertical_offset (); - + if (first_move) { - - // hide any dependent views - + + // hide any dependent views + rv->get_time_axis_view().hide_dependent_views (*rv); - - /* - reparent to a non scrolling group so that we can keep the + + /* + reparent to a non scrolling group so that we can keep the region selection above all time axis views. - reparenting means we have to move the rv as the two + reparenting means we have to move the rv as the two parent groups have different coordinates. */ - + rv->get_canvas_group()->property_y() = iy1 - 1; rv->get_canvas_group()->reparent(*(_editor->_region_motion_group)); - + rv->fake_set_opaque (true); } - + /* current view for this particular region */ pair pos = _editor->trackview_by_y_position (iy1); RouteTimeAxisView* rtv = dynamic_cast (pos.first); - + if (pointer_order_span != 0 && !clamp_y_axis) { - + /* INTER-TRACK MOVEMENT */ - + /* move through the height list to the track that the region is currently on */ vector::iterator j = tavs.height_list.begin (); int32_t x = 0; @@ -613,25 +704,25 @@ RegionMotionDrag::motion (GdkEvent* event, bool first_move) ++x; ++j; } - + y_delta = 0; int32_t temp_pointer_order_span = canvas_pointer_order_span; - + if (j != tavs.height_list.end ()) { - + /* Account for layers in the original and destination tracks. If we're moving around in layers we assume that only one track is involved, so it's ok to use *pointer* variables here. */ - + StreamView* lv = last_pointer_view->view (); assert (lv); - + /* move to the top of the last trackview */ if (lv->layer_display () == Stacked) { y_delta -= (lv->layers() - last_pointer_layer - 1) * lv->child_height (); } - + StreamView* cv = current_pointer_view->view (); assert (cv); @@ -639,77 +730,79 @@ RegionMotionDrag::motion (GdkEvent* event, bool first_move) if (cv->layer_display () == Stacked) { y_delta += (cv->layers() - current_pointer_layer - 1) * cv->child_height (); } - + /* And for being on a non-topmost layer on the new track */ - + while (temp_pointer_order_span > 0) { /* we're moving up canvas-wise, so we need to find the next track height */ - if (j != tavs.height_list.begin()) { + if (j != tavs.height_list.begin()) { j--; } - + if (x != last_pointer_order) { if ((*j) == 0) { ++temp_pointer_order_span; } } - + y_delta -= (*j); temp_pointer_order_span--; } - + while (temp_pointer_order_span < 0) { - + y_delta += (*j); - + if (x != last_pointer_order) { if ((*j) == 0) { --temp_pointer_order_span; } } - - if (j != tavs.height_list.end()) { + + if (j != tavs.height_list.end()) { j++; } - + temp_pointer_order_span++; } - - + + /* find out where we'll be when we move and set height accordingly */ - + pair const pos = _editor->trackview_by_y_position (iy1 + y_delta); RouteTimeAxisView const * temp_rtv = dynamic_cast (pos.first); rv->set_height (temp_rtv->view()->child_height()); - + /* if you un-comment the following, the region colours will follow the track colours whilst dragging; personally i think this can confuse things, but never mind. */ - + //const GdkColor& col (temp_rtv->view->get_region_color()); //rv->set_color (const_cast(col)); } } - + if (pointer_order_span == 0 && pointer_layer_span != 0 && !clamp_y_axis) { - + /* INTER-LAYER MOVEMENT in the same track */ y_delta = rtv->view()->child_height () * pointer_layer_span; } - - + + if (_brushing) { _editor->mouse_brush_insert_region (rv, pending_region_position); } else { rv->move (x_delta, y_delta); } - + } /* foreach region */ + _total_x_delta += x_delta; + if (first_move) { _editor->cursor_group->raise_to_top(); } @@ -730,13 +823,13 @@ RegionMoveDrag::motion (GdkEvent* event, bool first_move) } void -RegionMoveDrag::finished (GdkEvent* event, bool movement_occurred) +RegionMoveDrag::finished (GdkEvent* /*event*/, bool movement_occurred) { - bool nocommit = true; vector copies; boost::shared_ptr ds; boost::shared_ptr from_playlist; - list new_views; + boost::shared_ptr to_playlist; + RegionSelection new_views; typedef set > PlaylistSet; PlaylistSet modified_playlists; PlaylistSet frozen_playlists; @@ -744,27 +837,21 @@ RegionMoveDrag::finished (GdkEvent* event, bool movement_occurred) pair insert_result, frozen_insert_result; nframes64_t drag_delta; bool changed_tracks, changed_position; - map final; + map > final; RouteTimeAxisView* source_tv; + vector sdc; if (!movement_occurred) { /* just a click */ - goto out; - } - - nocommit = false; - - if (Config->get_edit_mode() == Splice && !_editor->pre_drag_region_selection.empty()) { - _editor->selection->set (_editor->pre_drag_region_selection); - _editor->pre_drag_region_selection.clear (); + return; } if (_brushing) { /* all changes were made during motion event handlers */ - + if (_copy) { - for (list::iterator i = _views.begin(); i != _views.end(); ++i) { - copies.push_back (*i); + for (list::iterator i = _views.begin(); i != _views.end(); ++i) { + copies.push_back (i->view); } } @@ -774,8 +861,8 @@ RegionMoveDrag::finished (GdkEvent* event, bool movement_occurred) /* reverse this here so that we have the correct logic to finalize the drag. */ - - if (Config->get_edit_mode() == Lock && !_copy) { + + if (Config->get_edit_mode() == Lock) { _x_constrained = !_x_constrained; } @@ -784,7 +871,7 @@ RegionMoveDrag::finished (GdkEvent* event, bool movement_occurred) _editor->begin_reversible_command (_("fixed time region copy")); } else { _editor->begin_reversible_command (_("region copy")); - } + } } else { if (_x_constrained) { _editor->begin_reversible_command (_("fixed time region drag")); @@ -801,15 +888,21 @@ RegionMoveDrag::finished (GdkEvent* event, bool movement_occurred) _editor->update_canvas_now (); /* make a list of where each region ended up */ - final = find_time_axis_views (); + final = find_time_axis_views_and_layers (); + + cerr << "Iterate over " << _views.size() << " views\n"; - for (list::const_iterator i = _views.begin(); i != _views.end(); ) { + for (list::const_iterator i = _views.begin(); i != _views.end(); ) { - RegionView* rv = (*i); - RouteTimeAxisView* dest_rtv = final[*i]; + RegionView* rv = i->view; + RouteTimeAxisView* dest_rtv = final[rv].first; + layer_t dest_layer = final[rv].second; nframes64_t where; + from_playlist.reset (); + to_playlist.reset (); + if (rv->region()->locked()) { ++i; continue; @@ -820,7 +913,7 @@ RegionMoveDrag::finished (GdkEvent* event, bool movement_occurred) } else { where = rv->region()->position(); } - + boost::shared_ptr new_region; if (_copy) { @@ -828,19 +921,19 @@ RegionMoveDrag::finished (GdkEvent* event, bool movement_occurred) new_region = rv->region(); /* undo the previous hide_dependent_views so that xfades don't - disappear on copying regions + disappear on copying regions */ - + //rv->get_time_axis_view().reveal_dependent_views (*rv); - + } else if (changed_tracks && dest_rtv->playlist()) { new_region = RegionFactory::create (rv->region()); } if (changed_tracks || _copy) { - boost::shared_ptr to_playlist = dest_rtv->playlist(); - + to_playlist = dest_rtv->playlist(); + if (!to_playlist) { ++i; continue; @@ -848,18 +941,30 @@ RegionMoveDrag::finished (GdkEvent* event, bool movement_occurred) _editor->latest_regionviews.clear (); - sigc::connection c = dest_rtv->view()->RegionViewAdded.connect (mem_fun(*_editor, &Editor::collect_new_region_view)); - + sigc::connection c = dest_rtv->view()->RegionViewAdded.connect (sigc::mem_fun(*_editor, &Editor::collect_new_region_view)); + insert_result = modified_playlists.insert (to_playlist); - + if (insert_result.second) { - _editor->session->add_command (new MementoCommand(*to_playlist, &to_playlist->get_state(), 0)); + to_playlist->clear_history (); } + cerr << "To playlist " << to_playlist->name() << " region history contains " + << to_playlist->region_list().change().added.size() << " adds and " + << to_playlist->region_list().change().removed.size() << " removes\n"; + + cerr << "Adding new region " << new_region->id() << " based on " + << rv->region()->id() << endl; + to_playlist->add_region (new_region, where); + if (dest_rtv->view()->layer_display() == Stacked) { + new_region->set_layer (dest_layer); + new_region->set_pending_explicit_relayer (true); + } + c.disconnect (); - + if (!_editor->latest_regionviews.empty()) { // XXX why just the first one ? we only expect one // commented out in nick_m's canvas reworking. is that intended? @@ -868,32 +973,40 @@ RegionMoveDrag::finished (GdkEvent* event, bool movement_occurred) } } else { - /* - motion on the same track. plonk the previously reparented region + rv->region()->clear_history (); + + /* + motion on the same track. plonk the previously reparented region back to its original canvas group (its streamview). No need to do anything for copies as they are fake regions which will be deleted. */ rv->get_canvas_group()->reparent (*dest_rtv->view()->canvas_item()); - rv->get_canvas_group()->property_y() = 0; - + rv->get_canvas_group()->property_y() = i->initial_y; + rv->get_time_axis_view().reveal_dependent_views (*rv); + /* just change the model */ - - boost::shared_ptr playlist = dest_rtv->playlist(); - insert_result = modified_playlists.insert (playlist); + boost::shared_ptr playlist = dest_rtv->playlist(); - if (insert_result.second) { - _editor->session->add_command (new MementoCommand(*playlist, &playlist->get_state(), 0)); + if (dest_rtv->view()->layer_display() == Stacked) { + rv->region()->set_layer (dest_layer); + rv->region()->set_pending_explicit_relayer (true); } - /* freeze to avoid lots of relayering in the case of a multi-region drag */ - frozen_insert_result = frozen_playlists.insert(playlist); + /* freeze playlist to avoid lots of relayering in the case of a multi-region drag */ + + frozen_insert_result = frozen_playlists.insert(playlist); + if (frozen_insert_result.second) { playlist->freeze(); } + cerr << "Moving region " << rv->region()->id() << endl; + rv->region()->set_position (where, (void*) this); + + sdc.push_back (new StatefulDiffCommand (rv->region())); } if (changed_tracks && !_copy) { @@ -902,9 +1015,13 @@ RegionMoveDrag::finished (GdkEvent* event, bool movement_occurred) because we may have copied the region and it has not been attached to a playlist. */ - assert ((source_tv = dynamic_cast (&rv->get_time_axis_view()))); - assert ((ds = source_tv->get_diskstream())); - assert ((from_playlist = ds->playlist())); + source_tv = dynamic_cast (&rv->get_time_axis_view()); + ds = source_tv->get_diskstream(); + from_playlist = ds->playlist(); + + assert (source_tv); + assert (ds); + assert (from_playlist); /* moved to a different audio track, without copying */ @@ -912,21 +1029,27 @@ RegionMoveDrag::finished (GdkEvent* event, bool movement_occurred) moved to the new one - we use a copy of it. as a result, any existing editor for the region should no longer be visible. - */ - + */ + rv->hide_region_editor(); rv->fake_set_opaque (false); - + /* remove the region from the old playlist */ insert_result = modified_playlists.insert (from_playlist); - + if (insert_result.second) { - _editor->session->add_command (new MementoCommand(*from_playlist, &from_playlist->get_state(), 0)); + from_playlist->clear_history (); } - + + cerr << "From playlist " << from_playlist->name() << " region history contains " + << from_playlist->region_list().change().added.size() << " adds and " + << from_playlist->region_list().change().removed.size() << " removes\n"; + + cerr << "removing region " << rv->region() << endl; + from_playlist->remove_region (rv->region()); - + /* OK, this is where it gets tricky. If the playlist was being used by >1 tracks, and the region was selected in all of them, then removing it from a playlist will have removed all trace of it from the selection (i.e. there were N regions selected, we removed 1, @@ -945,70 +1068,107 @@ RegionMoveDrag::finished (GdkEvent* event, bool movement_occurred) */ if (_views.empty()) { - break; - } else { + if (to_playlist) { + sdc.push_back (new StatefulDiffCommand (to_playlist)); + cerr << "Saved diff for to:" << to_playlist->name() << endl; + } + + if (from_playlist && (from_playlist != to_playlist)) { + sdc.push_back (new StatefulDiffCommand (from_playlist)); + cerr << "Saved diff for from:" << from_playlist->name() << endl; + } + break; + } else { i = _views.begin(); } } else { ++i; } - + if (_copy) { copies.push_back (rv); } + + cerr << "Done with TV, top = " << to_playlist << " from = " << from_playlist << endl; + + if (to_playlist) { + sdc.push_back (new StatefulDiffCommand (to_playlist)); + cerr << "Saved diff for to:" << to_playlist->name() << endl; + } + + if (from_playlist && (from_playlist != to_playlist)) { + sdc.push_back (new StatefulDiffCommand (from_playlist)); + cerr << "Saved diff for from:" << from_playlist->name() << endl; + } } - - if (new_views.empty()) { - if (_copy) { - /* the region(view)s that are being dragged around are copies and do not - belong to any track. remove them from our list - */ - _views.clear (); - } - } else { - _views = new_views; - _primary = _views.front (); + + /* + if we've created new regions either by copying or moving + to a new track, we want to replace the old selection with the new ones + */ + + if (new_views.size() > 0) { + _editor->selection->set (new_views); } for (set >::iterator p = frozen_playlists.begin(); p != frozen_playlists.end(); ++p) { (*p)->thaw(); } - + out: - if (!nocommit) { - for (set >::iterator p = modified_playlists.begin(); p != modified_playlists.end(); ++p) { - _editor->session->add_command (new MementoCommand(*(*p), 0, &(*p)->get_state())); - } + for (vector::iterator i = sdc.begin(); i != sdc.end(); ++i) { + _editor->session()->add_command (*i); + } - _editor->commit_reversible_command (); - } + _editor->commit_reversible_command (); for (vector::iterator x = copies.begin(); x != copies.end(); ++x) { delete *x; } } - -bool -RegionMoveDrag::x_move_allowed () const +void +RegionMoveDrag::aborted () { - if (Config->get_edit_mode() == Lock) { - if (_copy) { - return !_x_constrained; - } else { - /* in locked edit mode, reverse the usual meaning of _x_constrained */ - return _x_constrained; + if (_copy) { + + for (list::const_iterator i = _views.begin(); i != _views.end(); ++i) { + delete i->view; } + + _views.clear (); + + } else { + RegionMotionDrag::aborted (); } - - return !_x_constrained; } +void +RegionMotionDrag::aborted () +{ + for (list::const_iterator i = _views.begin(); i != _views.end(); ++i) { + RegionView* rv = i->view; + TimeAxisView* tv = &(rv->get_time_axis_view ()); + RouteTimeAxisView* rtv = dynamic_cast (tv); + assert (rtv); + rv->get_canvas_group()->reparent (*rtv->view()->canvas_item()); + rv->get_canvas_group()->property_y() = 0; + rv->get_time_axis_view().reveal_dependent_views (*rv); + rv->fake_set_opaque (false); + rv->move (-_total_x_delta, 0); + rv->set_height (rtv->view()->child_height ()); + } + + _editor->update_canvas_now (); +} + + bool -RegionInsertDrag::x_move_allowed () const +RegionMotionDrag::x_move_allowed () const { if (Config->get_edit_mode() == Lock) { + /* in locked edit mode, reverse the usual meaning of _x_constrained */ return _x_constrained; } @@ -1020,21 +1180,23 @@ RegionMotionDrag::copy_regions (GdkEvent* event) { /* duplicate the regionview(s) and region(s) */ - list new_regionviews; - - for (list::const_iterator i = _views.begin(); i != _views.end(); ++i) { - - RegionView* rv = (*i); + list new_regionviews; + + for (list::const_iterator i = _views.begin(); i != _views.end(); ++i) { + + RegionView* rv = i->view; AudioRegionView* arv = dynamic_cast(rv); MidiRegionView* mrv = dynamic_cast(rv); - + const boost::shared_ptr original = rv->region(); boost::shared_ptr region_copy = RegionFactory::create (original); + region_copy->set_position (original->position(), this); RegionView* nrv; if (arv) { boost::shared_ptr audioregion_copy = boost::dynamic_pointer_cast(region_copy); + nrv = new AudioRegionView (*arv, audioregion_copy); } else if (mrv) { boost::shared_ptr midiregion_copy @@ -1043,28 +1205,37 @@ RegionMotionDrag::copy_regions (GdkEvent* event) } else { continue; } - + nrv->get_canvas_group()->show (); - new_regionviews.push_back (nrv); + new_regionviews.push_back (DraggingView (nrv)); + + /* swap _primary to the copy */ + + if (rv == _primary) { + _primary = nrv; + } + + /* ..and deselect the one we copied */ + + rv->set_selected (false); } - + if (new_regionviews.empty()) { return; } - + /* reflect the fact that we are dragging the copies */ - - _primary = new_regionviews.front(); + _views = new_regionviews; - - swap_grab (new_regionviews.front()->get_canvas_group (), 0, event ? event->motion.time : 0); - - /* - sync the canvas to what we think is its current state - without it, the canvas seems to - "forget" to update properly after the upcoming reparent() - ..only if the mouse is in rapid motion at the time of the grab. - something to do with regionview creation raking so long? + + swap_grab (new_regionviews.front().view->get_canvas_group (), 0, event ? event->motion.time : 0); + + /* + sync the canvas to what we think is its current state + without it, the canvas seems to + "forget" to update properly after the upcoming reparent() + ..only if the mouse is in rapid motion at the time of the grab. + something to do with regionview creation taking so long? */ _editor->update_canvas_now(); } @@ -1074,7 +1245,7 @@ RegionMotionDrag::check_possible (RouteTimeAxisView** tv, layer_t* layer) { /* Which trackview is this ? */ - pair const tvp = _editor->trackview_by_y_position (current_pointer_y ()); + pair const tvp = _editor->trackview_by_y_position (_drags->current_pointer_y ()); (*tv) = dynamic_cast (tvp.first); (*layer) = tvp.second; @@ -1085,10 +1256,10 @@ RegionMotionDrag::check_possible (RouteTimeAxisView** tv, layer_t* layer) /* The region motion is only processed if the pointer is over an audio track. */ - + if (!(*tv) || !(*tv)->is_track()) { - /* To make sure we hide the verbose canvas cursor when the mouse is - not held over and audiotrack. + /* To make sure we hide the verbose canvas cursor when the mouse is + not held over and audiotrack. */ _editor->hide_verbose_canvas_cursor (); return false; @@ -1107,7 +1278,7 @@ RegionMotionDrag::y_movement_disallowed (int new_order, int old_order, int y_spa { if (new_order != old_order) { - /* this isn't the pointer track */ + /* this isn't the pointer track */ if (y_span > 0) { @@ -1123,20 +1294,20 @@ RegionMotionDrag::y_movement_disallowed (int new_order, int old_order, int y_spa while (tavs.height_list[new_order - (visible_tracks - n)] == 0) { /* passing through a hidden track */ n--; - } + } } - + if (tavs.tracks[new_order - (y_span - n)] != 0x00) { /* moving to a non-track; disallow */ return true; } - + } else { /* moving beyond the lowest visible track; disallow */ return true; - } - + } + } else if (y_span < 0) { /* moving down the canvas */ @@ -1146,30 +1317,30 @@ RegionMotionDrag::y_movement_disallowed (int new_order, int old_order, int y_spa int32_t n = 0; while (visible_tracks > y_span ) { visible_tracks--; - + while (tavs.height_list[new_order - (visible_tracks - n)] == 0) { /* passing through a hidden track */ n++; - } + } } - + if (tavs.tracks[new_order - (y_span - n)] != 0x00) { /* moving to a non-track; disallow */ return true; } - + } else { /* moving beyond the highest visible track; disallow */ return true; } - } - + } + } else { - + /* this is the pointer's track */ - + if ((new_order - y_span) > tavs.visible_y_high) { /* we will overflow */ return true; @@ -1188,7 +1359,7 @@ RegionMoveDrag::RegionMoveDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, _copy (c) { TimeAxisView* const tv = &_primary->get_time_axis_view (); - + _dest_trackview = tv; if (tv->layer_display() == Overlaid) { _dest_layer = 0; @@ -1209,8 +1380,8 @@ void RegionMoveDrag::start_grab (GdkEvent* event, Gdk::Cursor* c) { RegionMotionDrag::start_grab (event, c); - - _pointer_frame_offset = _grab_frame - _last_frame_position; + + _pointer_frame_offset = grab_frame() - _last_frame_position; } RegionInsertDrag::RegionInsertDrag (Editor* e, boost::shared_ptr r, RouteTimeAxisView* v, nframes64_t pos) @@ -1220,10 +1391,10 @@ RegionInsertDrag::RegionInsertDrag (Editor* e, boost::shared_ptr r, Rout (boost::dynamic_pointer_cast (r) && dynamic_cast (v))); _primary = v->view()->create_region_view (r, false, false); - + _primary->get_canvas_group()->show (); _primary->set_position (pos, 0); - _views.push_back (_primary); + _views.push_back (DraggingView (_primary)); _last_frame_position = pos; @@ -1232,20 +1403,21 @@ RegionInsertDrag::RegionInsertDrag (Editor* e, boost::shared_ptr r, Rout _dest_layer = _primary->region()->layer (); } -map -RegionMotionDrag::find_time_axis_views () +map > +RegionMotionDrag::find_time_axis_views_and_layers () { - map tav; - - for (list::const_iterator i = _views.begin(); i != _views.end(); ++i) { + map > tav; + + for (list::const_iterator i = _views.begin(); i != _views.end(); ++i) { double ix1, ix2, iy1, iy2; - (*i)->get_canvas_frame()->get_bounds (ix1, iy1, ix2, iy2); - (*i)->get_canvas_frame()->i2w (ix1, iy1); + RegionView* rv = i->view; + rv->get_canvas_frame()->get_bounds (ix1, iy1, ix2, iy2); + rv->get_canvas_frame()->i2w (ix1, iy1); iy1 += _editor->vertical_adjustment.get_value() - _editor->canvas_timebars_vsize; pair tv = _editor->trackview_by_y_position (iy1); - tav[*i] = dynamic_cast (tv.first); + tav[rv] = make_pair (dynamic_cast (tv.first), tv.second); } return tav; @@ -1253,13 +1425,13 @@ RegionMotionDrag::find_time_axis_views () void -RegionInsertDrag::finished (GdkEvent* event, bool movement_occurred) +RegionInsertDrag::finished (GdkEvent* /*event*/, bool /*movement_occurred*/) { _editor->update_canvas_now (); - map final = find_time_axis_views (); - - RouteTimeAxisView* dest_rtv = final[_primary]; + map > final = find_time_axis_views_and_layers (); + + RouteTimeAxisView* dest_rtv = final[_primary].first; _primary->get_canvas_group()->reparent (*dest_rtv->view()->canvas_item()); _primary->get_canvas_group()->property_y() = 0; @@ -1267,9 +1439,9 @@ RegionInsertDrag::finished (GdkEvent* event, bool movement_occurred) boost::shared_ptr playlist = dest_rtv->playlist(); _editor->begin_reversible_command (_("insert region")); - XMLNode& before = playlist->get_state (); + playlist->clear_history (); playlist->add_region (_primary->region (), _last_frame_position); - _editor->session->add_command (new MementoCommand (*playlist, &before, &playlist->get_state())); + _editor->session()->add_command (new StatefulDiffCommand (playlist)); _editor->commit_reversible_command (); delete _primary; @@ -1277,6 +1449,12 @@ RegionInsertDrag::finished (GdkEvent* event, bool movement_occurred) _views.clear (); } +void +RegionInsertDrag::aborted () +{ + /* XXX: TODO */ +} + RegionSpliceDrag::RegionSpliceDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list const & v) : RegionMoveDrag (e, i, p, v, false, false) { @@ -1294,14 +1472,14 @@ RegionSpliceDrag::motion (GdkEvent* event, bool) { RouteTimeAxisView* tv; layer_t layer; - + if (!check_possible (&tv, &layer)) { return; } int dir; - if (_current_pointer_x - _grab_x > 0) { + if ((_drags->current_pointer_x() - last_pointer_x()) > 0) { dir = 1; } else { dir = -1; @@ -1312,6 +1490,8 @@ RegionSpliceDrag::motion (GdkEvent* event, bool) RegionSelectionByPosition cmp; copy.sort (cmp); + nframes64_t const pf = adjusted_current_frame (event); + for (RegionSelection::iterator i = copy.begin(); i != copy.end(); ++i) { RouteTimeAxisView* atv = dynamic_cast (&(*i)->get_time_axis_view()); @@ -1328,106 +1508,166 @@ RegionSpliceDrag::motion (GdkEvent* event, bool) if (!playlist->region_is_shuffle_constrained ((*i)->region())) { continue; - } + } if (dir > 0) { - if (_current_pointer_frame < (*i)->region()->last_frame() + 1) { + if (pf < (*i)->region()->last_frame() + 1) { continue; } } else { - if (_current_pointer_frame > (*i)->region()->first_frame()) { + if (pf > (*i)->region()->first_frame()) { continue; } } - - playlist->shuffle ((*i)->region(), dir); - _grab_x = _current_pointer_x; + playlist->shuffle ((*i)->region(), dir); } } void -RegionSpliceDrag::finished (GdkEvent* event, bool) +RegionSpliceDrag::finished (GdkEvent* /*event*/, bool) { - + } +void +RegionSpliceDrag::aborted () +{ + /* XXX: TODO */ +} RegionCreateDrag::RegionCreateDrag (Editor* e, ArdourCanvas::Item* i, TimeAxisView* v) : Drag (e, i), _view (v) { - + } void RegionCreateDrag::start_grab (GdkEvent* event, Gdk::Cursor *) { _dest_trackview = _view; - + Drag::start_grab (event); } void -RegionCreateDrag::motion (GdkEvent* event, bool first_move) +RegionCreateDrag::motion (GdkEvent* /*event*/, bool first_move) { if (first_move) { // TODO: create region-create-drag region view here } // TODO: resize region-create-drag region view here -} +} void RegionCreateDrag::finished (GdkEvent* event, bool movement_occurred) { MidiTimeAxisView* mtv = dynamic_cast (_dest_trackview); + if (!mtv) { return; } - const boost::shared_ptr diskstream = - boost::dynamic_pointer_cast(mtv->view()->trackview().track()->diskstream()); - - if (!diskstream) { - warning << "Cannot create non-MIDI region" << endl; - return; + if (!movement_occurred) { + mtv->add_region (grab_frame ()); + } else { + motion (event, false); + // TODO: create region-create-drag region here } +} - if (!movement_occurred) { - _editor->begin_reversible_command (_("create region")); - XMLNode &before = mtv->playlist()->get_state(); +void +RegionCreateDrag::aborted () +{ + /* XXX: TODO */ +} + +NoteResizeDrag::NoteResizeDrag (Editor* e, ArdourCanvas::Item* i) + : Drag (e, i) + , region (0) +{ - nframes64_t start = _grab_frame; - _editor->snap_to (start, -1); - const Meter& m = _editor->session->tempo_map().meter_at(start); - const Tempo& t = _editor->session->tempo_map().tempo_at(start); - double length = floor (m.frames_per_bar(t, _editor->session->frame_rate())); +} - boost::shared_ptr src = _editor->session->create_midi_source_for_session(*diskstream.get()); - - mtv->playlist()->add_region (boost::dynamic_pointer_cast - (RegionFactory::create(src, 0, (nframes_t) length, - PBD::basename_nosuffix(src->name()))), start); - XMLNode &after = mtv->playlist()->get_state(); - _editor->session->add_command(new MementoCommand(*mtv->playlist().get(), &before, &after)); - _editor->commit_reversible_command(); +void +NoteResizeDrag::start_grab (GdkEvent* event, Gdk::Cursor *) +{ + Gdk::Cursor cursor; + ArdourCanvas::CanvasNote* cnote = dynamic_cast(_item); + + Drag::start_grab (event); + region = &cnote->region_view(); + + double region_start = region->get_position_pixels(); + double middle_point = region_start + cnote->x1() + (cnote->x2() - cnote->x1()) / 2.0L; + + if (grab_x() <= middle_point) { + cursor = Gdk::Cursor(Gdk::LEFT_SIDE); + at_front = true; } else { - motion (event, false); - // TODO: create region-create-drag region here + cursor = Gdk::Cursor(Gdk::RIGHT_SIDE); + at_front = false; + } + + _item->grab(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK, cursor, event->motion.time); + + if (event->motion.state & Keyboard::PrimaryModifier) { + relative = false; + } else { + relative = true; + } + + MidiRegionSelection& ms (_editor->get_selection().midi_regions); + + if (ms.size() > 1) { + /* has to be relative, may make no sense otherwise */ + relative = true; + } + + region->note_selected (cnote, true); + + for (MidiRegionSelection::iterator r = ms.begin(); r != ms.end(); ) { + MidiRegionSelection::iterator next; + next = r; + ++next; + (*r)->begin_resizing (at_front); + r = next; } } +void +NoteResizeDrag::motion (GdkEvent* /*event*/, bool /*first_move*/) +{ + MidiRegionSelection& ms (_editor->get_selection().midi_regions); + for (MidiRegionSelection::iterator r = ms.begin(); r != ms.end(); ++r) { + (*r)->update_resizing (at_front, _drags->current_pointer_x() - grab_x(), relative); + } +} +void +NoteResizeDrag::finished (GdkEvent*, bool /*movement_occurred*/) +{ + MidiRegionSelection& ms (_editor->get_selection().midi_regions); + for (MidiRegionSelection::iterator r = ms.begin(); r != ms.end(); ++r) { + (*r)->commit_resizing (at_front, _drags->current_pointer_x() - grab_x(), relative); + } +} +void +NoteResizeDrag::aborted () +{ + /* XXX: TODO */ +} void -RegionGainDrag::motion (GdkEvent* event, bool) +RegionGainDrag::motion (GdkEvent* /*event*/, bool) { - + } void @@ -1436,8 +1676,15 @@ RegionGainDrag::finished (GdkEvent *, bool) } +void +RegionGainDrag::aborted () +{ + /* XXX: TODO */ +} + TrimDrag::TrimDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list const & v) : RegionDrag (e, i, p, v) + , _have_transaction (false) { } @@ -1452,21 +1699,23 @@ TrimDrag::start_grab (GdkEvent* event, Gdk::Cursor *) if (tv && tv->is_track()) { speed = tv->get_diskstream()->speed(); } - + nframes64_t region_start = (nframes64_t) (_primary->region()->position() / speed); nframes64_t region_end = (nframes64_t) (_primary->region()->last_frame() / speed); nframes64_t region_length = (nframes64_t) (_primary->region()->length() / speed); Drag::start_grab (event, _editor->trimmer_cursor); - + + nframes64_t const pf = adjusted_current_frame (event); + if (Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) { _operation = ContentsTrim; } else { /* These will get overridden for a point trim.*/ - if (_current_pointer_frame < (region_start + region_length/2)) { + if (pf < (region_start + region_length/2)) { /* closer to start */ _operation = StartTrim; - } else if (_current_pointer_frame > (region_end - region_length/2)) { + } else if (pf > (region_end - region_length/2)) { /* closer to end */ _operation = EndTrim; } @@ -1474,13 +1723,13 @@ TrimDrag::start_grab (GdkEvent* event, Gdk::Cursor *) switch (_operation) { case StartTrim: - _editor->show_verbose_time_cursor (region_start, 10); + _editor->show_verbose_time_cursor (region_start, 10); break; case EndTrim: - _editor->show_verbose_time_cursor (region_end, 10); + _editor->show_verbose_time_cursor (region_end, 10); break; case ContentsTrim: - _editor->show_verbose_time_cursor (_current_pointer_frame, 10); + _editor->show_verbose_time_cursor (pf, 10); break; } } @@ -1492,12 +1741,12 @@ TrimDrag::motion (GdkEvent* event, bool first_move) nframes64_t frame_delta = 0; bool left_direction; - bool obey_snap = !Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier()); + bool obey_snap = event ? !Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier()) : false; /* snap modifier works differently here.. - its' current state has to be passed to the - various trim functions in order to work properly - */ + its current state has to be passed to the + various trim functions in order to work properly + */ double speed = 1.0; TimeAxisView* tvp = &_primary->get_time_axis_view (); @@ -1507,23 +1756,17 @@ TrimDrag::motion (GdkEvent* event, bool first_move) if (tv && tv->is_track()) { speed = tv->get_diskstream()->speed(); } - - if (_last_pointer_frame > _current_pointer_frame) { + + nframes64_t const pf = adjusted_current_frame (event); + + if (last_pointer_frame() > pf) { left_direction = true; } else { left_direction = false; } - if (obey_snap) { - _editor->snap_to (_current_pointer_frame); - } - - if (_current_pointer_frame == _last_pointer_frame) { - return; - } - if (first_move) { - + string trim_type; switch (_operation) { @@ -1539,73 +1782,74 @@ TrimDrag::motion (GdkEvent* event, bool first_move) } _editor->begin_reversible_command (trim_type); + _have_transaction = true; - for (list::const_iterator i = _views.begin(); i != _views.end(); ++i) { - (*i)->fake_set_opaque(false); - (*i)->region()->freeze (); - - AudioRegionView* const arv = dynamic_cast(*i); + for (list::const_iterator i = _views.begin(); i != _views.end(); ++i) { + RegionView* rv = i->view; + rv->fake_set_opaque(false); + rv->region()->clear_history (); + rv->region()->suspend_property_changes (); + + AudioRegionView* const arv = dynamic_cast (rv); if (arv){ arv->temporarily_hide_envelope (); } - boost::shared_ptr pl = (*i)->region()->playlist(); + boost::shared_ptr pl = rv->region()->playlist(); insert_result = _editor->motion_frozen_playlists.insert (pl); if (insert_result.second) { - _editor->session->add_command(new MementoCommand(*pl, &pl->get_state(), 0)); pl->freeze(); } } } if (left_direction) { - frame_delta = (_last_pointer_frame - _current_pointer_frame); + frame_delta = (last_pointer_frame() - pf); } else { - frame_delta = (_current_pointer_frame - _last_pointer_frame); + frame_delta = (pf - last_pointer_frame()); } bool non_overlap_trim = false; - if (Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) { + if (event && Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) { non_overlap_trim = true; } - switch (_operation) { + switch (_operation) { case StartTrim: - if ((left_direction == false) && (_current_pointer_frame <= rv->region()->first_frame()/speed)) { + if ((left_direction == false) && (pf <= rv->region()->first_frame()/speed)) { break; } else { - for (list::const_iterator i = _views.begin(); i != _views.end(); ++i) { - _editor->single_start_trim (**i, frame_delta, left_direction, obey_snap, non_overlap_trim); + for (list::const_iterator i = _views.begin(); i != _views.end(); ++i) { + _editor->single_start_trim (*i->view, frame_delta, left_direction, obey_snap, non_overlap_trim); } break; } - + case EndTrim: - if ((left_direction == true) && (_current_pointer_frame > (nframes64_t) (rv->region()->last_frame()/speed))) { + if ((left_direction == true) && (pf > (nframes64_t) (rv->region()->last_frame()/speed))) { break; } else { - for (list::const_iterator i = _views.begin(); i != _views.end(); ++i) { - _editor->single_end_trim (**i, frame_delta, left_direction, obey_snap, non_overlap_trim); + for (list::const_iterator i = _views.begin(); i != _views.end(); ++i) { + _editor->single_end_trim (*i->view, frame_delta, left_direction, obey_snap, non_overlap_trim); } break; } - + case ContentsTrim: { bool swap_direction = false; - if (Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) { + if (event && Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) { swap_direction = true; } - - for (list::const_iterator i = _views.begin(); i != _views.end(); ++i) - { - _editor->single_contents_trim (**i, frame_delta, left_direction, swap_direction, obey_snap); + + for (list::const_iterator i = _views.begin(); i != _views.end(); ++i) { + _editor->single_contents_trim (*i->view, frame_delta, left_direction, swap_direction, obey_snap); } } break; @@ -1613,17 +1857,15 @@ TrimDrag::motion (GdkEvent* event, bool first_move) switch (_operation) { case StartTrim: - _editor->show_verbose_time_cursor((nframes64_t) (rv->region()->position()/speed), 10); + _editor->show_verbose_time_cursor((nframes64_t) (rv->region()->position()/speed), 10); break; case EndTrim: - _editor->show_verbose_time_cursor((nframes64_t) (rv->region()->last_frame()/speed), 10); + _editor->show_verbose_time_cursor((nframes64_t) (rv->region()->last_frame()/speed), 10); break; case ContentsTrim: - _editor->show_verbose_time_cursor(_current_pointer_frame, 10); + _editor->show_verbose_time_cursor (pf, 10); break; } - - _last_pointer_frame = _current_pointer_frame; } @@ -1632,28 +1874,47 @@ TrimDrag::finished (GdkEvent* event, bool movement_occurred) { if (movement_occurred) { motion (event, false); - + if (!_editor->selection->selected (_primary)) { - _editor->thaw_region_after_trim (*_primary); + _editor->thaw_region_after_trim (*_primary); } else { - - for (list::const_iterator i = _views.begin(); i != _views.end(); ++i) { - _editor->thaw_region_after_trim (**i); - (*i)->fake_set_opaque (true); + + for (list::const_iterator i = _views.begin(); i != _views.end(); ++i) { + _editor->thaw_region_after_trim (*i->view); + i->view->fake_set_opaque (true); + if (_have_transaction) { + _editor->session()->add_command (new StatefulDiffCommand (i->view->region())); + } } } - for (set >::iterator p = _editor->motion_frozen_playlists.begin(); p != _editor->motion_frozen_playlists.end(); ++p) { (*p)->thaw (); - _editor->session->add_command (new MementoCommand(*(*p).get(), 0, &(*p)->get_state())); } - + _editor->motion_frozen_playlists.clear (); - _editor->commit_reversible_command(); + if (_have_transaction) { + _editor->commit_reversible_command(); + } + } else { /* no mouse movement */ - _editor->point_trim (event); + _editor->point_trim (event, adjusted_current_frame (event)); + } +} + +void +TrimDrag::aborted () +{ + /* Our motion method is changing model state, so use the Undo system + to cancel. Perhaps not ideal, as this will leave an Undo point + behind which may be slightly odd from the user's point of view. + */ + + finished (0, true); + + if (_have_transaction) { + _editor->undo (); } } @@ -1673,43 +1934,37 @@ MeterMarkerDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor) // The actual copying is not done before we reach the finish callback. char name[64]; snprintf (name, sizeof(name), "%g/%g", _marker->meter().beats_per_bar(), _marker->meter().note_divisor ()); - MeterMarker* new_marker = new MeterMarker(*_editor, *_editor->meter_group, ARDOUR_UI::config()->canvasvar_MeterMarker.get(), name, + MeterMarker* new_marker = new MeterMarker(*_editor, *_editor->meter_group, ARDOUR_UI::config()->canvasvar_MeterMarker.get(), name, *new MeterSection (_marker->meter())); _item = &new_marker->the_item (); _marker = new_marker; - + } else { MetricSection& section (_marker->meter()); - + if (!section.movable()) { return; } - + } Drag::start_grab (event, cursor); - - _pointer_frame_offset = _grab_frame - _marker->meter().frame(); - _editor->show_verbose_time_cursor (_current_pointer_frame, 10); + _pointer_frame_offset = grab_frame() - _marker->meter().frame(); + + _editor->show_verbose_time_cursor (adjusted_current_frame(event), 10); } void MeterMarkerDrag::motion (GdkEvent* event, bool) { - nframes64_t const adjusted_frame = adjusted_current_frame (event); - - if (adjusted_frame == _last_pointer_frame) { - return; - } + nframes64_t const pf = adjusted_current_frame (event); - _marker->set_position (adjusted_frame); + _marker->set_position (pf); - _last_pointer_frame = adjusted_frame; - - _editor->show_verbose_time_cursor (adjusted_frame, 10); + _editor->show_verbose_time_cursor (pf, 10); } void @@ -1720,18 +1975,18 @@ MeterMarkerDrag::finished (GdkEvent* event, bool movement_occurred) } motion (event, false); - + BBT_Time when; - - TempoMap& map (_editor->session->tempo_map()); - map.bbt_time (_last_pointer_frame, when); - + + TempoMap& map (_editor->session()->tempo_map()); + map.bbt_time (last_pointer_frame(), when); + if (_copy == true) { _editor->begin_reversible_command (_("copy meter mark")); XMLNode &before = map.get_state(); map.add_meter (_marker->meter(), when); XMLNode &after = map.get_state(); - _editor->session->add_command(new MementoCommand(map, &before, &after)); + _editor->session()->add_command(new MementoCommand(map, &before, &after)); _editor->commit_reversible_command (); // delete the dummy marker we used for visual representation of copying. @@ -1742,11 +1997,17 @@ MeterMarkerDrag::finished (GdkEvent* event, bool movement_occurred) XMLNode &before = map.get_state(); map.move_meter (_marker->meter(), when); XMLNode &after = map.get_state(); - _editor->session->add_command(new MementoCommand(map, &before, &after)); + _editor->session()->add_command(new MementoCommand(map, &before, &after)); _editor->commit_reversible_command (); } } +void +MeterMarkerDrag::aborted () +{ + _marker->set_position (_marker->meter().frame ()); +} + TempoMarkerDrag::TempoMarkerDrag (Editor* e, ArdourCanvas::Item* i, bool c) : Drag (e, i), _copy (c) @@ -1760,12 +2021,12 @@ TempoMarkerDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor) { if (_copy) { - + // create a dummy marker for visual representation of moving the copy. // The actual copying is not done before we reach the finish callback. char name[64]; snprintf (name, sizeof (name), "%.2f", _marker->tempo().beats_per_minute()); - TempoMarker* new_marker = new TempoMarker(*_editor, *_editor->tempo_group, ARDOUR_UI::config()->canvasvar_TempoMarker.get(), name, + TempoMarker* new_marker = new TempoMarker(*_editor, *_editor->tempo_group, ARDOUR_UI::config()->canvasvar_TempoMarker.get(), name, *new TempoSection (_marker->tempo())); _item = &new_marker->the_item (); @@ -1774,7 +2035,7 @@ TempoMarkerDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor) } else { MetricSection& section (_marker->tempo()); - + if (!section.movable()) { return; } @@ -1782,26 +2043,16 @@ TempoMarkerDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor) Drag::start_grab (event, cursor); - _pointer_frame_offset = _grab_frame - _marker->tempo().frame(); - _editor->show_verbose_time_cursor (_current_pointer_frame, 10); + _pointer_frame_offset = grab_frame() - _marker->tempo().frame(); + _editor->show_verbose_time_cursor (adjusted_current_frame (event), 10); } void TempoMarkerDrag::motion (GdkEvent* event, bool) { - nframes64_t const adjusted_frame = adjusted_current_frame (event); - - if (adjusted_frame == _last_pointer_frame) { - return; - } - - /* OK, we've moved far enough to make it worth actually move the thing. */ - - _marker->set_position (adjusted_frame); - - _editor->show_verbose_time_cursor (adjusted_frame, 10); - - _last_pointer_frame = adjusted_frame; + nframes64_t const pf = adjusted_current_frame (event); + _marker->set_position (pf); + _editor->show_verbose_time_cursor (pf, 10); } void @@ -1810,22 +2061,22 @@ TempoMarkerDrag::finished (GdkEvent* event, bool movement_occurred) if (!movement_occurred) { return; } - + motion (event, false); - + BBT_Time when; - - TempoMap& map (_editor->session->tempo_map()); - map.bbt_time (_last_pointer_frame, when); + + TempoMap& map (_editor->session()->tempo_map()); + map.bbt_time (last_pointer_frame(), when); if (_copy == true) { _editor->begin_reversible_command (_("copy tempo mark")); XMLNode &before = map.get_state(); map.add_tempo (_marker->tempo(), when); XMLNode &after = map.get_state(); - _editor->session->add_command (new MementoCommand(map, &before, &after)); + _editor->session()->add_command (new MementoCommand(map, &before, &after)); _editor->commit_reversible_command (); - + // delete the dummy marker we used for visual representation of copying. // a new visual marker will show up automatically. delete _marker; @@ -1834,11 +2085,16 @@ TempoMarkerDrag::finished (GdkEvent* event, bool movement_occurred) XMLNode &before = map.get_state(); map.move_tempo (_marker->tempo(), when); XMLNode &after = map.get_state(); - _editor->session->add_command (new MementoCommand(map, &before, &after)); + _editor->session()->add_command (new MementoCommand(map, &before, &after)); _editor->commit_reversible_command (); } } +void +TempoMarkerDrag::aborted () +{ + _marker->set_position (_marker->tempo().frame()); +} CursorDrag::CursorDrag (Editor* e, ArdourCanvas::Item* i, bool s) : Drag (e, i), @@ -1854,10 +2110,10 @@ CursorDrag::start_grab (GdkEvent* event, Gdk::Cursor* c) Drag::start_grab (event, c); if (!_stop) { - + nframes64_t where = _editor->event_frame (event, 0, 0); - _editor->snap_to (where); + _editor->snap_to_with_modifier (where, event); _editor->playhead_cursor->set_position (where); } @@ -1865,17 +2121,17 @@ CursorDrag::start_grab (GdkEvent* event, Gdk::Cursor* c) if (_cursor == _editor->playhead_cursor) { _editor->_dragging_playhead = true; - if (_editor->session && _was_rolling && _stop) { - _editor->session->request_stop (); + if (_editor->session() && _was_rolling && _stop) { + _editor->session()->request_stop (); } - if (_editor->session && _editor->session->is_auditioning()) { - _editor->session->cancel_audition (); + if (_editor->session() && _editor->session()->is_auditioning()) { + _editor->session()->cancel_audition (); } } - _pointer_frame_offset = _grab_frame - _cursor->current_frame; - + _pointer_frame_offset = grab_frame() - _cursor->current_frame; + _editor->show_verbose_time_cursor (_cursor->current_frame, 10); } @@ -1884,7 +2140,7 @@ CursorDrag::motion (GdkEvent* event, bool) { nframes64_t const adjusted_frame = adjusted_current_frame (event); - if (adjusted_frame == _last_pointer_frame) { + if (adjusted_frame == last_pointer_frame()) { return; } @@ -1896,8 +2152,6 @@ CursorDrag::motion (GdkEvent* event, bool) _editor->update_canvas_now (); #endif _editor->UpdateAllTransportClocks (_cursor->current_frame); - - _last_pointer_frame = adjusted_frame; } void @@ -1908,21 +2162,28 @@ CursorDrag::finished (GdkEvent* event, bool movement_occurred) if (!movement_occurred && _stop) { return; } - + motion (event, false); - + if (_item == &_editor->playhead_cursor->canvas_item) { - if (_editor->session) { - _editor->session->request_locate (_editor->playhead_cursor->current_frame, _was_rolling); + if (_editor->session()) { + _editor->session()->request_locate (_editor->playhead_cursor->current_frame, _was_rolling); _editor->_pending_locate_request = true; } - } + } +} + +void +CursorDrag::aborted () +{ + _editor->_dragging_playhead = false; + _cursor->set_position (adjusted_frame (grab_frame (), 0, false)); } FadeInDrag::FadeInDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list const & v) : RegionDrag (e, i, p, v) { - + } void @@ -1932,8 +2193,9 @@ FadeInDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor) AudioRegionView* a = dynamic_cast (_primary); boost::shared_ptr const r = a->audio_region (); - - _pointer_frame_offset = _grab_frame - ((nframes64_t) r->fade_in()->back()->when + r->position()); + + _pointer_frame_offset = grab_frame() - ((nframes64_t) r->fade_in()->back()->when + r->position()); + _editor->show_verbose_duration_cursor (r->position(), r->position() + r->fade_in()->back()->when, 10); } void @@ -1942,7 +2204,7 @@ FadeInDrag::motion (GdkEvent* event, bool) nframes64_t fade_length; nframes64_t const pos = adjusted_current_frame (event); - + boost::shared_ptr region = _primary->region (); if (pos < (region->position() + 64)) { @@ -1951,16 +2213,16 @@ FadeInDrag::motion (GdkEvent* event, bool) fade_length = region->length(); } else { fade_length = pos - region->position(); - } + } - for (RegionSelection::iterator i = _views.begin(); i != _views.end(); ++i) { + for (list::iterator i = _views.begin(); i != _views.end(); ++i) { + + AudioRegionView* tmp = dynamic_cast (i->view); - AudioRegionView* tmp = dynamic_cast (*i); - if (!tmp) { continue; } - + tmp->reset_fade_in_shape_width (fade_length); } @@ -1977,7 +2239,7 @@ FadeInDrag::finished (GdkEvent* event, bool movement_occurred) nframes64_t fade_length; nframes64_t const pos = adjusted_current_frame (event); - + boost::shared_ptr region = _primary->region (); if (pos < (region->position() + 64)) { @@ -1987,34 +2249,48 @@ FadeInDrag::finished (GdkEvent* event, bool movement_occurred) } else { fade_length = pos - region->position(); } - + _editor->begin_reversible_command (_("change fade in length")); - for (RegionSelection::iterator i = _views.begin(); i != _views.end(); ++i) { + for (list::iterator i = _views.begin(); i != _views.end(); ++i) { + + AudioRegionView* tmp = dynamic_cast (i->view); - AudioRegionView* tmp = dynamic_cast (*i); - if (!tmp) { continue; } - + boost::shared_ptr alist = tmp->audio_region()->fade_in(); XMLNode &before = alist->get_state(); tmp->audio_region()->set_fade_in_length (fade_length); tmp->audio_region()->set_fade_in_active (true); - + XMLNode &after = alist->get_state(); - _editor->session->add_command(new MementoCommand(*alist.get(), &before, &after)); + _editor->session()->add_command(new MementoCommand(*alist.get(), &before, &after)); } _editor->commit_reversible_command (); } +void +FadeInDrag::aborted () +{ + for (list::iterator i = _views.begin(); i != _views.end(); ++i) { + AudioRegionView* tmp = dynamic_cast (i->view); + + if (!tmp) { + continue; + } + + tmp->reset_fade_in_shape_width (tmp->audio_region()->fade_in()->back()->when); + } +} + FadeOutDrag::FadeOutDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list const & v) : RegionDrag (e, i, p, v) { - + } void @@ -2024,8 +2300,9 @@ FadeOutDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor) AudioRegionView* a = dynamic_cast (_primary); boost::shared_ptr r = a->audio_region (); - - _pointer_frame_offset = _grab_frame - (r->length() - (nframes64_t) r->fade_out()->back()->when + r->position()); + + _pointer_frame_offset = grab_frame() - (r->length() - (nframes64_t) r->fade_out()->back()->when + r->position()); + _editor->show_verbose_duration_cursor (r->last_frame() - r->fade_out()->back()->when, r->last_frame(), 10); } void @@ -2036,7 +2313,7 @@ FadeOutDrag::motion (GdkEvent* event, bool) nframes64_t const pos = adjusted_current_frame (event); boost::shared_ptr region = _primary->region (); - + if (pos > (region->last_frame() - 64)) { fade_length = 64; // this should really be a minimum fade defined somewhere } @@ -2046,15 +2323,15 @@ FadeOutDrag::motion (GdkEvent* event, bool) else { fade_length = region->last_frame() - pos; } - - for (RegionSelection::iterator i = _views.begin(); i != _views.end(); ++i) { - AudioRegionView* tmp = dynamic_cast (*i); - + for (list::iterator i = _views.begin(); i != _views.end(); ++i) { + + AudioRegionView* tmp = dynamic_cast (i->view); + if (!tmp) { continue; } - + tmp->reset_fade_out_shape_width (fade_length); } @@ -2086,27 +2363,41 @@ FadeOutDrag::finished (GdkEvent* event, bool movement_occurred) _editor->begin_reversible_command (_("change fade out length")); - for (RegionSelection::iterator i = _views.begin(); i != _views.end(); ++i) { + for (list::iterator i = _views.begin(); i != _views.end(); ++i) { + + AudioRegionView* tmp = dynamic_cast (i->view); - AudioRegionView* tmp = dynamic_cast (*i); - if (!tmp) { continue; } - + boost::shared_ptr alist = tmp->audio_region()->fade_out(); XMLNode &before = alist->get_state(); - + tmp->audio_region()->set_fade_out_length (fade_length); tmp->audio_region()->set_fade_out_active (true); XMLNode &after = alist->get_state(); - _editor->session->add_command(new MementoCommand(*alist.get(), &before, &after)); + _editor->session()->add_command(new MementoCommand(*alist.get(), &before, &after)); } _editor->commit_reversible_command (); } +void +FadeOutDrag::aborted () +{ + for (list::iterator i = _views.begin(); i != _views.end(); ++i) { + AudioRegionView* tmp = dynamic_cast (i->view); + + if (!tmp) { + continue; + } + + tmp->reset_fade_out_shape_width (tmp->audio_region()->fade_out()->back()->when); + } +} + MarkerDrag::MarkerDrag (Editor* e, ArdourCanvas::Item* i) : Drag (e, i) { @@ -2135,13 +2426,13 @@ void MarkerDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor) { Drag::start_grab (event, cursor); - + bool is_start; Location *location = _editor->find_location_from_marker (_marker, is_start); _editor->_dragging_edit_point = true; - _pointer_frame_offset = _grab_frame - (is_start ? location->start() : location->end()); + _pointer_frame_offset = grab_frame() - (is_start ? location->start() : location->end()); update_item (location); @@ -2154,7 +2445,7 @@ MarkerDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor) _editor->show_verbose_time_cursor (location->end(), 10); } - Selection::Operation op = Keyboard::selection_type (event->button.state); + Selection::Operation op = ArdourKeyboard::selection_type (event->button.state); switch (op) { case Selection::Toggle: @@ -2178,7 +2469,7 @@ MarkerDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor) if (e < max_frames) { ++e; } - _editor->session->locations()->find_all_between (s, e, ll, Location::Flags (0)); + _editor->session()->locations()->find_all_between (s, e, ll, Location::Flags (0)); for (Locations::LocationList::iterator i = ll.begin(); i != ll.end(); ++i) { Editor::LocationMarkers* lm = _editor->find_location_markers (*i); if (lm) { @@ -2200,10 +2491,10 @@ MarkerDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor) break; } - /* set up copies for us to manipulate during the drag */ + /* Set up copies for us to manipulate during the drag */ for (MarkerSelection::iterator i = _editor->selection->markers.begin(); i != _editor->selection->markers.end(); ++i) { - Location *l = _editor->find_location_from_marker (*i, is_start); + Location* l = _editor->find_location_from_marker (*i, is_start); _copied_locations.push_back (new Location (*l)); } } @@ -2215,14 +2506,14 @@ MarkerDrag::motion (GdkEvent* event, bool) bool is_start; bool move_both = false; Marker* marker; - Location *real_location; + Location *real_location; Location *copy_location = 0; nframes64_t const newframe = adjusted_current_frame (event); nframes64_t next = newframe; - - if (_current_pointer_frame == _last_pointer_frame) { + + if (newframe == last_pointer_frame()) { return; } @@ -2235,8 +2526,8 @@ MarkerDrag::motion (GdkEvent* event, bool) /* find the marker we're dragging, and compute the delta */ - for (i = _editor->selection->markers.begin(), x = _copied_locations.begin(); - x != _copied_locations.end() && i != _editor->selection->markers.end(); + for (i = _editor->selection->markers.begin(), x = _copied_locations.begin(); + x != _copied_locations.end() && i != _editor->selection->markers.end(); ++i, ++x) { copy_location = *x; @@ -2282,49 +2573,49 @@ MarkerDrag::motion (GdkEvent* event, bool) /* now move them all */ - for (i = _editor->selection->markers.begin(), x = _copied_locations.begin(); - x != _copied_locations.end() && i != _editor->selection->markers.end(); + for (i = _editor->selection->markers.begin(), x = _copied_locations.begin(); + x != _copied_locations.end() && i != _editor->selection->markers.end(); ++i, ++x) { copy_location = *x; marker = *i; /* call this to find out if its the start or end */ - + if ((real_location = _editor->find_location_from_marker (marker, is_start)) == 0) { continue; } - + if (real_location->locked()) { continue; } if (copy_location->is_mark()) { - /* just move it */ - + /* now move it */ + copy_location->set_start (copy_location->start() + f_delta); } else { - + nframes64_t new_start = copy_location->start() + f_delta; nframes64_t new_end = copy_location->end() + f_delta; - + if (is_start) { // start-of-range marker - + if (move_both) { copy_location->set_start (new_start); copy_location->set_end (new_end); } else if (new_start < copy_location->end()) { copy_location->set_start (new_start); - } else { + } else { _editor->snap_to (next, 1, true); copy_location->set_end (next); copy_location->set_start (newframe); } - + } else { // end marker - + if (move_both) { copy_location->set_end (new_end); copy_location->set_start (new_start); @@ -2347,17 +2638,13 @@ MarkerDrag::motion (GdkEvent* event, bool) } } - _last_pointer_frame = _current_pointer_frame; - assert (!_copied_locations.empty()); - _editor->edit_point_clock.set (_copied_locations.front()->start()); _editor->show_verbose_time_cursor (newframe, 10); #ifdef GTKOSX _editor->update_canvas_now (); #endif - _editor->edit_point_clock.set (copy_location->start()); } void @@ -2369,7 +2656,7 @@ MarkerDrag::finished (GdkEvent* event, bool movement_occurred) off the selection process */ - Selection::Operation op = Keyboard::selection_type (event->button.state); + Selection::Operation op = ArdourKeyboard::selection_type (event->button.state); switch (op) { case Selection::Set: @@ -2383,31 +2670,31 @@ MarkerDrag::finished (GdkEvent* event, bool movement_occurred) case Selection::Add: break; } - + return; } _editor->_dragging_edit_point = false; - + _editor->begin_reversible_command ( _("move marker") ); - XMLNode &before = _editor->session->locations()->get_state(); + XMLNode &before = _editor->session()->locations()->get_state(); MarkerSelection::iterator i; list::iterator x; bool is_start; - for (i = _editor->selection->markers.begin(), x = _copied_locations.begin(); - x != _copied_locations.end() && i != _editor->selection->markers.end(); + for (i = _editor->selection->markers.begin(), x = _copied_locations.begin(); + x != _copied_locations.end() && i != _editor->selection->markers.end(); ++i, ++x) { - + Location * location = _editor->find_location_from_marker (*i, is_start); - + if (location) { - + if (location->locked()) { return; } - + if (location->is_mark()) { location->set_start ((*x)->start()); } else { @@ -2416,13 +2703,19 @@ MarkerDrag::finished (GdkEvent* event, bool movement_occurred) } } - XMLNode &after = _editor->session->locations()->get_state(); - _editor->session->add_command(new MementoCommand(*(_editor->session->locations()), &before, &after)); + XMLNode &after = _editor->session()->locations()->get_state(); + _editor->session()->add_command(new MementoCommand(*(_editor->session()->locations()), &before, &after)); _editor->commit_reversible_command (); - + _line->hide(); } +void +MarkerDrag::aborted () +{ + /* XXX: TODO */ +} + void MarkerDrag::update_item (Location* location) { @@ -2444,25 +2737,21 @@ ControlPointDrag::ControlPointDrag (Editor* e, ArdourCanvas::Item* i) void -ControlPointDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor) +ControlPointDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*cursor*/) { Drag::start_grab (event, _editor->fader_cursor); // start the grab at the center of the control point so // the point doesn't 'jump' to the mouse after the first drag - _grab_x = _point->get_x(); - _grab_y = _point->get_y(); - - _point->line().parent_group().i2w (_grab_x, _grab_y); - _editor->track_canvas->w2c (_grab_x, _grab_y, _grab_x, _grab_y); + _time_axis_view_grab_x = _point->get_x(); + _time_axis_view_grab_y = _point->get_y(); - _grab_frame = _editor->pixel_to_frame (_grab_x); + float const fraction = 1 - (_point->get_y() / _point->line().height()); - _point->line().start_drag (_point, _grab_frame, 0); + _point->line().start_drag_single (_point, _time_axis_view_grab_x, fraction); - float fraction = 1.0 - (_point->get_y() / _point->line().height()); - _editor->set_verbose_canvas_cursor (_point->line().get_verbose_cursor_string (fraction), - _current_pointer_x + 10, _current_pointer_y + 10); + _editor->set_verbose_canvas_cursor (_point->line().get_verbose_cursor_string (fraction), + event->button.x + 10, event->button.y + 10); _editor->show_verbose_canvas_cursor (); } @@ -2470,58 +2759,53 @@ ControlPointDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor) void ControlPointDrag::motion (GdkEvent* event, bool) { - double dx = _current_pointer_x - _last_pointer_x; - double dy = _current_pointer_y - _last_pointer_y; + double dx = _drags->current_pointer_x() - last_pointer_x(); + double dy = _drags->current_pointer_y() - last_pointer_y(); if (event->button.state & Keyboard::SecondaryModifier) { dx *= 0.1; dy *= 0.1; } - double cx = _grab_x + _cumulative_x_drag + dx; - double cy = _grab_y + _cumulative_y_drag + dy; + /* coordinate in TimeAxisView's space */ + double cx = _time_axis_view_grab_x + _cumulative_x_drag + dx; + double cy = _time_axis_view_grab_y + _cumulative_y_drag + dy; // calculate zero crossing point. back off by .01 to stay on the // positive side of zero - double _unused = 0; - double zero_gain_y = (1.0 - _zero_gain_fraction) * _point->line().height() - .01; - _point->line().parent_group().i2w(_unused, zero_gain_y); + double const zero_gain_y = (1.0 - _zero_gain_fraction) * _point->line().height() - .01; // make sure we hit zero when passing through - if ((cy < zero_gain_y and (cy - dy) > zero_gain_y) - or (cy > zero_gain_y and (cy - dy) < zero_gain_y)) { + if ((cy < zero_gain_y && (cy - dy) > zero_gain_y) || (cy > zero_gain_y && (cy - dy) < zero_gain_y)) { cy = zero_gain_y; } if (_x_constrained) { - cx = _grab_x; + cx = _time_axis_view_grab_x; } if (_y_constrained) { - cy = _grab_y; + cy = _time_axis_view_grab_y; } - _cumulative_x_drag = cx - _grab_x; - _cumulative_y_drag = cy - _grab_y; - - _point->line().parent_group().w2i (cx, cy); + _cumulative_x_drag = cx - _time_axis_view_grab_x; + _cumulative_y_drag = cy - _time_axis_view_grab_y; cx = max (0.0, cx); cy = max (0.0, cy); cy = min ((double) _point->line().height(), cy); - //translate cx to frames nframes64_t cx_frames = _editor->unit_to_frame (cx); - if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier()) && !_x_constrained) { - _editor->snap_to (cx_frames); + if (!_x_constrained) { + _editor->snap_to_with_modifier (cx_frames, event); } float const fraction = 1.0 - (cy / _point->line().height()); bool const push = Keyboard::modifier_state_contains (event->button.state, Keyboard::PrimaryModifier); - _point->line().point_drag (*_point, cx_frames, fraction, push); - + _point->line().drag_motion (_editor->frame_to_unit (cx_frames), fraction, false, push); + _editor->set_verbose_canvas_cursor_text (_point->line().get_verbose_cursor_string (fraction)); } @@ -2531,7 +2815,7 @@ ControlPointDrag::finished (GdkEvent* event, bool movement_occurred) if (!movement_occurred) { /* just a click */ - + if ((event->type == GDK_BUTTON_RELEASE) && (event->button.button == 1) && Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) { _editor->reset_point_selection (); } @@ -2539,7 +2823,25 @@ ControlPointDrag::finished (GdkEvent* event, bool movement_occurred) } else { motion (event, false); } - _point->line().end_drag (_point); + _point->line().end_drag (); +} + +void +ControlPointDrag::aborted () +{ + _point->line().reset (); +} + +bool +ControlPointDrag::active (Editing::MouseMode m) +{ + if (m == Editing::MouseGain) { + /* always active in mouse gain */ + return true; + } + + /* otherwise active if the point is on an automation line (ie not if its on a region gain line) */ + return dynamic_cast (&(_point->line())) != 0; } LineDrag::LineDrag (Editor* e, ArdourCanvas::Item* i) @@ -2550,7 +2852,7 @@ LineDrag::LineDrag (Editor* e, ArdourCanvas::Item* i) } void -LineDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor) +LineDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*cursor*/) { _line = reinterpret_cast (_item->get_data ("line")); assert (_line); @@ -2568,7 +2870,10 @@ LineDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor) nframes64_t const frame_within_region = (nframes64_t) floor (cx * _editor->frames_per_unit); - if (!_line->control_points_adjacent (frame_within_region, _before, _after)) { + uint32_t before; + uint32_t after; + + if (!_line->control_points_adjacent (frame_within_region, before, after)) { /* no adjacent points */ return; } @@ -2577,31 +2882,31 @@ LineDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor) /* store grab start in parent frame */ - _grab_x = cx; - _grab_y = cy; + _time_axis_view_grab_x = cx; + _time_axis_view_grab_y = cy; double fraction = 1.0 - (cy / _line->height()); - _line->start_drag (0, _grab_frame, fraction); - + _line->start_drag_line (before, after, fraction); + _editor->set_verbose_canvas_cursor (_line->get_verbose_cursor_string (fraction), - _current_pointer_x + 10, _current_pointer_y + 10); - + event->button.x + 10, event->button.y + 10); + _editor->show_verbose_canvas_cursor (); } void LineDrag::motion (GdkEvent* event, bool) { - double dy = _current_pointer_y - _last_pointer_y; - + double dy = _drags->current_pointer_y() - last_pointer_y(); + if (event->button.state & Keyboard::SecondaryModifier) { dy *= 0.1; } - double cy = _grab_y + _cumulative_y_drag + dy; + double cy = _time_axis_view_grab_y + _cumulative_y_drag + dy; - _cumulative_y_drag = cy - _grab_y; + _cumulative_y_drag = cy - _time_axis_view_grab_y; cy = max (0.0, cy); cy = min ((double) _line->height(), cy); @@ -2616,8 +2921,9 @@ LineDrag::motion (GdkEvent* event, bool) push = true; } - _line->line_drag (_before, _after, fraction, push); - + /* we are ignoring x position for this drag, so we can just pass in anything */ + _line->drag_motion (0, fraction, true, push); + _editor->set_verbose_canvas_cursor_text (_line->get_verbose_cursor_string (fraction)); } @@ -2625,61 +2931,61 @@ void LineDrag::finished (GdkEvent* event, bool) { motion (event, false); - _line->end_drag (0); + _line->end_drag (); +} + +void +LineDrag::aborted () +{ + _line->reset (); } void RubberbandSelectDrag::start_grab (GdkEvent* event, Gdk::Cursor *) { Drag::start_grab (event); - _editor->show_verbose_time_cursor (_current_pointer_frame, 10); + _editor->show_verbose_time_cursor (adjusted_current_frame (event), 10); } void -RubberbandSelectDrag::motion (GdkEvent* event, bool first_move) +RubberbandSelectDrag::motion (GdkEvent* event, bool) { nframes64_t start; nframes64_t end; double y1; double y2; - /* use a bigger drag threshold than the default */ + nframes64_t const pf = adjusted_current_frame (event, Config->get_rubberbanding_snaps_to_grid ()); - if (abs ((int) (_current_pointer_frame - _grab_frame)) < 8) { - return; + nframes64_t grab = grab_frame (); + if (Config->get_rubberbanding_snaps_to_grid ()) { + _editor->snap_to_with_modifier (grab, event); } - if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier()) && Config->get_rubberbanding_snaps_to_grid()) { - if (first_move) { - _editor->snap_to (_grab_frame); - } - _editor->snap_to (_current_pointer_frame); - } - /* base start and end on initial click position */ - if (_current_pointer_frame < _grab_frame) { - start = _current_pointer_frame; - end = _grab_frame; + if (pf < grab) { + start = pf; + end = grab; } else { - end = _current_pointer_frame; - start = _grab_frame; + end = pf; + start = grab; } - if (_current_pointer_y < _grab_y) { - y1 = _current_pointer_y; - y2 = _grab_y; + if (_drags->current_pointer_y() < grab_y()) { + y1 = _drags->current_pointer_y(); + y2 = grab_y(); } else { - y2 = _current_pointer_y; - y1 = _grab_y; + y2 = _drags->current_pointer_y(); + y1 = grab_y(); } - + if (start != end || y1 != y2) { double x1 = _editor->frame_to_pixel (start); double x2 = _editor->frame_to_pixel (end); - + _editor->rubberband_rect->property_x1() = x1; _editor->rubberband_rect->property_y1() = y1; _editor->rubberband_rect->property_x2() = x2; @@ -2687,10 +2993,8 @@ RubberbandSelectDrag::motion (GdkEvent* event, bool first_move) _editor->rubberband_rect->show(); _editor->rubberband_rect->raise_to_top(); - - _last_pointer_frame = _current_pointer_frame; - _editor->show_verbose_time_cursor (_current_pointer_frame, 10); + _editor->show_verbose_time_cursor (pf, 10); } } @@ -2702,30 +3006,30 @@ RubberbandSelectDrag::finished (GdkEvent* event, bool movement_occurred) motion (event, false); double y1,y2; - if (_current_pointer_y < _grab_y) { - y1 = _current_pointer_y; - y2 = _grab_y; + if (_drags->current_pointer_y() < grab_y()) { + y1 = _drags->current_pointer_y(); + y2 = grab_y(); } else { - y2 = _current_pointer_y; - y1 = _grab_y; + y2 = _drags->current_pointer_y(); + y1 = grab_y(); } - Selection::Operation op = Keyboard::selection_type (event->button.state); - bool commit; + Selection::Operation op = ArdourKeyboard::selection_type (event->button.state); + bool committed; _editor->begin_reversible_command (_("rubberband selection")); - if (_grab_frame < _last_pointer_frame) { - commit = _editor->select_all_within (_grab_frame, _last_pointer_frame, y1, y2, _editor->track_views, op); + if (grab_frame() < last_pointer_frame()) { + committed = _editor->select_all_within (grab_frame(), last_pointer_frame() - 1, y1, y2, _editor->track_views, op); } else { - commit = _editor->select_all_within (_last_pointer_frame, _grab_frame, y1, y2, _editor->track_views, op); - } + committed = _editor->select_all_within (last_pointer_frame(), grab_frame() - 1, y1, y2, _editor->track_views, op); + } - if (commit) { + if (!committed) { _editor->commit_reversible_command (); } - + } else { if (!getenv("ARDOUR_SAE")) { _editor->selection->clear_tracks(); @@ -2738,12 +3042,18 @@ RubberbandSelectDrag::finished (GdkEvent* event, bool movement_occurred) _editor->rubberband_rect->hide(); } +void +RubberbandSelectDrag::aborted () +{ + _editor->rubberband_rect->hide (); +} + void TimeFXDrag::start_grab (GdkEvent* event, Gdk::Cursor *) { Drag::start_grab (event); - - _editor->show_verbose_time_cursor (_current_pointer_frame, 10); + + _editor->show_verbose_time_cursor (adjusted_current_frame (event), 10); } void @@ -2751,60 +3061,59 @@ TimeFXDrag::motion (GdkEvent* event, bool) { RegionView* rv = _primary; - if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) { - _editor->snap_to (_current_pointer_frame); - } - - if (_current_pointer_frame == _last_pointer_frame) { - return; - } + nframes64_t const pf = adjusted_current_frame (event); - if (_current_pointer_frame > rv->region()->position()) { - rv->get_time_axis_view().show_timestretch (rv->region()->position(), _current_pointer_frame); + if (pf > rv->region()->position()) { + rv->get_time_axis_view().show_timestretch (rv->region()->position(), pf); } - _last_pointer_frame = _current_pointer_frame; - - _editor->show_verbose_time_cursor (_current_pointer_frame, 10); + _editor->show_verbose_time_cursor (pf, 10); } void -TimeFXDrag::finished (GdkEvent* event, bool movement_occurred) +TimeFXDrag::finished (GdkEvent* /*event*/, bool movement_occurred) { _primary->get_time_axis_view().hide_timestretch (); - if (!movement_occurred) { + if (!movement_occurred) { return; } - if (_last_pointer_frame < _primary->region()->position()) { + if (last_pointer_frame() < _primary->region()->position()) { /* backwards drag of the left edge - not usable */ return; } - - nframes64_t newlen = _last_pointer_frame - _primary->region()->position(); + + nframes64_t newlen = last_pointer_frame() - _primary->region()->position(); float percentage = (double) newlen / (double) _primary->region()->length(); - + #ifndef USE_RUBBERBAND - // Soundtouch uses percentage / 100 instead of normal (/ 1) + // Soundtouch uses percentage / 100 instead of normal (/ 1) if (_primary->region()->data_type() == DataType::AUDIO) { percentage = (float) ((double) newlen - (double) _primary->region()->length()) / ((double) newlen) * 100.0f; } -#endif - +#endif + _editor->begin_reversible_command (_("timestretch")); - + // XXX how do timeFX on multiple regions ? - + RegionSelection rs; rs.add (_primary); - if (_editor->time_stretch (rs, percentage) == 0) { - _editor->session->commit_reversible_command (); + if (!_editor->time_stretch (rs, percentage) == 0) { + error << _("An error occurred while executing time stretch operation") << endmsg; } } +void +TimeFXDrag::aborted () +{ + _primary->get_time_axis_view().hide_timestretch (); +} + + void ScrubDrag::start_grab (GdkEvent* event, Gdk::Cursor *) { @@ -2812,24 +3121,32 @@ ScrubDrag::start_grab (GdkEvent* event, Gdk::Cursor *) } void -ScrubDrag::motion (GdkEvent* event, bool) +ScrubDrag::motion (GdkEvent* /*event*/, bool) { - _editor->scrub (); + _editor->scrub (adjusted_current_frame (0, false), _drags->current_pointer_x ()); } void -ScrubDrag::finished (GdkEvent* event, bool movement_occurred) +ScrubDrag::finished (GdkEvent* /*event*/, bool movement_occurred) { - if (movement_occurred && _editor->session) { + if (movement_occurred && _editor->session()) { /* make sure we stop */ - _editor->session->request_transport_speed (0.0); - } + _editor->session()->request_transport_speed (0.0); + } +} + +void +ScrubDrag::aborted () +{ + /* XXX: TODO */ } SelectionDrag::SelectionDrag (Editor* e, ArdourCanvas::Item* i, Operation o) - : Drag (e, i), - _operation (o), - _copy (false) + : Drag (e, i) + , _operation (o) + , _copy (false) + , _original_pointer_time_axis (-1) + , _last_pointer_time_axis (-1) { } @@ -2840,7 +3157,7 @@ SelectionDrag::start_grab (GdkEvent* event, Gdk::Cursor*) nframes64_t start = 0; nframes64_t end = 0; - if (_editor->session == 0) { + if (_editor->session() == 0) { return; } @@ -2860,35 +3177,35 @@ SelectionDrag::start_grab (GdkEvent* event, Gdk::Cursor*) case SelectionStartTrim: if (_editor->clicked_axisview) { _editor->clicked_axisview->order_selection_trims (_item, true); - } - Drag::start_grab (event, cursor); - cursor = _editor->trimmer_cursor; + } + Drag::start_grab (event, _editor->trimmer_cursor); start = _editor->selection->time[_editor->clicked_selection].start; - _pointer_frame_offset = _grab_frame - start; + _pointer_frame_offset = grab_frame() - start; break; - + case SelectionEndTrim: if (_editor->clicked_axisview) { _editor->clicked_axisview->order_selection_trims (_item, false); } - Drag::start_grab (event, cursor); - cursor = _editor->trimmer_cursor; + Drag::start_grab (event, _editor->trimmer_cursor); end = _editor->selection->time[_editor->clicked_selection].end; - _pointer_frame_offset = _grab_frame - end; + _pointer_frame_offset = grab_frame() - end; break; case SelectionMove: start = _editor->selection->time[_editor->clicked_selection].start; Drag::start_grab (event, cursor); - _pointer_frame_offset = _grab_frame - start; + _pointer_frame_offset = grab_frame() - start; break; } if (_operation == SelectionMove) { - _editor->show_verbose_time_cursor (start, 10); + _editor->show_verbose_time_cursor (start, 10); } else { - _editor->show_verbose_time_cursor (_current_pointer_frame, 10); + _editor->show_verbose_time_cursor (adjusted_current_frame (event), 10); } + + _original_pointer_time_axis = _editor->trackview_by_y_position (_drags->current_pointer_y ()).first->order (); } void @@ -2898,56 +3215,90 @@ SelectionDrag::motion (GdkEvent* event, bool first_move) nframes64_t end = 0; nframes64_t length; - nframes64_t const pending_position = adjusted_current_frame (event); + pair const pending_time_axis = _editor->trackview_by_y_position (_drags->current_pointer_y ()); + if (pending_time_axis.first == 0) { + return; + } - /* only alter selection if the current frame is - different from the last frame position (adjusted) - */ - - if (pending_position == _last_pointer_frame) { + nframes64_t const pending_position = adjusted_current_frame (event); + + /* only alter selection if things have changed */ + + if (pending_time_axis.first->order() == _last_pointer_time_axis && pending_position == last_pointer_frame()) { return; } - + switch (_operation) { case CreateSelection: - + { + nframes64_t grab = grab_frame (); + if (first_move) { - _editor->snap_to (_grab_frame); + _editor->snap_to (grab); } - - if (pending_position < _grab_frame) { + + if (pending_position < grab_frame()) { start = pending_position; - end = _grab_frame; + end = grab; } else { end = pending_position; - start = _grab_frame; + start = grab; } - + /* first drag: Either add to the selection - or create a new selection-> + or create a new selection */ - + if (first_move) { - - _editor->begin_reversible_command (_("range selection")); - + if (_copy) { /* adding to the selection */ + _editor->selection->add (_editor->clicked_axisview); _editor->clicked_selection = _editor->selection->add (start, end); _copy = false; } else { - /* new selection-> */ - _editor->clicked_selection = _editor->selection->set (_editor->clicked_axisview, start, end); + /* new selection */ + + if (!_editor->selection->selected (_editor->clicked_axisview)) { + _editor->selection->set (_editor->clicked_axisview); + } + + _editor->clicked_selection = _editor->selection->set (start, end); } - } - break; - - case SelectionStartTrim: - - if (first_move) { - _editor->begin_reversible_command (_("trim selection start")); } + + /* select the track that we're in */ + if (find (_added_time_axes.begin(), _added_time_axes.end(), pending_time_axis.first) == _added_time_axes.end()) { + _editor->selection->add (pending_time_axis.first); + _added_time_axes.push_back (pending_time_axis.first); + } + + /* deselect any tracks that this drag no longer includes, being careful to only deselect + tracks that we selected in the first place. + */ + int min_order = min (_original_pointer_time_axis, pending_time_axis.first->order()); + int max_order = max (_original_pointer_time_axis, pending_time_axis.first->order()); + + list::iterator i = _added_time_axes.begin(); + while (i != _added_time_axes.end()) { + + list::iterator tmp = i; + ++tmp; + + if ((*i)->order() < min_order || (*i)->order() > max_order) { + _editor->selection->remove (*i); + _added_time_axes.remove (*i); + } + + i = tmp; + } + + } + break; + + case SelectionStartTrim: + start = _editor->selection->time[_editor->clicked_selection].start; end = _editor->selection->time[_editor->clicked_selection].end; @@ -2957,13 +3308,9 @@ SelectionDrag::motion (GdkEvent* event, bool first_move) start = pending_position; } break; - + case SelectionEndTrim: - - if (first_move) { - _editor->begin_reversible_command (_("trim selection end")); - } - + start = _editor->selection->time[_editor->clicked_selection].start; end = _editor->selection->time[_editor->clicked_selection].end; @@ -2972,28 +3319,24 @@ SelectionDrag::motion (GdkEvent* event, bool first_move) } else { end = pending_position; } - + break; - + case SelectionMove: - - if (first_move) { - _editor->begin_reversible_command (_("move selection")); - } - + start = _editor->selection->time[_editor->clicked_selection].start; end = _editor->selection->time[_editor->clicked_selection].end; - + length = end - start; - + start = pending_position; _editor->snap_to (start); - + end = start + length; - + break; } - + if (event->button.x >= _editor->horizontal_adjustment.get_value() + _editor->_canvas_width) { _editor->start_canvas_autoscroll (1, 0); } @@ -3002,40 +3345,57 @@ SelectionDrag::motion (GdkEvent* event, bool first_move) _editor->selection->replace (_editor->clicked_selection, start, end); } - _last_pointer_frame = pending_position; - if (_operation == SelectionMove) { - _editor->show_verbose_time_cursor(start, 10); + _editor->show_verbose_time_cursor(start, 10); } else { - _editor->show_verbose_time_cursor(pending_position, 10); + _editor->show_verbose_time_cursor(pending_position, 10); } } void SelectionDrag::finished (GdkEvent* event, bool movement_occurred) { + Session* s = _editor->session(); + if (movement_occurred) { motion (event, false); /* XXX this is not object-oriented programming at all. ick */ if (_editor->selection->time.consolidate()) { _editor->selection->TimeChanged (); } - _editor->commit_reversible_command (); + + /* XXX what if its a music time selection? */ + if (s && (s->config.get_auto_play() || (s->get_play_range() && s->transport_rolling()))) { + s->request_play_range (&_editor->selection->time, true); + } + + } else { /* just a click, no pointer movement.*/ if (Keyboard::no_modifier_keys_pressed (&event->button)) { - _editor->selection->clear_time(); + } + + if (!_editor->selection->selected (_editor->clicked_axisview)) { + _editor->selection->set (_editor->clicked_axisview); + } + + if (s && s->get_play_range () && s->transport_rolling()) { + s->request_stop (false, false); + } - } } - /* XXX what happens if its a music selection? */ - _editor->session->set_audio_range (_editor->selection->time); _editor->stop_canvas_autoscroll (); } +void +SelectionDrag::aborted () +{ + /* XXX: TODO */ +} + RangeMarkerBarDrag::RangeMarkerBarDrag (Editor* e, ArdourCanvas::Item* i, Operation o) : Drag (e, i), _operation (o), @@ -3051,7 +3411,7 @@ RangeMarkerBarDrag::RangeMarkerBarDrag (Editor* e, ArdourCanvas::Item* i, Operat void RangeMarkerBarDrag::start_grab (GdkEvent* event, Gdk::Cursor *) { - if (_editor->session == 0) { + if (_editor->session() == 0) { return; } @@ -3060,12 +3420,12 @@ RangeMarkerBarDrag::start_grab (GdkEvent* event, Gdk::Cursor *) if (!_editor->temp_location) { _editor->temp_location = new Location; } - + switch (_operation) { case CreateRangeMarker: case CreateTransportMarker: case CreateCDMarker: - + if (Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) { _copy = true; } else { @@ -3077,7 +3437,7 @@ RangeMarkerBarDrag::start_grab (GdkEvent* event, Gdk::Cursor *) Drag::start_grab (event, cursor); - _editor->show_verbose_time_cursor (_current_pointer_frame, 10); + _editor->show_verbose_time_cursor (adjusted_current_frame (event), 10); } void @@ -3102,57 +3462,42 @@ RangeMarkerBarDrag::motion (GdkEvent* event, bool first_move) return; break; } - - if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) { - _editor->snap_to (_current_pointer_frame); - } - /* only alter selection if the current frame is - different from the last frame position. - */ - - if (_current_pointer_frame == _last_pointer_frame) { - return; - } - - switch (_operation) { - case CreateRangeMarker: - case CreateTransportMarker: - case CreateCDMarker: - if (first_move) { - _editor->snap_to (_grab_frame); - } + nframes64_t const pf = adjusted_current_frame (event); + + if (_operation == CreateRangeMarker || _operation == CreateTransportMarker || _operation == CreateCDMarker) { + nframes64_t grab = grab_frame (); + _editor->snap_to (grab); - if (_current_pointer_frame < _grab_frame) { - start = _current_pointer_frame; - end = _grab_frame; + if (pf < grab_frame()) { + start = pf; + end = grab; } else { - end = _current_pointer_frame; - start = _grab_frame; + end = pf; + start = grab; } - + /* first drag: Either add to the selection or create a new selection. */ - + if (first_move) { - + _editor->temp_location->set (start, end); - + crect->show (); update_item (_editor->temp_location); _drag_rect->show(); //_drag_rect->raise_to_top(); - - } - break; + + } } - + if (event->button.x >= _editor->horizontal_adjustment.get_value() + _editor->_canvas_width) { _editor->start_canvas_autoscroll (1, 0); } - + if (start != end) { _editor->temp_location->set (start, end); @@ -3164,10 +3509,8 @@ RangeMarkerBarDrag::motion (GdkEvent* event, bool first_move) update_item (_editor->temp_location); } - _last_pointer_frame = _current_pointer_frame; + _editor->show_verbose_time_cursor (pf, 10); - _editor->show_verbose_time_cursor (_current_pointer_frame, 10); - } void @@ -3176,17 +3519,18 @@ RangeMarkerBarDrag::finished (GdkEvent* event, bool movement_occurred) Location * newloc = 0; string rangename; int flags; - + if (movement_occurred) { motion (event, false); + _drag_rect->hide(); switch (_operation) { case CreateRangeMarker: case CreateCDMarker: { _editor->begin_reversible_command (_("new range marker")); - XMLNode &before = _editor->session->locations()->get_state(); - _editor->session->locations()->next_available_name(rangename,"unnamed"); + XMLNode &before = _editor->session()->locations()->get_state(); + _editor->session()->locations()->next_available_name(rangename,"unnamed"); if (_operation == CreateCDMarker) { flags = Location::IsRangeMarker | Location::IsCDMarker; _editor->cd_marker_bar_drag_rect->hide(); @@ -3196,19 +3540,16 @@ RangeMarkerBarDrag::finished (GdkEvent* event, bool movement_occurred) _editor->range_bar_drag_rect->hide(); } newloc = new Location(_editor->temp_location->start(), _editor->temp_location->end(), rangename, (Location::Flags) flags); - _editor->session->locations()->add (newloc, true); - XMLNode &after = _editor->session->locations()->get_state(); - _editor->session->add_command(new MementoCommand(*(_editor->session->locations()), &before, &after)); + _editor->session()->locations()->add (newloc, true); + XMLNode &after = _editor->session()->locations()->get_state(); + _editor->session()->add_command(new MementoCommand(*(_editor->session()->locations()), &before, &after)); _editor->commit_reversible_command (); - - _drag_rect->hide(); break; } case CreateTransportMarker: // popup menu to pick loop or punch _editor->new_transport_marker_context_menu (&event->button, _item); - break; } } else { @@ -3219,15 +3560,14 @@ RangeMarkerBarDrag::finished (GdkEvent* event, bool movement_occurred) nframes64_t start; nframes64_t end; - start = _editor->session->locations()->first_mark_before (_grab_frame); - end = _editor->session->locations()->first_mark_after (_grab_frame); - + _editor->session()->locations()->marks_either_side (grab_frame(), start, end); + if (end == max_frames) { - end = _editor->session->current_end_frame (); + end = _editor->session()->current_end_frame (); } - if (start == 0) { - start = _editor->session->current_start_frame (); + if (start == max_frames) { + start = _editor->session()->current_start_frame (); } switch (_editor->mouse_mode) { @@ -3238,19 +3578,23 @@ RangeMarkerBarDrag::finished (GdkEvent* event, bool movement_occurred) case MouseRange: /* find the two markers on either side of the click and make the range out of it */ - _editor->selection->set (0, start, end); + _editor->selection->set (start, end); break; default: break; } - } + } } _editor->stop_canvas_autoscroll (); } - +void +RangeMarkerBarDrag::aborted () +{ + /* XXX: TODO */ +} void RangeMarkerBarDrag::update_item (Location* location) @@ -3266,7 +3610,7 @@ void MouseZoomDrag::start_grab (GdkEvent* event, Gdk::Cursor *) { Drag::start_grab (event, _editor->zoom_cursor); - _editor->show_verbose_time_cursor (_current_pointer_frame, 10); + _editor->show_verbose_time_cursor (adjusted_current_frame (event), 10); } void @@ -3275,27 +3619,20 @@ MouseZoomDrag::motion (GdkEvent* event, bool first_move) nframes64_t start; nframes64_t end; - if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) { - _editor->snap_to (_current_pointer_frame); - - if (first_move) { - _editor->snap_to (_grab_frame); - } - } - - if (_current_pointer_frame == _last_pointer_frame) { - return; - } + nframes64_t const pf = adjusted_current_frame (event); + + nframes64_t grab = grab_frame (); + _editor->snap_to_with_modifier (grab, event); /* base start and end on initial click position */ - if (_current_pointer_frame < _grab_frame) { - start = _current_pointer_frame; - end = _grab_frame; + if (pf < grab) { + start = pf; + end = grab; } else { - end = _current_pointer_frame; - start = _grab_frame; + end = pf; + start = grab; } - + if (start != end) { if (first_move) { @@ -3305,9 +3642,7 @@ MouseZoomDrag::motion (GdkEvent* event, bool first_move) _editor->reposition_zoom_rect(start, end); - _last_pointer_frame = _current_pointer_frame; - - _editor->show_verbose_time_cursor (_current_pointer_frame, 10); + _editor->show_verbose_time_cursor (pf, 10); } } @@ -3316,19 +3651,275 @@ MouseZoomDrag::finished (GdkEvent* event, bool movement_occurred) { if (movement_occurred) { motion (event, false); - - if (_grab_frame < _last_pointer_frame) { - _editor->temporal_zoom_by_frame (_grab_frame, _last_pointer_frame, "mouse zoom"); + + if (grab_frame() < last_pointer_frame()) { + _editor->temporal_zoom_by_frame (grab_frame(), last_pointer_frame(), "mouse zoom"); } else { - _editor->temporal_zoom_by_frame (_last_pointer_frame, _grab_frame, "mouse zoom"); - } + _editor->temporal_zoom_by_frame (last_pointer_frame(), grab_frame(), "mouse zoom"); + } } else { - _editor->temporal_zoom_to_frame (false, _grab_frame); + _editor->temporal_zoom_to_frame (false, grab_frame()); /* temporal_zoom_step (false); - center_screen (_grab_frame); + center_screen (grab_frame()); */ } _editor->zoom_rect->hide(); } + +void +MouseZoomDrag::aborted () +{ + _editor->zoom_rect->hide (); +} + +NoteDrag::NoteDrag (Editor* e, ArdourCanvas::Item* i) + : Drag (e, i) +{ + CanvasNoteEvent* cnote = dynamic_cast(_item); + region = &cnote->region_view(); +} + +void +NoteDrag::start_grab (GdkEvent* event, Gdk::Cursor *) +{ + Drag::start_grab (event); + + drag_delta_x = 0; + drag_delta_note = 0; + + double event_x; + double event_y; + + event_x = _drags->current_pointer_x(); + event_y = _drags->current_pointer_y(); + + _item->property_parent().get_value()->w2i(event_x, event_y); + + last_x = region->snap_to_pixel(event_x); + last_y = event_y; + + CanvasNoteEvent* cnote = dynamic_cast(_item); + + if (!(was_selected = cnote->selected())) { + + /* tertiary-click means extend selection - we'll do that on button release, + so don't add it here, because otherwise we make it hard to figure + out the "extend-to" range. + */ + + bool extend = Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier); + + if (!extend) { + bool add = Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier); + + if (add) { + region->note_selected (cnote, true); + } else { + region->unique_select (cnote); + } + } + } +} + +void +NoteDrag::motion (GdkEvent*, bool) +{ + MidiStreamView* streamview = region->midi_stream_view(); + double event_x; + double event_y; + + event_x = _drags->current_pointer_x(); + event_y = _drags->current_pointer_y(); + + _item->property_parent().get_value()->w2i(event_x, event_y); + + event_x = region->snap_to_pixel(event_x); + + double dx = event_x - last_x; + double dy = event_y - last_y; + last_x = event_x; + + drag_delta_x += dx; + + // Snap to note rows + + if (abs (dy) < streamview->note_height()) { + dy = 0.0; + } else { + int8_t this_delta_note; + if (dy > 0) { + this_delta_note = (int8_t)ceil(dy / streamview->note_height() / 2.0); + } else { + this_delta_note = (int8_t)floor(dy / streamview->note_height() / 2.0); + } + drag_delta_note -= this_delta_note; + dy = streamview->note_height() * this_delta_note; + last_y = last_y + dy; + } + + if (dx || dy) { + region->move_selection (dx, dy); + + CanvasNoteEvent* cnote = dynamic_cast(_item); + char buf[4]; + snprintf (buf, sizeof (buf), "%g", (int) cnote->note()->note() + drag_delta_note); + //editor.show_verbose_canvas_cursor_with (Evoral::midi_note_name (ev->note()->note())); + _editor->show_verbose_canvas_cursor_with (buf); + } +} + +void +NoteDrag::finished (GdkEvent* ev, bool moved) +{ + ArdourCanvas::CanvasNote* cnote = dynamic_cast(_item); + + if (!moved) { + if (_editor->current_mouse_mode() == Editing::MouseObject) { + + if (was_selected) { + bool add = Keyboard::modifier_state_equals (ev->button.state, Keyboard::PrimaryModifier); + if (add) { + region->note_deselected (cnote); + } + } else { + bool extend = Keyboard::modifier_state_equals (ev->button.state, Keyboard::TertiaryModifier); + bool add = Keyboard::modifier_state_equals (ev->button.state, Keyboard::PrimaryModifier); + + if (!extend && !add && region->selection_size() > 1) { + region->unique_select(cnote); + } else if (extend) { + region->note_selected (cnote, true, true); + } else { + /* it was added during button press */ + } + } + } + } else { + region->note_dropped (cnote, drag_delta_x, drag_delta_note); + } +} + +void +NoteDrag::aborted () +{ + /* XXX: TODO */ +} + +AutomationRangeDrag::AutomationRangeDrag (Editor* e, ArdourCanvas::Item* i, list const & r) + : Drag (e, i) + , _ranges (r) + , _nothing_to_drag (false) +{ + _atav = reinterpret_cast (_item->get_data ("trackview")); + assert (_atav); + + _line = _atav->line (); +} + +void +AutomationRangeDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor) +{ + Drag::start_grab (event, cursor); + + list points; + + XMLNode* state = &_line->get_state (); + + if (_ranges.empty()) { + + uint32_t const N = _line->npoints (); + for (uint32_t i = 0; i < N; ++i) { + points.push_back (_line->nth (i)); + } + + } else { + + boost::shared_ptr the_list = _line->the_list (); + for (list::const_iterator j = _ranges.begin(); j != _ranges.end(); ++j) { + + /* fade into and out of the region that we're dragging; + 64 samples length plucked out of thin air. + */ + nframes64_t const h = (j->start + j->end) / 2; + nframes64_t a = j->start + 64; + if (a > h) { + a = h; + } + nframes64_t b = j->end - 64; + if (b < h) { + b = h; + } + + the_list->add (j->start, the_list->eval (j->start)); + _line->add_always_in_view (j->start); + the_list->add (a, the_list->eval (a)); + _line->add_always_in_view (a); + the_list->add (b, the_list->eval (b)); + _line->add_always_in_view (b); + the_list->add (j->end, the_list->eval (j->end)); + _line->add_always_in_view (j->end); + } + + uint32_t const N = _line->npoints (); + for (uint32_t i = 0; i < N; ++i) { + + ControlPoint* p = _line->nth (i); + + list::const_iterator j = _ranges.begin (); + while (j != _ranges.end() && (j->start >= (*p->model())->when || j->end <= (*p->model())->when)) { + ++j; + } + + if (j != _ranges.end()) { + points.push_back (p); + } + } + } + + if (points.empty()) { + _nothing_to_drag = true; + return; + } + + _line->start_drag_multiple (points, 1 - (_drags->current_pointer_y() / _line->height ()), state); +} + +void +AutomationRangeDrag::motion (GdkEvent* event, bool first_move) +{ + if (_nothing_to_drag) { + return; + } + + float const f = 1 - (_drags->current_pointer_y() / _line->height()); + + /* we are ignoring x position for this drag, so we can just pass in anything */ + _line->drag_motion (0, f, true, false); +} + +void +AutomationRangeDrag::finished (GdkEvent* event, bool) +{ + if (_nothing_to_drag) { + return; + } + + motion (event, false); + _line->end_drag (); + _line->clear_always_in_view (); +} + +void +AutomationRangeDrag::aborted () +{ + _line->clear_always_in_view (); + _line->reset (); +} + +DraggingView::DraggingView (RegionView* v) + : view (v) +{ + initial_y = v->get_canvas_group()->property_y (); +}