*/
-#define __STDC_LIMIT_MACROS 1
+#ifdef WAF_BUILD
+#include "gtk2ardour-config.h"
+#endif
+
#include <stdint.h>
+
#include "pbd/memento_command.h"
#include "pbd/basename.h"
#include "pbd/stateful_diff_command.h"
+
+#include "gtkmm2ext/utils.h"
+
#include "ardour/session.h"
#include "ardour/dB.h"
#include "ardour/region_factory.h"
+#include "ardour/operations.h"
+
#include "editor.h"
#include "i18n.h"
#include "keyboard.h"
#include "selection.h"
#include "midi_selection.h"
#include "automation_time_axis.h"
+#include "debug.h"
+#include "editor_cursors.h"
+#include "mouse_cursors.h"
using namespace std;
using namespace ARDOUR;
using namespace PBD;
using namespace Gtk;
+using namespace Gtkmm2ext;
using namespace Editing;
using namespace ArdourCanvas;
_drags.clear ();
+ _editor->set_follow_playhead (_old_follow_playhead, false);
+
_ending = false;
}
void
DragManager::set (Drag* d, GdkEvent* e, Gdk::Cursor* c)
{
- assert (_drags.empty ());
d->set_manager (this);
_drags.push_back (d);
- start_grab (e);
+ start_grab (e, c);
}
void
-DragManager::start_grab (GdkEvent* e)
+DragManager::start_grab (GdkEvent* e, Gdk::Cursor* c)
{
+ /* Prevent follow playhead during the drag to be nice to the user */
+ _old_follow_playhead = _editor->follow_playhead ();
+ _editor->set_follow_playhead (false);
+
_current_pointer_frame = _editor->event_frame (e, &_current_pointer_x, &_current_pointer_y);
for (list<Drag*>::const_iterator i = _drags.begin(); i != _drags.end(); ++i) {
- (*i)->start_grab (e);
+ (*i)->start_grab (e, c);
}
}
_drags.clear ();
_ending = false;
+
+ _editor->set_follow_playhead (_old_follow_playhead, false);
return r;
}
, _item (i)
, _pointer_frame_offset (0)
, _move_threshold_passed (false)
+ , _raw_grab_frame (0)
, _grab_frame (0)
, _last_pointer_frame (0)
{
_y_constrained = false;
}
- _grab_frame = _editor->event_frame (event, &_grab_x, &_grab_y);
- _grab_frame = adjusted_frame (_grab_frame, event);
+ _raw_grab_frame = _editor->event_frame (event, &_grab_x, &_grab_y);
+ setup_pointer_frame_offset ();
+ _grab_frame = adjusted_frame (_raw_grab_frame, event);
_last_pointer_frame = _grab_frame;
_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);
+ *cursor,
+ event->button.time);
if (_editor->session() && _editor->session()->transport_rolling()) {
_was_rolling = true;
return _move_threshold_passed;
}
-nframes64_t
-Drag::adjusted_frame (nframes64_t f, GdkEvent const * event, bool snap) const
+framepos_t
+Drag::adjusted_frame (framepos_t f, GdkEvent const * event, bool snap) const
{
- nframes64_t pos = 0;
+ framepos_t pos = 0;
if (f > _pointer_frame_offset) {
pos = f - _pointer_frame_offset;
return pos;
}
-nframes64_t
+framepos_t
Drag::adjusted_current_frame (GdkEvent const * event, bool snap) const
{
return adjusted_frame (_drags->current_pointer_frame (), event, snap);
Drag::motion_handler (GdkEvent* event, bool from_autoscroll)
{
/* 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 ()) ) {
+ if (_move_threshold_passed &&
+ (!x_movement_matters() || _last_pointer_frame == adjusted_current_frame (event)) &&
+ (!y_movement_matters() || _last_pointer_y == _drags->current_pointer_y ()) ) {
return false;
}
- pair<nframes64_t, int> const threshold = move_threshold ();
+ pair<framecnt_t, int> const threshold = move_threshold ();
bool const old_move_threshold_passed = _move_threshold_passed;
if (!from_autoscroll && !_move_threshold_passed) {
- bool const xp = (::llabs (adjusted_current_frame (event) - _grab_frame) >= threshold.first);
+ bool const xp = (::llabs (_drags->current_pointer_frame () - _grab_frame) >= threshold.first);
bool const yp = (::fabs ((_drags->current_pointer_y () - _grab_y)) >= threshold.second);
_move_threshold_passed = ((xp && x_movement_matters()) || (yp && y_movement_matters()));
_item->ungrab (0);
}
- aborted ();
+ aborted (_move_threshold_passed);
_editor->stop_canvas_autoscroll ();
_editor->hide_verbose_canvas_cursor ();
}
+struct EditorOrderTimeAxisViewSorter {
+ bool operator() (TimeAxisView* a, TimeAxisView* b) {
+ RouteTimeAxisView* ra = dynamic_cast<RouteTimeAxisView*> (a);
+ RouteTimeAxisView* rb = dynamic_cast<RouteTimeAxisView*> (b);
+ assert (ra && rb);
+ return ra->route()->order_key (N_ ("editor")) < rb->route()->order_key (N_ ("editor"));
+ }
+};
+
RegionDrag::RegionDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v)
: Drag (e, i),
_primary (p)
{
+ _editor->visible_order_range (&_visible_y_low, &_visible_y_high);
+
+ /* Make a list of non-hidden tracks to refer to during the drag */
+
+ TrackViewList track_views = _editor->track_views;
+ track_views.sort (EditorOrderTimeAxisViewSorter ());
+
+ for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
+ if (!(*i)->hidden()) {
+
+ _time_axis_views.push_back (*i);
+
+ TimeAxisView::Children children_list = (*i)->get_child_list ();
+ for (TimeAxisView::Children::iterator j = children_list.begin(); j != children_list.end(); ++j) {
+ _time_axis_views.push_back (j->get());
+ }
+ }
+ }
+
+ /* the list of views can be empty at this point if this is a region list-insert drag
+ */
+
for (list<RegionView*>::const_iterator i = v.begin(); i != v.end(); ++i) {
- _views.push_back (DraggingView (*i));
+ _views.push_back (DraggingView (*i, this));
}
RegionView::RegionViewGoingAway.connect (death_connection, invalidator (*this), ui_bind (&RegionDrag::region_going_away, this, _1), gui_context());
}
}
+/** Given a non-hidden TimeAxisView, return the index of it into the _time_axis_views vector */
+int
+RegionDrag::find_time_axis_view (TimeAxisView* t) const
+{
+ int i = 0;
+ int const N = _time_axis_views.size ();
+ while (i < N && _time_axis_views[i] != t) {
+ ++i;
+ }
+
+ if (i == N) {
+ return -1;
+ }
+
+ return i;
+}
+
RegionMotionDrag::RegionMotionDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v, bool b)
: RegionDrag (e, i, p, v),
- _dest_trackview (0),
- _dest_layer (0),
_brushing (b),
_total_x_delta (0)
{
void
-RegionMotionDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
+RegionMotionDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
{
- Drag::start_grab (event);
+ Drag::start_grab (event, cursor);
_editor->show_verbose_time_cursor (_last_frame_position, 10);
-}
-RegionMotionDrag::TimeAxisViewSummary
-RegionMotionDrag::get_time_axis_view_summary ()
-{
- int32_t children = 0;
- TimeAxisViewSummary sum;
-
- _editor->visible_order_range (&sum.visible_y_low, &sum.visible_y_high);
-
- /* get a bitmask representing the visible tracks */
-
- for (TrackViewList::iterator i = _editor->track_views.begin(); i != _editor->track_views.end(); ++i) {
- RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*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) {
- sum.tracks = sum.tracks |= (0x01 << (rtv->order() + children));
- sum.height_list[rtv->order() + children] = (*j)->current_height();
- children++;
- }
- }
- }
- }
-
- return sum;
+ pair<TimeAxisView*, int> const tv = _editor->trackview_by_y_position (_drags->current_pointer_y ());
+ _last_pointer_time_axis_view = find_time_axis_view (tv.first);
+ _last_pointer_layer = tv.first->layer_display() == Overlaid ? 0 : tv.second;
}
-bool
-RegionMotionDrag::compute_y_delta (
- TimeAxisView const * last_pointer_view, TimeAxisView* current_pointer_view,
- int32_t last_pointer_layer, int32_t current_pointer_layer,
- TimeAxisViewSummary const & tavs,
- int32_t* pointer_order_span, int32_t* pointer_layer_span,
- int32_t* canvas_pointer_order_span
- )
-{
- if (_brushing) {
- *pointer_order_span = 0;
- *pointer_layer_span = 0;
- return true;
- }
-
- 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;
- only meaningful if pointer_order_span == 0 (ie we've not moved tracks) */
- *pointer_layer_span = last_pointer_layer - current_pointer_layer;
-
- if (*pointer_order_span != 0) {
-
- /* find the actual pointer span, in terms of the number of visible tracks;
- to do this, we reduce |pointer_order_span| by the number of hidden tracks
- over the span */
-
- *canvas_pointer_order_span = *pointer_order_span;
- if (last_pointer_view->order() >= current_pointer_view->order()) {
- for (int32_t y = current_pointer_view->order(); y < last_pointer_view->order(); y++) {
- if (tavs.height_list[y] == 0) {
- *canvas_pointer_order_span--;
- }
- }
- } else {
- for (int32_t y = last_pointer_view->order(); y <= current_pointer_view->order(); y++) {
- if (tavs.height_list[y] == 0) {
- *canvas_pointer_order_span++;
- }
- }
- }
-
- for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
-
- RegionView* rv = i->view;
-
- if (rv->region()->locked()) {
- continue;
- }
-
- double ix1, ix2, iy1, iy2;
- 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;
-
- /* get the new trackview for this particular region */
- pair<TimeAxisView*, int> const tvp = _editor->trackview_by_y_position (iy1);
- assert (tvp.first);
- RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tvp.first);
-
- /* 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
- );
-
- if (clamp_y_axis) {
- break;
- }
- }
-
- } else if (_dest_trackview == current_pointer_view) {
-
- if (current_pointer_layer == last_pointer_layer) {
- /* No movement; clamp */
- clamp_y_axis = true;
- }
- }
-
- if (!clamp_y_axis) {
- _dest_trackview = current_pointer_view;
- _dest_layer = current_pointer_layer;
- }
-
- return clamp_y_axis;
-}
-
-
double
-RegionMotionDrag::compute_x_delta (GdkEvent const * event, nframes64_t* pending_region_position)
+RegionMotionDrag::compute_x_delta (GdkEvent const * event, framepos_t* pending_region_position)
{
/* compute the amount of pointer motion in frames, and where
the region would be if we moved it by that much.
*/
*pending_region_position = adjusted_current_frame (event);
-
- nframes64_t sync_frame;
- nframes64_t sync_offset;
+
+ framepos_t sync_frame;
+ framecnt_t sync_offset;
int32_t sync_dir;
sync_offset = _primary->region()->sync_offset (sync_dir);
*pending_region_position = _last_frame_position;
}
- if (*pending_region_position > max_frames - _primary->region()->length()) {
+ if (*pending_region_position > max_framepos - _primary->region()->length()) {
*pending_region_position = _last_frame_position;
}
- double x_delta = 0;
+ double dx = 0;
- if ((*pending_region_position != _last_frame_position) && x_move_allowed ()) {
+ /* in locked edit mode, reverse the usual meaning of _x_constrained */
+ bool const x_move_allowed = Config->get_edit_mode() == Lock ? _x_constrained : !_x_constrained;
- /* now compute the canvas unit distance we need to move the regionview
- to make it appear at the new location.
- */
-
- x_delta = (static_cast<double> (*pending_region_position) - _last_frame_position) / _editor->frames_per_unit;
+ if ((*pending_region_position != _last_frame_position) && x_move_allowed) {
- if (*pending_region_position <= _last_frame_position) {
+ /* x movement since last time */
+ dx = (static_cast<double> (*pending_region_position) - _last_frame_position) / _editor->frames_per_unit;
- for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
-
- RegionView* rv = i->view;
+ /* total x movement */
+ framecnt_t total_dx = *pending_region_position;
+ if (regions_came_from_canvas()) {
+ total_dx = total_dx - grab_frame () + _pointer_frame_offset;
+ }
- // If any regionview is at zero, we need to know so we can stop further leftward motion.
+ /* check that no regions have gone off the start of the session */
+ for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
+ if ((i->view->region()->position() + total_dx) < 0) {
+ dx = 0;
+ *pending_region_position = _last_frame_position;
+ break;
+ }
+ }
- double ix1, ix2, iy1, iy2;
- rv->get_canvas_frame()->get_bounds (ix1, iy1, ix2, iy2);
- rv->get_canvas_frame()->i2w (ix1, iy1);
+ _last_frame_position = *pending_region_position;
+ }
- if (-x_delta > ix1 + _editor->horizontal_position()) {
- x_delta = 0;
- *pending_region_position = _last_frame_position;
- break;
- }
- }
+ return dx;
+}
+bool
+RegionMotionDrag::y_movement_allowed (int delta_track, layer_t delta_layer) const
+{
+ for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
+ int const n = i->time_axis_view + delta_track;
+ if (n < 0 || n >= int (_time_axis_views.size())) {
+ /* off the top or bottom track */
+ return false;
}
- _last_frame_position = *pending_region_position;
+ RouteTimeAxisView const * to = dynamic_cast<RouteTimeAxisView const *> (_time_axis_views[n]);
+ if (to == 0 || !to->is_track() || to->track()->data_type() != i->view->region()->data_type()) {
+ /* not a track, or the wrong type */
+ return false;
+ }
+
+ int const l = i->layer + delta_layer;
+ if (delta_track == 0 && (l < 0 || l >= int (to->view()->layers()))) {
+ /* Off the top or bottom layer; note that we only refuse if the track hasn't changed.
+ If it has, the layers will be munged later anyway, so it's ok.
+ */
+ return false;
+ }
}
- return x_delta;
+ /* all regions being dragged are ok with this change */
+ return true;
}
void
RegionMotionDrag::motion (GdkEvent* event, bool first_move)
{
- double y_delta = 0;
-
- TimeAxisViewSummary tavs = get_time_axis_view_summary ();
+ assert (!_views.empty ());
- vector<int32_t>::iterator j;
+ /* Find the TimeAxisView that the pointer is now over */
+ pair<TimeAxisView*, int> const tv = _editor->trackview_by_y_position (_drags->current_pointer_y ());
- /* *pointer* variables reflect things about the pointer; as we may be moving
- multiple regions, much detail must be computed per-region */
-
- /* current_pointer_view will become the TimeAxisView that we're currently pointing at, and
- current_pointer_layer the current layer on that TimeAxisView; in this code layer numbers
- are with respect to how the view's layers are displayed; if we are in Overlaid mode, layer
- is always 0 regardless of what the region's "real" layer is */
- RouteTimeAxisView* current_pointer_view;
- layer_t current_pointer_layer;
- if (!check_possible (¤t_pointer_view, ¤t_pointer_layer)) {
+ /* Bail early if we're not over a track */
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tv.first);
+ if (!rtv || !rtv->is_track()) {
+ _editor->hide_verbose_canvas_cursor ();
return;
}
- /* TimeAxisView that we were pointing at last time we entered this method */
- TimeAxisView const * const last_pointer_view = _dest_trackview;
- /* the order of the track that we were pointing at last time we entered this method */
- int32_t const last_pointer_order = last_pointer_view->order ();
- /* the layer that we were pointing at last time we entered this method */
- layer_t const last_pointer_layer = _dest_layer;
+ /* Note: time axis views in this method are often expressed as an index into the _time_axis_views vector */
- int32_t pointer_order_span;
- int32_t pointer_layer_span;
- int32_t canvas_pointer_order_span;
+ /* Here's the current pointer position in terms of time axis view and layer */
+ int const current_pointer_time_axis_view = find_time_axis_view (tv.first);
+ layer_t const current_pointer_layer = tv.first->layer_display() == Overlaid ? 0 : tv.second;
- bool const clamp_y_axis = compute_y_delta (
- last_pointer_view, current_pointer_view,
- last_pointer_layer, current_pointer_layer, tavs,
- &pointer_order_span, &pointer_layer_span,
- &canvas_pointer_order_span
- );
-
- nframes64_t pending_region_position;
+ /* Work out the change in x */
+ framepos_t pending_region_position;
double const x_delta = compute_x_delta (event, &pending_region_position);
- /*************************************************************
- PREPARE TO MOVE
- ************************************************************/
+ /* Work out the change in y */
+ int delta_time_axis_view = current_pointer_time_axis_view - _last_pointer_time_axis_view;
+ int delta_layer = current_pointer_layer - _last_pointer_layer;
+
+ if (!y_movement_allowed (delta_time_axis_view, delta_layer)) {
+ /* this y movement is not allowed, so do no y movement this time */
+ delta_time_axis_view = 0;
+ delta_layer = 0;
+ }
- if (x_delta == 0 && pointer_order_span == 0 && pointer_layer_span == 0 && !first_move) {
+ if (x_delta == 0 && delta_time_axis_view == 0 && delta_layer == 0 && !first_move) {
/* haven't reached next snap point, and we're not switching
trackviews nor layers. nothing to do.
*/
return;
}
- /*************************************************************
- MOTION
- ************************************************************/
-
pair<set<boost::shared_ptr<Playlist> >::iterator,bool> insert_result;
- for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
+ for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
RegionView* rv = i->view;
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) {
+ /* 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 ();
+
// 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
- region selection above all time axis views.
- reparenting means we have to move the rv as the two
- parent groups have different coordinates.
+ 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
+ parent groups have different coordinates.
*/
-
+
rv->get_canvas_group()->property_y() = iy1 - 1;
- rv->get_canvas_group()->reparent(*(_editor->_region_motion_group));
-
+ rv->get_canvas_group()->reparent (*(_editor->_region_motion_group));
+
rv->fake_set_opaque (true);
}
- /* current view for this particular region */
- pair<TimeAxisView*, int> pos = _editor->trackview_by_y_position (iy1);
- RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (pos.first);
-
- if (pointer_order_span != 0 && !clamp_y_axis) {
+ /* Work out the change in y position of this region view */
- /* INTER-TRACK MOVEMENT */
+ double y_delta = 0;
- /* move through the height list to the track that the region is currently on */
- vector<int32_t>::iterator j = tavs.height_list.begin ();
- int32_t x = 0;
- while (j != tavs.height_list.end () && x != rtv->order ()) {
- ++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);
-
- /* move to the right layer on the current trackview */
- 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()) {
- 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()) {
- j++;
- }
-
- temp_pointer_order_span++;
- }
-
-
- /* find out where we'll be when we move and set height accordingly */
+ /* If we have moved tracks, we'll fudge the layer delta so that the
+ region gets moved back onto layer 0 on its new track; this avoids
+ confusion when dragging regions from non-zero layers onto different
+ tracks.
+ */
+ int this_delta_layer = delta_layer;
+ if (delta_time_axis_view != 0) {
+ this_delta_layer = - i->layer;
+ }
- pair<TimeAxisView*, int> const pos = _editor->trackview_by_y_position (iy1 + y_delta);
- RouteTimeAxisView const * temp_rtv = dynamic_cast<RouteTimeAxisView*> (pos.first);
- rv->set_height (temp_rtv->view()->child_height());
+ /* Move this region to layer 0 on its old track */
+ StreamView* lv = _time_axis_views[i->time_axis_view]->view ();
+ if (lv->layer_display() == Stacked) {
+ y_delta -= (lv->layers() - i->layer - 1) * lv->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.
- */
+ /* Now move it to its right layer on the current track */
+ StreamView* cv = _time_axis_views[i->time_axis_view + delta_time_axis_view]->view ();
+ if (cv->layer_display() == Stacked) {
+ y_delta += (cv->layers() - (i->layer + this_delta_layer) - 1) * cv->child_height ();
+ }
- //const GdkColor& col (temp_rtv->view->get_region_color());
- //rv->set_color (const_cast<GdkColor&>(col));
+ /* Move tracks */
+ if (delta_time_axis_view > 0) {
+ for (int j = 0; j < delta_time_axis_view; ++j) {
+ y_delta += _time_axis_views[i->time_axis_view + j]->current_height ();
+ }
+ } else {
+ /* start by subtracting the height of the track above where we are now */
+ for (int j = 1; j <= -delta_time_axis_view; ++j) {
+ y_delta -= _time_axis_views[i->time_axis_view - j]->current_height ();
}
}
- 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;
- }
+ /* Set height */
+ rv->set_height (_time_axis_views[i->time_axis_view + delta_time_axis_view]->view()->child_height ());
+ /* Update the DraggingView */
+ i->time_axis_view += delta_time_axis_view;
+ i->layer += this_delta_layer;
if (_brushing) {
_editor->mouse_brush_insert_region (rv, pending_region_position);
if (x_delta != 0 && !_brushing) {
_editor->show_verbose_time_cursor (_last_frame_position, 10);
}
+
+ _last_pointer_time_axis_view += delta_time_axis_view;
+ _last_pointer_layer += delta_layer;
}
void
RegionMoveDrag::motion (GdkEvent* event, bool first_move)
{
if (_copy && first_move) {
- copy_regions (event);
+
+ /* duplicate the regionview(s) and region(s) */
+
+ list<DraggingView> new_regionviews;
+
+ for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
+
+ RegionView* rv = i->view;
+ AudioRegionView* arv = dynamic_cast<AudioRegionView*>(rv);
+ MidiRegionView* mrv = dynamic_cast<MidiRegionView*>(rv);
+
+ const boost::shared_ptr<const Region> original = rv->region();
+ boost::shared_ptr<Region> region_copy = RegionFactory::create (original, true);
+ region_copy->set_position (original->position(), this);
+
+ RegionView* nrv;
+ if (arv) {
+ boost::shared_ptr<AudioRegion> audioregion_copy
+ = boost::dynamic_pointer_cast<AudioRegion>(region_copy);
+
+ nrv = new AudioRegionView (*arv, audioregion_copy);
+ } else if (mrv) {
+ boost::shared_ptr<MidiRegion> midiregion_copy
+ = boost::dynamic_pointer_cast<MidiRegion>(region_copy);
+ nrv = new MidiRegionView (*mrv, midiregion_copy);
+ } else {
+ continue;
+ }
+
+ nrv->get_canvas_group()->show ();
+ new_regionviews.push_back (DraggingView (nrv, this));
+
+ /* swap _primary to the copy */
+
+ if (rv == _primary) {
+ _primary = nrv;
+ }
+
+ /* ..and deselect the one we copied */
+
+ rv->set_selected (false);
+ }
+
+ if (!new_regionviews.empty()) {
+
+ /* reflect the fact that we are dragging the copies */
+
+ _views = new_regionviews;
+
+ 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();
+ }
}
RegionMotionDrag::motion (event, first_move);
}
void
-RegionMoveDrag::finished (GdkEvent* /*event*/, bool movement_occurred)
+RegionMoveDrag::finished (GdkEvent *, bool movement_occurred)
{
- vector<RegionView*> copies;
- boost::shared_ptr<Track> tr;
- boost::shared_ptr<Playlist> from_playlist;
- boost::shared_ptr<Playlist> to_playlist;
- RegionSelection new_views;
- typedef set<boost::shared_ptr<Playlist> > PlaylistSet;
- PlaylistSet modified_playlists;
- PlaylistSet frozen_playlists;
- list <sigc::connection> modified_playlist_connections;
- pair<PlaylistSet::iterator,bool> insert_result, frozen_insert_result;
- nframes64_t drag_delta;
- bool changed_tracks, changed_position;
- map<RegionView*, pair<RouteTimeAxisView*, int> > final;
- RouteTimeAxisView* source_tv;
- vector<StatefulDiffCommand*> sdc;
-
if (!movement_occurred) {
/* just a click */
return;
}
- if (_brushing) {
- /* all changes were made during motion event handlers */
-
- if (_copy) {
- for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
- copies.push_back (i->view);
- }
- }
-
- goto out;
- }
-
/* reverse this here so that we have the correct logic to finalize
the drag.
*/
_x_constrained = !_x_constrained;
}
+ assert (!_views.empty ());
+
+ bool const changed_position = (_last_frame_position != _primary->region()->position());
+ bool const changed_tracks = (_time_axis_views[_views.front().time_axis_view] != &_views.front().view->get_time_axis_view());
+ framecnt_t const drag_delta = _primary->region()->position() - _last_frame_position;
+
+ _editor->update_canvas_now ();
+
if (_copy) {
- if (_x_constrained) {
- _editor->begin_reversible_command (_("fixed time region copy"));
- } else {
- _editor->begin_reversible_command (_("region copy"));
+
+ finished_copy (
+ changed_position,
+ changed_tracks,
+ drag_delta
+ );
+
+ } else {
+
+ finished_no_copy (
+ changed_position,
+ changed_tracks,
+ drag_delta
+ );
+
+ }
+}
+
+void
+RegionMoveDrag::finished_copy (bool const changed_position, bool const /*changed_tracks*/, framecnt_t const drag_delta)
+{
+ RegionSelection new_views;
+ PlaylistSet modified_playlists;
+ list<RegionView*> views_to_delete;
+
+ if (_brushing) {
+ /* all changes were made during motion event handlers */
+
+ for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
+ delete i->view;
}
+
+ _editor->commit_reversible_command ();
+ return;
+ }
+
+ if (_x_constrained) {
+ _editor->begin_reversible_command (_("fixed time region copy"));
} else {
- if (_x_constrained) {
- _editor->begin_reversible_command (_("fixed time region drag"));
+ _editor->begin_reversible_command (_("region copy"));
+ }
+
+ /* insert the regions into their new playlists */
+ for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
+
+ if (i->view->region()->locked()) {
+ continue;
+ }
+
+ framepos_t where;
+
+ if (changed_position && !_x_constrained) {
+ where = i->view->region()->position() - drag_delta;
} else {
- _editor->begin_reversible_command (_("region drag"));
+ where = i->view->region()->position();
+ }
+
+ RegionView* new_view = insert_region_into_playlist (
+ i->view->region(), dynamic_cast<RouteTimeAxisView*> (_time_axis_views[i->time_axis_view]), i->layer, where, modified_playlists
+ );
+
+ if (new_view == 0) {
+ continue;
}
+
+ new_views.push_back (new_view);
+
+ /* we don't need the copied RegionView any more */
+ views_to_delete.push_back (i->view);
}
- changed_position = (_last_frame_position != (nframes64_t) (_primary->region()->position()));
- changed_tracks = (_dest_trackview != &_primary->get_time_axis_view());
+ /* Delete views that are no longer needed; we can't do this directly in the iteration over _views
+ because when views are deleted they are automagically removed from _views, which messes
+ up the iteration.
+ */
+ for (list<RegionView*>::iterator i = views_to_delete.begin(); i != views_to_delete.end(); ++i) {
+ delete *i;
+ }
- drag_delta = _primary->region()->position() - _last_frame_position;
+ /* 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
+ */
- _editor->update_canvas_now ();
+ if (new_views.size() > 0) {
+ _editor->selection->set (new_views);
+ }
+
+ /* write commands for the accumulated diffs for all our modified playlists */
+ add_stateful_diff_commands_for_playlists (modified_playlists);
+
+ _editor->commit_reversible_command ();
+}
+
+void
+RegionMoveDrag::finished_no_copy (
+ bool const changed_position,
+ bool const changed_tracks,
+ framecnt_t const drag_delta
+ )
+{
+ RegionSelection new_views;
+ PlaylistSet modified_playlists;
+ PlaylistSet frozen_playlists;
- /* make a list of where each region ended up */
- final = find_time_axis_views_and_layers ();
+ if (_brushing) {
+ /* all changes were made during motion event handlers */
+ _editor->commit_reversible_command ();
+ return;
+ }
- cerr << "Iterate over " << _views.size() << " views\n";
+ if (_x_constrained) {
+ _editor->begin_reversible_command (_("fixed time region drag"));
+ } else {
+ _editor->begin_reversible_command (Operations::region_drag);
+ }
for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ) {
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 ();
+ RouteTimeAxisView* const dest_rtv = dynamic_cast<RouteTimeAxisView*> (_time_axis_views[i->time_axis_view]);
+ layer_t const dest_layer = i->layer;
if (rv->region()->locked()) {
++i;
continue;
}
+ framepos_t where;
+
if (changed_position && !_x_constrained) {
where = rv->region()->position() - drag_delta;
} else {
where = rv->region()->position();
}
- boost::shared_ptr<Region> new_region;
-
- if (_copy) {
- /* we already made a copy */
- new_region = rv->region();
-
- /* undo the previous hide_dependent_views so that xfades don't
- disappear on copying regions
- */
-
- //rv->get_time_axis_view().reveal_dependent_views (*rv);
+ if (changed_tracks) {
- } else if (changed_tracks && dest_rtv->playlist()) {
- new_region = RegionFactory::create (rv->region());
- }
+ /* insert into new playlist */
- if (changed_tracks || _copy) {
-
- to_playlist = dest_rtv->playlist();
+ RegionView* new_view = insert_region_into_playlist (
+ RegionFactory::create (rv->region (), true), dest_rtv, dest_layer, where, modified_playlists
+ );
- if (!to_playlist) {
+ if (new_view == 0) {
++i;
continue;
}
- _editor->latest_regionviews.clear ();
-
- 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) {
- 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";
+ new_views.push_back (new_view);
- cerr << "Adding new region " << new_region->id() << " based on "
- << rv->region()->id() << endl;
-
- to_playlist->add_region (new_region, where);
+ /* remove from old playlist */
- if (dest_rtv->view()->layer_display() == Stacked) {
- new_region->set_layer (dest_layer);
- new_region->set_pending_explicit_relayer (true);
- }
-
- c.disconnect ();
+ /* the region that used to be in the old playlist is not
+ 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);
- 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?
- //dest_atv->reveal_dependent_views (*latest_regionviews.front());
- new_views.push_back (_editor->latest_regionviews.front());
- }
+ remove_region_from_playlist (rv->region(), i->initial_playlist, modified_playlists);
} else {
- rv->region()->clear_history ();
+
+ rv->region()->clear_changes ();
/*
motion on the same track. plonk the previously reparented region
/* freeze playlist to avoid lots of relayering in the case of a multi-region drag */
- frozen_insert_result = frozen_playlists.insert(playlist);
+ pair<PlaylistSet::iterator, bool> r = frozen_playlists.insert (playlist);
- if (frozen_insert_result.second) {
- playlist->freeze();
+ if (r.second) {
+ playlist->freeze ();
}
- cerr << "Moving region " << rv->region()->id() << endl;
+ /* this movement may result in a crossfade being modified, so we need to get undo
+ data from the playlist as well as the region.
+ */
+
+ r = modified_playlists.insert (playlist);
+ if (r.second) {
+ playlist->clear_changes ();
+ }
rv->region()->set_position (where, (void*) this);
- sdc.push_back (new StatefulDiffCommand (rv->region()));
+ _editor->session()->add_command (new StatefulDiffCommand (rv->region()));
}
- if (changed_tracks && !_copy) {
-
- /* get the playlist where this drag started. we can't use rv->region()->playlist()
- because we may have copied the region and it has not been attached to a playlist.
- */
-
- source_tv = dynamic_cast<RouteTimeAxisView*> (&rv->get_time_axis_view());
- tr = source_tv->track();
- from_playlist = tr->playlist();
-
- assert (source_tv);
- assert (tr);
- assert (from_playlist);
-
- /* moved to a different audio track, without copying */
-
- /* the region that used to be in the old playlist is not
- 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) {
- 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());
-
+ if (changed_tracks) {
+
/* 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,
+ trace of it from _views (i.e. there were N regions selected, we removed 1,
but since its the same playlist for N tracks, all N tracks updated themselves, removed the
- corresponding regionview, and the selection is now empty).
+ corresponding regionview, and _views is now empty).
- this could have invalidated any and all iterators into the region selection.
+ This could have invalidated any and all iterators into _views.
- the heuristic we use here is: if the region selection is empty, break out of the loop
+ The heuristic we use here is: if the region selection is empty, break out of the loop
here. if the region selection is not empty, then restart the loop because we know that
we must have removed at least the region(view) we've just been working on as well as any
that we processed on previous iterations.
- EXCEPT .... if we are doing a copy drag, then the selection hasn't been modified and
+ EXCEPT .... if we are doing a copy drag, then _views hasn't been modified and
we can just iterate.
*/
+
if (_views.empty()) {
- 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;
+ 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 we've created new regions either by copying or moving
+ /* 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
*/
(*p)->thaw();
}
- out:
- for (vector<StatefulDiffCommand*>::iterator i = sdc.begin(); i != sdc.end(); ++i) {
- _editor->session()->add_command (*i);
- }
+ /* write commands for the accumulated diffs for all our modified playlists */
+ add_stateful_diff_commands_for_playlists (modified_playlists);
_editor->commit_reversible_command ();
-
- for (vector<RegionView*>::iterator x = copies.begin(); x != copies.end(); ++x) {
- delete *x;
- }
}
+/** Remove a region from a playlist, clearing the diff history of the playlist first if necessary.
+ * @param region Region to remove.
+ * @param playlist playlist To remove from.
+ * @param modified_playlists The playlist will be added to this if it is not there already; used to ensure
+ * that clear_changes () is only called once per playlist.
+ */
void
-RegionMoveDrag::aborted ()
+RegionMoveDrag::remove_region_from_playlist (
+ boost::shared_ptr<Region> region,
+ boost::shared_ptr<Playlist> playlist,
+ PlaylistSet& modified_playlists
+ )
{
- if (_copy) {
-
- for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
- delete i->view;
- }
-
- _views.clear ();
+ pair<set<boost::shared_ptr<Playlist> >::iterator, bool> r = modified_playlists.insert (playlist);
- } else {
- RegionMotionDrag::aborted ();
+ if (r.second) {
+ playlist->clear_changes ();
}
+
+ playlist->remove_region (region);
}
+
-void
-RegionMotionDrag::aborted ()
+/** Insert a region into a playlist, handling the recovery of the resulting new RegionView, and
+ * clearing the playlist's diff history first if necessary.
+ * @param region Region to insert.
+ * @param dest_rtv Destination RouteTimeAxisView.
+ * @param dest_layer Destination layer.
+ * @param where Destination position.
+ * @param modified_playlists The playlist will be added to this if it is not there already; used to ensure
+ * that clear_changes () is only called once per playlist.
+ * @return New RegionView, or 0 if no insert was performed.
+ */
+RegionView *
+RegionMoveDrag::insert_region_into_playlist (
+ boost::shared_ptr<Region> region,
+ RouteTimeAxisView* dest_rtv,
+ layer_t dest_layer,
+ framecnt_t where,
+ PlaylistSet& modified_playlists
+ )
{
- for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
- RegionView* rv = i->view;
- TimeAxisView* tv = &(rv->get_time_axis_view ());
- RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (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 ());
+ boost::shared_ptr<Playlist> dest_playlist = dest_rtv->playlist ();
+ if (!dest_playlist) {
+ return 0;
}
- _editor->update_canvas_now ();
-}
-
+ /* arrange to collect the new region view that will be created as a result of our playlist insertion */
+ _new_region_view = 0;
+ sigc::connection c = dest_rtv->view()->RegionViewAdded.connect (sigc::mem_fun (*this, &RegionMoveDrag::collect_new_region_view));
-bool
-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;
+ /* clear history for the playlist we are about to insert to, provided we haven't already done so */
+ pair<PlaylistSet::iterator, bool> r = modified_playlists.insert (dest_playlist);
+ if (r.second) {
+ dest_playlist->clear_changes ();
}
- return !_x_constrained;
-}
-
-void
-RegionMotionDrag::copy_regions (GdkEvent* event)
-{
- /* duplicate the regionview(s) and region(s) */
+ dest_playlist->add_region (region, where);
- list<DraggingView> new_regionviews;
+ if (dest_rtv->view()->layer_display() == Stacked) {
+ region->set_layer (dest_layer);
+ region->set_pending_explicit_relayer (true);
+ }
- for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
+ c.disconnect ();
- RegionView* rv = i->view;
- AudioRegionView* arv = dynamic_cast<AudioRegionView*>(rv);
- MidiRegionView* mrv = dynamic_cast<MidiRegionView*>(rv);
+ assert (_new_region_view);
- const boost::shared_ptr<const Region> original = rv->region();
- boost::shared_ptr<Region> region_copy = RegionFactory::create (original);
- region_copy->set_position (original->position(), this);
+ return _new_region_view;
+}
- RegionView* nrv;
- if (arv) {
- boost::shared_ptr<AudioRegion> audioregion_copy
- = boost::dynamic_pointer_cast<AudioRegion>(region_copy);
+void
+RegionMoveDrag::collect_new_region_view (RegionView* rv)
+{
+ _new_region_view = rv;
+}
- nrv = new AudioRegionView (*arv, audioregion_copy);
- } else if (mrv) {
- boost::shared_ptr<MidiRegion> midiregion_copy
- = boost::dynamic_pointer_cast<MidiRegion>(region_copy);
- nrv = new MidiRegionView (*mrv, midiregion_copy);
+void
+RegionMoveDrag::add_stateful_diff_commands_for_playlists (PlaylistSet const & playlists)
+{
+ for (PlaylistSet::const_iterator i = playlists.begin(); i != playlists.end(); ++i) {
+ StatefulDiffCommand* c = new StatefulDiffCommand (*i);
+ if (!c->empty()) {
+ _editor->session()->add_command (c);
} else {
- continue;
- }
-
- nrv->get_canvas_group()->show ();
- new_regionviews.push_back (DraggingView (nrv));
-
- /* swap _primary to the copy */
-
- if (rv == _primary) {
- _primary = nrv;
+ delete c;
}
-
- /* ..and deselect the one we copied */
-
- rv->set_selected (false);
- }
-
- if (new_regionviews.empty()) {
- return;
}
-
- /* reflect the fact that we are dragging the copies */
-
- _views = new_regionviews;
-
- 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();
}
-bool
-RegionMotionDrag::check_possible (RouteTimeAxisView** tv, layer_t* layer)
-{
- /* Which trackview is this ? */
- pair<TimeAxisView*, int> const tvp = _editor->trackview_by_y_position (_drags->current_pointer_y ());
- (*tv) = dynamic_cast<RouteTimeAxisView*> (tvp.first);
- (*layer) = tvp.second;
+void
+RegionMoveDrag::aborted (bool movement_occurred)
+{
+ if (_copy) {
- if (*tv && (*tv)->layer_display() == Overlaid) {
- *layer = 0;
- }
+ for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
+ delete i->view;
+ }
- /* The region motion is only processed if the pointer is over
- an audio track.
- */
+ _views.clear ();
- if (!(*tv) || !(*tv)->is_track()) {
- /* 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;
+ } else {
+ RegionMotionDrag::aborted (movement_occurred);
}
-
- return true;
}
-/** @param new_order New track order.
- * @param old_order Old track order.
- * @param visible_y_low Lowest visible order.
- * @return true if y movement should not happen, otherwise false.
- */
-bool
-RegionMotionDrag::y_movement_disallowed (int new_order, int old_order, int y_span, TimeAxisViewSummary const & tavs) const
+void
+RegionMotionDrag::aborted (bool)
{
- if (new_order != old_order) {
-
- /* this isn't the pointer track */
-
- if (y_span > 0) {
-
- /* moving up the canvas */
- if ( (new_order - y_span) >= tavs.visible_y_low) {
-
- int32_t n = 0;
-
- /* work out where we'll end up with this y span, taking hidden TimeAxisViews into account */
- int32_t visible_tracks = 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 lowest visible track; disallow */
- return true;
- }
-
- } else if (y_span < 0) {
-
- /* moving down the canvas */
- if ((new_order - y_span) <= tavs.visible_y_high) {
-
- int32_t visible_tracks = 0;
- 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;
- } else if ((new_order - y_span) < tavs.visible_y_low) {
- /* we will overflow */
- return true;
- }
+ for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
+ RegionView* rv = i->view;
+ TimeAxisView* tv = &(rv->get_time_axis_view ());
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (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 ());
}
- return false;
+ _editor->update_canvas_now ();
}
-
-
+
RegionMoveDrag::RegionMoveDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v, bool b, bool c)
: RegionMotionDrag (e, i, p, v, b),
_copy (c)
{
- TimeAxisView* const tv = &_primary->get_time_axis_view ();
-
- _dest_trackview = tv;
- if (tv->layer_display() == Overlaid) {
- _dest_layer = 0;
- } else {
- _dest_layer = _primary->region()->layer ();
- }
-
+ DEBUG_TRACE (DEBUG::Drags, "New RegionMoveDrag\n");
+
double speed = 1;
- RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tv);
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (&_primary->get_time_axis_view ());
if (rtv && rtv->is_track()) {
speed = rtv->track()->speed ();
}
- _last_frame_position = static_cast<nframes64_t> (_primary->region()->position() / speed);
+ _last_frame_position = static_cast<framepos_t> (_primary->region()->position() / speed);
}
void
-RegionMoveDrag::start_grab (GdkEvent* event, Gdk::Cursor* c)
+RegionMoveDrag::setup_pointer_frame_offset ()
{
- RegionMotionDrag::start_grab (event, c);
-
- _pointer_frame_offset = grab_frame() - _last_frame_position;
+ _pointer_frame_offset = raw_grab_frame() - _last_frame_position;
}
-RegionInsertDrag::RegionInsertDrag (Editor* e, boost::shared_ptr<Region> r, RouteTimeAxisView* v, nframes64_t pos)
+RegionInsertDrag::RegionInsertDrag (Editor* e, boost::shared_ptr<Region> r, RouteTimeAxisView* v, framepos_t pos)
: RegionMotionDrag (e, 0, 0, list<RegionView*> (), false)
{
+ DEBUG_TRACE (DEBUG::Drags, "New RegionInsertDrag\n");
+
assert ((boost::dynamic_pointer_cast<AudioRegion> (r) && dynamic_cast<AudioTimeAxisView*> (v)) ||
(boost::dynamic_pointer_cast<MidiRegion> (r) && dynamic_cast<MidiTimeAxisView*> (v)));
_primary->get_canvas_group()->show ();
_primary->set_position (pos, 0);
- _views.push_back (DraggingView (_primary));
+ _views.push_back (DraggingView (_primary, this));
_last_frame_position = pos;
_item = _primary->get_canvas_group ();
- _dest_trackview = v;
- _dest_layer = _primary->region()->layer ();
-}
-
-map<RegionView*, pair<RouteTimeAxisView*, int> >
-RegionMotionDrag::find_time_axis_views_and_layers ()
-{
- map<RegionView*, pair<RouteTimeAxisView*, int> > tav;
-
- for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
-
- double ix1, ix2, iy1, iy2;
- 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<TimeAxisView*, int> tv = _editor->trackview_by_y_position (iy1);
- tav[rv] = make_pair (dynamic_cast<RouteTimeAxisView*> (tv.first), tv.second);
- }
-
- return tav;
}
-
void
-RegionInsertDrag::finished (GdkEvent* /*event*/, bool /*movement_occurred*/)
+RegionInsertDrag::finished (GdkEvent *, bool)
{
_editor->update_canvas_now ();
- map<RegionView*, pair<RouteTimeAxisView*, int> > final = find_time_axis_views_and_layers ();
-
- RouteTimeAxisView* dest_rtv = final[_primary].first;
+ RouteTimeAxisView* dest_rtv = dynamic_cast<RouteTimeAxisView*> (_time_axis_views[_views.front().time_axis_view]);
_primary->get_canvas_group()->reparent (*dest_rtv->view()->canvas_item());
_primary->get_canvas_group()->property_y() = 0;
boost::shared_ptr<Playlist> playlist = dest_rtv->playlist();
- _editor->begin_reversible_command (_("insert region"));
- playlist->clear_history ();
+ _editor->begin_reversible_command (Operations::insert_region);
+ playlist->clear_changes ();
playlist->add_region (_primary->region (), _last_frame_position);
_editor->session()->add_command (new StatefulDiffCommand (playlist));
_editor->commit_reversible_command ();
}
void
-RegionInsertDrag::aborted ()
+RegionInsertDrag::aborted (bool)
{
delete _primary;
_primary = 0;
RegionSpliceDrag::RegionSpliceDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v)
: RegionMoveDrag (e, i, p, v, false, false)
{
-
+ DEBUG_TRACE (DEBUG::Drags, "New RegionSpliceDrag\n");
}
struct RegionSelectionByPosition {
void
RegionSpliceDrag::motion (GdkEvent* event, bool)
{
- RouteTimeAxisView* tv;
- layer_t layer;
+ /* Which trackview is this ? */
+
+ pair<TimeAxisView*, int> const tvp = _editor->trackview_by_y_position (_drags->current_pointer_y ());
+ RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*> (tvp.first);
+ layer_t layer = tvp.second;
+
+ if (tv && tv->layer_display() == Overlaid) {
+ layer = 0;
+ }
- if (!check_possible (&tv, &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.
+ */
+ _editor->hide_verbose_canvas_cursor ();
return;
}
RegionSelectionByPosition cmp;
copy.sort (cmp);
- nframes64_t const pf = adjusted_current_frame (event);
+ framepos_t const pf = adjusted_current_frame (event);
for (RegionSelection::iterator i = copy.begin(); i != copy.end(); ++i) {
}
void
-RegionSpliceDrag::finished (GdkEvent* /*event*/, bool)
+RegionSpliceDrag::finished (GdkEvent* event, bool movement_occurred)
{
-
+ RegionMoveDrag::finished (event, movement_occurred);
}
void
-RegionSpliceDrag::aborted ()
+RegionSpliceDrag::aborted (bool)
{
/* XXX: TODO */
}
RegionCreateDrag::RegionCreateDrag (Editor* e, ArdourCanvas::Item* i, TimeAxisView* v)
: Drag (e, i),
- _view (v)
-{
-
-}
-
-void
-RegionCreateDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
+ _view (dynamic_cast<MidiTimeAxisView*> (v))
{
- _dest_trackview = _view;
-
- Drag::start_grab (event);
+ DEBUG_TRACE (DEBUG::Drags, "New RegionCreateDrag\n");
+
+ assert (_view);
}
-
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
+ add_region();
+ } else {
+ if (_region) {
+ framepos_t const f = adjusted_current_frame (event);
+ if (f < grab_frame()) {
+ _region->set_position (f, this);
+ }
+
+ /* again, don't use a zero-length region (see above) */
+ framecnt_t const len = abs (f - grab_frame ());
+ _region->set_length (len < 1 ? 1 : len, this);
+ }
}
-
- // TODO: resize region-create-drag region view here
}
void
-RegionCreateDrag::finished (GdkEvent* event, bool movement_occurred)
+RegionCreateDrag::finished (GdkEvent*, bool movement_occurred)
{
- MidiTimeAxisView* mtv = dynamic_cast<MidiTimeAxisView*> (_dest_trackview);
+ if (!movement_occurred) {
+ add_region ();
+ }
- if (!mtv) {
- return;
+ if (_region) {
+ _editor->commit_reversible_command ();
}
+}
- if (!movement_occurred) {
- mtv->add_region (grab_frame ());
- } else {
- motion (event, false);
- // TODO: create region-create-drag region here
+void
+RegionCreateDrag::add_region ()
+{
+ if (_editor->session()) {
+ const TempoMap& map (_editor->session()->tempo_map());
+ framecnt_t pos = grab_frame();
+ const Meter& m = map.meter_at (pos);
+ /* not that the frame rate used here can be affected by pull up/down which
+ might be wrong.
+ */
+ framecnt_t len = m.frames_per_bar (map.tempo_at (pos), _editor->session()->frame_rate());
+ _region = _view->add_region (grab_frame(), len, false);
}
}
void
-RegionCreateDrag::aborted ()
+RegionCreateDrag::aborted (bool)
{
- /* XXX: TODO */
+ /* XXX */
}
NoteResizeDrag::NoteResizeDrag (Editor* e, ArdourCanvas::Item* i)
: Drag (e, i)
, region (0)
{
-
+ DEBUG_TRACE (DEBUG::Drags, "New NoteResizeDrag\n");
}
void
NoteResizeDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*ignored*/)
{
Gdk::Cursor* cursor;
- ArdourCanvas::CanvasNote* cnote = dynamic_cast<ArdourCanvas::CanvasNote*>(_item);
+ ArdourCanvas::CanvasNoteEvent* cnote = dynamic_cast<ArdourCanvas::CanvasNoteEvent*>(_item);
+ float x_fraction = cnote->mouse_x_fraction ();
- Drag::start_grab (event);
+ if (x_fraction > 0.0 && x_fraction < 0.25) {
+ cursor = _editor->cursors()->left_side_trim;
+ } else {
+ cursor = _editor->cursors()->right_side_trim;
+ }
+
+ Drag::start_grab (event, cursor);
region = &cnote->region_view();
double const middle_point = region_start + cnote->x1() + (cnote->x2() - cnote->x1()) / 2.0L;
if (grab_x() <= middle_point) {
- cursor = _editor->left_side_trim_cursor;
+ cursor = _editor->cursors()->left_side_trim;
at_front = true;
} else {
- cursor = _editor->right_side_trim_cursor;
+ cursor = _editor->cursors()->right_side_trim;
at_front = false;
}
{
MidiRegionSelection& ms (_editor->get_selection().midi_regions);
for (MidiRegionSelection::iterator r = ms.begin(); r != ms.end(); ++r) {
- (*r)->update_resizing (dynamic_cast<ArdourCanvas::CanvasNote*>(_item), at_front, _drags->current_pointer_x() - grab_x(), relative);
+ (*r)->update_resizing (dynamic_cast<ArdourCanvas::CanvasNoteEvent*>(_item), at_front, _drags->current_pointer_x() - grab_x(), relative);
}
}
{
MidiRegionSelection& ms (_editor->get_selection().midi_regions);
for (MidiRegionSelection::iterator r = ms.begin(); r != ms.end(); ++r) {
- (*r)->commit_resizing (dynamic_cast<ArdourCanvas::CanvasNote*>(_item), at_front, _drags->current_pointer_x() - grab_x(), relative);
+ (*r)->commit_resizing (dynamic_cast<ArdourCanvas::CanvasNoteEvent*>(_item), at_front, _drags->current_pointer_x() - grab_x(), relative);
}
}
void
-NoteResizeDrag::aborted ()
+NoteResizeDrag::aborted (bool)
{
/* XXX: TODO */
}
+RegionGainDrag::RegionGainDrag (Editor* e, ArdourCanvas::Item* i)
+ : Drag (e, i)
+{
+ DEBUG_TRACE (DEBUG::Drags, "New RegionGainDrag\n");
+}
+
void
RegionGainDrag::motion (GdkEvent* /*event*/, bool)
{
}
void
-RegionGainDrag::aborted ()
+RegionGainDrag::aborted (bool)
{
/* XXX: TODO */
}
TrimDrag::TrimDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v)
: RegionDrag (e, i, p, v)
- , _have_transaction (false)
{
-
+ DEBUG_TRACE (DEBUG::Drags, "New TrimDrag\n");
}
void
-TrimDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
+TrimDrag::start_grab (GdkEvent* event, Gdk::Cursor*)
{
double speed = 1.0;
TimeAxisView* tvp = &_primary->get_time_axis_view ();
speed = tv->track()->speed();
}
- nframes64_t const region_start = (nframes64_t) (_primary->region()->position() / speed);
- nframes64_t const region_end = (nframes64_t) (_primary->region()->last_frame() / speed);
- nframes64_t const region_length = (nframes64_t) (_primary->region()->length() / speed);
+ framepos_t const region_start = (framepos_t) (_primary->region()->position() / speed);
+ framepos_t const region_end = (framepos_t) (_primary->region()->last_frame() / speed);
+ framecnt_t const region_length = (framecnt_t) (_primary->region()->length() / speed);
- nframes64_t const pf = adjusted_current_frame (event);
+ framepos_t const pf = adjusted_current_frame (event);
if (Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
+ /* Move the contents of the region around without changing the region bounds */
_operation = ContentsTrim;
- Drag::start_grab (event, _editor->trimmer_cursor);
+ Drag::start_grab (event, _editor->cursors()->trimmer);
} else {
/* These will get overridden for a point trim.*/
if (pf < (region_start + region_length/2)) {
- /* closer to start */
+ /* closer to front */
_operation = StartTrim;
- Drag::start_grab (event, _editor->left_side_trim_cursor);
+ Drag::start_grab (event, _editor->cursors()->left_side_trim);
} else {
/* closer to end */
_operation = EndTrim;
- Drag::start_grab (event, _editor->right_side_trim_cursor);
- }
+ Drag::start_grab (event, _editor->cursors()->right_side_trim);
+ }
}
switch (_operation) {
case StartTrim:
_editor->show_verbose_time_cursor (region_start, 10);
+ for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
+ i->view->trim_front_starting ();
+ }
break;
case EndTrim:
_editor->show_verbose_time_cursor (region_end, 10);
_editor->show_verbose_time_cursor (pf, 10);
break;
}
+
+ for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
+ i->view->region()->suspend_property_changes ();
+ }
}
void
{
RegionView* rv = _primary;
- /* snap modifier works differently here..
- 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 ();
RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*>(tvp);
speed = tv->track()->speed();
}
- nframes64_t const pf = adjusted_current_frame (event);
+ framecnt_t const dt = adjusted_current_frame (event) - raw_grab_frame () + _pointer_frame_offset;
if (first_move) {
}
_editor->begin_reversible_command (trim_type);
- _have_transaction = true;
for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
RegionView* rv = i->view;
- rv->fake_set_opaque(false);
+ rv->fake_set_opaque (false);
rv->enable_display (false);
- rv->region()->clear_history ();
- rv->region()->suspend_property_changes ();
+ rv->region()->playlist()->clear_owned_changes ();
AudioRegionView* const arv = dynamic_cast<AudioRegionView*> (rv);
- if (arv){
+ if (arv) {
arv->temporarily_hide_envelope ();
}
switch (_operation) {
case StartTrim:
for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
- _editor->single_start_trim (*i->view, pf, non_overlap_trim);
+ i->view->trim_front (i->initial_position + dt, non_overlap_trim);
}
break;
case EndTrim:
for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
- _editor->single_end_trim (*i->view, pf, non_overlap_trim);
+ i->view->trim_end (i->initial_end + dt, non_overlap_trim);
}
break;
swap_direction = true;
}
- nframes64_t frame_delta = 0;
+ framecnt_t frame_delta = 0;
bool left_direction = false;
- if (last_pointer_frame() > pf) {
+ if (last_pointer_frame() > adjusted_current_frame(event)) {
left_direction = true;
}
if (left_direction) {
- frame_delta = (last_pointer_frame() - pf);
+ frame_delta = (last_pointer_frame() - adjusted_current_frame(event));
} else {
- frame_delta = (pf - last_pointer_frame());
+ frame_delta = (adjusted_current_frame(event) - last_pointer_frame());
}
for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
- _editor->single_contents_trim (*i->view, frame_delta, left_direction, swap_direction);
+ i->view->trim_contents (frame_delta, left_direction, swap_direction);
}
}
break;
switch (_operation) {
case StartTrim:
- _editor->show_verbose_time_cursor((nframes64_t) (rv->region()->position()/speed), 10);
+ _editor->show_verbose_time_cursor ((framepos_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 ((framepos_t) (rv->region()->last_frame() / speed), 10);
break;
case ContentsTrim:
- _editor->show_verbose_time_cursor (pf, 10);
+ _editor->show_verbose_time_cursor (adjusted_current_frame (event), 10);
break;
}
}
if (movement_occurred) {
motion (event, false);
+ /* This must happen before the region's StatefulDiffCommand is created, as it may
+ `correct' (ahem) the region's _start from being negative to being zero. It
+ needs to be zero in the undo record.
+ */
+ if (_operation == StartTrim) {
+ for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
+ i->view->trim_front_ending ();
+ }
+ }
+
if (!_editor->selection->selected (_primary)) {
- _editor->thaw_region_after_trim (*_primary);
+ _primary->thaw_after_trim ();
} else {
+ set<boost::shared_ptr<Playlist> > diffed_playlists;
+
for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
- _editor->thaw_region_after_trim (*i->view);
+ i->view->thaw_after_trim ();
i->view->enable_display (true);
i->view->fake_set_opaque (true);
- if (_have_transaction) {
- _editor->session()->add_command (new StatefulDiffCommand (i->view->region()));
- }
+
+ /* Trimming one region may affect others on the playlist, so we need
+ to get undo Commands from the whole playlist rather than just the
+ region. Use diffed_playlists to make sure we don't diff a given
+ playlist more than once.
+ */
+ boost::shared_ptr<Playlist> p = i->view->region()->playlist ();
+ if (diffed_playlists.find (p) == diffed_playlists.end()) {
+ vector<Command*> cmds;
+ p->rdiff (cmds);
+ _editor->session()->add_commands (cmds);
+ diffed_playlists.insert (p);
+ }
}
}
for (set<boost::shared_ptr<Playlist> >::iterator p = _editor->motion_frozen_playlists.begin(); p != _editor->motion_frozen_playlists.end(); ++p) {
}
_editor->motion_frozen_playlists.clear ();
-
- if (_have_transaction) {
- _editor->commit_reversible_command();
- }
+ _editor->commit_reversible_command();
} else {
/* no mouse movement */
_editor->point_trim (event, adjusted_current_frame (event));
}
+
+ for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
+ if (_operation == StartTrim) {
+ i->view->trim_front_ending ();
+ }
+
+ i->view->region()->resume_property_changes ();
+ }
}
void
-TrimDrag::aborted ()
+TrimDrag::aborted (bool movement_occurred)
{
/* Our motion method is changing model state, so use the Undo system
to cancel. Perhaps not ideal, as this will leave an Undo point
finished (0, true);
- if (_have_transaction) {
+ if (movement_occurred) {
_editor->undo ();
}
+
+ for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
+ i->view->region()->resume_property_changes ();
+ }
+}
+
+void
+TrimDrag::setup_pointer_frame_offset ()
+{
+ list<DraggingView>::iterator i = _views.begin ();
+ while (i != _views.end() && i->view != _primary) {
+ ++i;
+ }
+
+ if (i == _views.end()) {
+ return;
+ }
+
+ switch (_operation) {
+ case StartTrim:
+ _pointer_frame_offset = raw_grab_frame() - i->initial_position;
+ break;
+ case EndTrim:
+ _pointer_frame_offset = raw_grab_frame() - i->initial_end;
+ break;
+ case ContentsTrim:
+ break;
+ }
}
MeterMarkerDrag::MeterMarkerDrag (Editor* e, ArdourCanvas::Item* i, bool c)
: Drag (e, i),
_copy (c)
{
+ DEBUG_TRACE (DEBUG::Drags, "New MeterMarkerDrag\n");
+
_marker = reinterpret_cast<MeterMarker*> (_item->get_data ("marker"));
assert (_marker);
}
// 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,
- *new MeterSection (_marker->meter()));
+
+ 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;
Drag::start_grab (event, cursor);
- _pointer_frame_offset = grab_frame() - _marker->meter().frame();
-
_editor->show_verbose_time_cursor (adjusted_current_frame(event), 10);
}
+void
+MeterMarkerDrag::setup_pointer_frame_offset ()
+{
+ _pointer_frame_offset = raw_grab_frame() - _marker->meter().frame();
+}
+
void
MeterMarkerDrag::motion (GdkEvent* event, bool)
{
- nframes64_t const pf = adjusted_current_frame (event);
+ framepos_t const pf = adjusted_current_frame (event);
_marker->set_position (pf);
motion (event, false);
- BBT_Time when;
+ Timecode::BBT_Time when;
TempoMap& map (_editor->session()->tempo_map());
map.bbt_time (last_pointer_frame(), when);
}
void
-MeterMarkerDrag::aborted ()
+MeterMarkerDrag::aborted (bool)
{
_marker->set_position (_marker->meter().frame ());
}
: Drag (e, i),
_copy (c)
{
+ DEBUG_TRACE (DEBUG::Drags, "New TempoMarkerDrag\n");
+
_marker = reinterpret_cast<TempoMarker*> (_item->get_data ("marker"));
assert (_marker);
}
void
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,
- *new TempoSection (_marker->tempo()));
+
+ 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 ();
_marker = new_marker;
- } else {
-
- MetricSection& section (_marker->tempo());
-
- if (!section.movable()) {
- return;
- }
}
Drag::start_grab (event, cursor);
- _pointer_frame_offset = grab_frame() - _marker->tempo().frame();
_editor->show_verbose_time_cursor (adjusted_current_frame (event), 10);
}
+void
+TempoMarkerDrag::setup_pointer_frame_offset ()
+{
+ _pointer_frame_offset = raw_grab_frame() - _marker->tempo().frame();
+}
+
void
TempoMarkerDrag::motion (GdkEvent* event, bool)
{
- nframes64_t const pf = adjusted_current_frame (event);
+ framepos_t const pf = adjusted_current_frame (event);
_marker->set_position (pf);
_editor->show_verbose_time_cursor (pf, 10);
}
motion (event, false);
- BBT_Time when;
+ Timecode::BBT_Time when;
TempoMap& map (_editor->session()->tempo_map());
map.bbt_time (last_pointer_frame(), when);
}
void
-TempoMarkerDrag::aborted ()
+TempoMarkerDrag::aborted (bool)
{
_marker->set_position (_marker->tempo().frame());
}
: Drag (e, i),
_stop (s)
{
- _cursor = reinterpret_cast<EditorCursor*> (_item->get_data ("cursor"));
- assert (_cursor);
+ DEBUG_TRACE (DEBUG::Drags, "New CursorDrag\n");
}
+/** Do all the things we do when dragging the playhead to make it look as though
+ * we have located, without actually doing the locate (because that would cause
+ * the diskstream buffers to be refilled, which is too slow).
+ */
void
-CursorDrag::start_grab (GdkEvent* event, Gdk::Cursor* c)
+CursorDrag::fake_locate (framepos_t t)
{
- Drag::start_grab (event, c);
-
- if (!_stop) {
-
- nframes64_t where = _editor->event_frame (event, 0, 0);
+ _editor->playhead_cursor->set_position (t);
+
+ Session* s = _editor->session ();
+ if (s->timecode_transmission_suspended ()) {
+ framepos_t const f = _editor->playhead_cursor->current_frame;
+ s->send_mmc_locate (f);
+ s->send_full_time_code (f);
+ }
- _editor->snap_to_with_modifier (where, event);
- _editor->playhead_cursor->set_position (where);
+ _editor->show_verbose_time_cursor (t, 10);
+ _editor->UpdateAllTransportClocks (t);
+}
- }
+void
+CursorDrag::start_grab (GdkEvent* event, Gdk::Cursor* c)
+{
+ Drag::start_grab (event, c);
- if (_cursor == _editor->playhead_cursor) {
- _editor->_dragging_playhead = true;
+ framepos_t where = _editor->event_frame (event, 0, 0);
+ _editor->snap_to_with_modifier (where, event);
- if (_editor->session() && _was_rolling && _stop) {
- _editor->session()->request_stop ();
+ _editor->_dragging_playhead = true;
+
+ Session* s = _editor->session ();
+
+ if (s) {
+ if (_was_rolling && _stop) {
+ s->request_stop ();
}
-
- if (_editor->session() && _editor->session()->is_auditioning()) {
- _editor->session()->cancel_audition ();
+
+ if (s->is_auditioning()) {
+ s->cancel_audition ();
+ }
+
+ s->request_suspend_timecode_transmission ();
+ while (!s->timecode_transmission_suspended ()) {
+ /* twiddle our thumbs */
}
}
-
- _pointer_frame_offset = grab_frame() - _cursor->current_frame;
-
- _editor->show_verbose_time_cursor (_cursor->current_frame, 10);
+
+ fake_locate (where);
}
void
CursorDrag::motion (GdkEvent* event, bool)
{
- nframes64_t const adjusted_frame = adjusted_current_frame (event);
+ framepos_t const adjusted_frame = adjusted_current_frame (event);
if (adjusted_frame == last_pointer_frame()) {
return;
}
- _cursor->set_position (adjusted_frame);
-
- _editor->show_verbose_time_cursor (_cursor->current_frame, 10);
-
- if (_editor->session() && _item == &_editor->playhead_cursor->canvas_item) {
- _editor->session()->send_mmc_locate (_editor->playhead_cursor->current_frame);
- }
+ fake_locate (adjusted_frame);
-
#ifdef GTKOSX
_editor->update_canvas_now ();
#endif
- _editor->UpdateAllTransportClocks (_cursor->current_frame);
}
void
motion (event, false);
- if (_item == &_editor->playhead_cursor->canvas_item) {
- if (_editor->session()) {
- _editor->session()->request_locate (_editor->playhead_cursor->current_frame, _was_rolling);
- _editor->_pending_locate_request = true;
- }
+ Session* s = _editor->session ();
+ if (s) {
+ s->request_locate (_editor->playhead_cursor->current_frame, _was_rolling);
+ _editor->_pending_locate_request = true;
+ s->request_resume_timecode_transmission ();
}
}
void
-CursorDrag::aborted ()
+CursorDrag::aborted (bool)
{
- _editor->_dragging_playhead = false;
- _cursor->set_position (adjusted_frame (grab_frame (), 0, false));
+ if (_editor->_dragging_playhead) {
+ _editor->session()->request_resume_timecode_transmission ();
+ _editor->_dragging_playhead = false;
+ }
+
+ _editor->playhead_cursor->set_position (adjusted_frame (grab_frame (), 0, false));
}
FadeInDrag::FadeInDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v)
: RegionDrag (e, i, p, v)
{
-
+ DEBUG_TRACE (DEBUG::Drags, "New FadeInDrag\n");
}
void
{
Drag::start_grab (event, cursor);
- AudioRegionView* a = dynamic_cast<AudioRegionView*> (_primary);
- boost::shared_ptr<AudioRegion> const r = a->audio_region ();
+ AudioRegionView* a
rv = dynamic_cast<AudioRegionView*> (_primary);
+ boost::shared_ptr<AudioRegion> const r = arv->audio_region ();
- _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);
+ arv->show_fade_line((framepos_t) r->fade_in()->back()->when);
+}
+
+void
+FadeInDrag::setup_pointer_frame_offset ()
+{
+ AudioRegionView* arv = dynamic_cast<AudioRegionView*> (_primary);
+ boost::shared_ptr<AudioRegion> const r = arv->audio_region ();
+ _pointer_frame_offset = raw_grab_frame() - ((framecnt_t) r->fade_in()->back()->when + r->position());
}
void
FadeInDrag::motion (GdkEvent* event, bool)
{
- nframes64_t fade_length;
+ framecnt_t fade_length;
- nframes64_t const pos = adjusted_current_frame (event);
+ framepos_t const pos = adjusted_current_frame (event);
boost::shared_ptr<Region> region = _primary->region ();
}
tmp->reset_fade_in_shape_width (fade_length);
+ tmp->show_fade_line((framecnt_t) fade_length);
}
_editor->show_verbose_duration_cursor (region->position(), region->position() + fade_length, 10);
return;
}
- nframes64_t fade_length;
+ framecnt_t fade_length;
- nframes64_t const pos = adjusted_current_frame (event);
+ framepos_t const pos = adjusted_current_frame (event);
boost::shared_ptr<Region> region = _primary->region ();
tmp->audio_region()->set_fade_in_length (fade_length);
tmp->audio_region()->set_fade_in_active (true);
+ tmp->hide_fade_line();
XMLNode &after = alist->get_state();
_editor->session()->add_command(new MementoCommand<AutomationList>(*alist.get(), &before, &after));
}
void
-FadeInDrag::aborted ()
+FadeInDrag::aborted (bool)
{
for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (i->view);
}
tmp->reset_fade_in_shape_width (tmp->audio_region()->fade_in()->back()->when);
+ tmp->hide_fade_line();
}
}
FadeOutDrag::FadeOutDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v)
: RegionDrag (e, i, p, v)
{
-
+ DEBUG_TRACE (DEBUG::Drags, "New FadeOutDrag\n");
}
void
{
Drag::start_grab (event, cursor);
- AudioRegionView* a = dynamic_cast<AudioRegionView*> (_primary);
- boost::shared_ptr<AudioRegion> r = a->audio_region ();
+ AudioRegionView* a
rv = dynamic_cast<AudioRegionView*> (_primary);
+ boost::shared_ptr<AudioRegion> r = arv->audio_region ();
- _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);
+
+ arv->show_fade_line(r->length() - r->fade_out()->back()->when);
}
+void
+FadeOutDrag::setup_pointer_frame_offset ()
+{
+ AudioRegionView* arv = dynamic_cast<AudioRegionView*> (_primary);
+ boost::shared_ptr<AudioRegion> r = arv->audio_region ();
+ _pointer_frame_offset = raw_grab_frame() - (r->length() - (framecnt_t) r->fade_out()->back()->when + r->position());
+}
+
void
FadeOutDrag::motion (GdkEvent* event, bool)
{
- nframes64_t fade_length;
+ framecnt_t fade_length;
- nframes64_t const pos = adjusted_current_frame (event);
+ framepos_t const pos = adjusted_current_frame (event);
boost::shared_ptr<Region> region = _primary->region ();
}
tmp->reset_fade_out_shape_width (fade_length);
+ tmp->show_fade_line(region->length() - fade_length);
}
_editor->show_verbose_duration_cursor (region->last_frame() - fade_length, region->last_frame(), 10);
return;
}
- nframes64_t fade_length;
+ framecnt_t fade_length;
- nframes64_t const pos = adjusted_current_frame (event);
+ framepos_t const pos = adjusted_current_frame (event);
boost::shared_ptr<Region> region = _primary->region ();
tmp->audio_region()->set_fade_out_length (fade_length);
tmp->audio_region()->set_fade_out_active (true);
+ tmp->hide_fade_line();
XMLNode &after = alist->get_state();
_editor->session()->add_command(new MementoCommand<AutomationList>(*alist.get(), &before, &after));
}
void
-FadeOutDrag::aborted ()
+FadeOutDrag::aborted (bool)
{
for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (i->view);
}
tmp->reset_fade_out_shape_width (tmp->audio_region()->fade_out()->back()->when);
+ tmp->hide_fade_line();
}
}
MarkerDrag::MarkerDrag (Editor* e, ArdourCanvas::Item* i)
: Drag (e, i)
{
+ DEBUG_TRACE (DEBUG::Drags, "New MarkerDrag\n");
+
_marker = reinterpret_cast<Marker*> (_item->get_data ("marker"));
assert (_marker);
_points.push_back (Gnome::Art::Point (0, 0));
- _points.push_back (Gnome::Art::Point (0, _editor->physical_screen_height));
-
- _line = new ArdourCanvas::Line (*_editor->timebar_group);
- _line->property_width_pixels() = 1;
- _line->property_points () = _points;
- _line->hide ();
-
- _line->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_MarkerDragLine.get();
+ _points.push_back (Gnome::Art::Point (0, physical_screen_height (_editor->get_window())));
}
MarkerDrag::~MarkerDrag ()
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());
-
update_item (location);
// _drag_line->show();
{
Locations::LocationList ll;
list<Marker*> to_add;
- nframes64_t s, e;
+ framepos_t s, e;
_editor->selection->markers.range (s, e);
s = min (_marker->position(), s);
e = max (_marker->position(), e);
s = min (s, e);
e = max (s, e);
- if (e < max_frames) {
+ if (e < max_framepos) {
++e;
}
_editor->session()->locations()->find_all_between (s, e, ll, Location::Flags (0));
}
}
+void
+MarkerDrag::setup_pointer_frame_offset ()
+{
+ bool is_start;
+ Location *location = _editor->find_location_from_marker (_marker, is_start);
+ _pointer_frame_offset = raw_grab_frame() - (is_start ? location->start() : location->end());
+}
+
void
MarkerDrag::motion (GdkEvent* event, bool)
{
- nframes64_t f_delta = 0;
+ framecnt_t f_delta = 0;
bool is_start;
bool move_both = false;
Marker* marker;
Location *real_location;
Location *copy_location = 0;
- nframes64_t const newframe = adjusted_current_frame (event);
+ framepos_t const newframe = adjusted_current_frame (event);
- nframes64_t next = newframe;
+ framepos_t next = newframe;
if (newframe == last_pointer_frame()) {
return;
switch (marker->type()) {
- case Marker::Start:
+ case Marker::SessionStart:
+ case Marker::RangeStart:
case Marker::LoopStart:
case Marker::PunchIn:
f_delta = newframe - copy_location->start();
break;
- case Marker::End:
+ case Marker::SessionEnd:
+ case Marker::RangeEnd:
case Marker::LoopEnd:
case Marker::PunchOut:
f_delta = newframe - copy_location->end();
} else {
- nframes64_t new_start = copy_location->start() + f_delta;
- nframes64_t new_end = copy_location->end() + f_delta;
+ framepos_t new_start = copy_location->start() + f_delta;
+ framepos_t new_end = copy_location->end() + f_delta;
if (is_start) { // start-of-range marker
copy_location->set_end (new_end);
} else if (new_start < copy_location->end()) {
copy_location->set_start (new_start);
- } else {
+ } else if (newframe > 0) {
_editor->snap_to (next, 1, true);
copy_location->set_end (next);
copy_location->set_start (newframe);
XMLNode &after = _editor->session()->locations()->get_state();
_editor->session()->add_command(new MementoCommand<Locations>(*(_editor->session()->locations()), &before, &after));
_editor->commit_reversible_command ();
-
- _line->hide();
}
void
-MarkerDrag::aborted ()
+MarkerDrag::aborted (bool)
{
/* XXX: TODO */
}
void
MarkerDrag::update_item (Location* location)
{
- double const x1 = _editor->frame_to_pixel (location->start());
-
- _points.front().set_x(x1);
- _points.back().set_x(x1);
- _line->property_points() = _points;
+ /* noop */
}
ControlPointDrag::ControlPointDrag (Editor* e, ArdourCanvas::Item* i)
_cumulative_x_drag (0),
_cumulative_y_drag (0)
{
+ DEBUG_TRACE (DEBUG::Drags, "New ControlPointDrag\n");
+
_point = reinterpret_cast<ControlPoint*> (_item->get_data ("control_point"));
assert (_point);
}
void
ControlPointDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*cursor*/)
{
- Drag::start_grab (event, _editor->fader_cursor);
+ Drag::start_grab (event, _editor->cursors()->fader);
// start the grab at the center of the control point so
// the point doesn't 'jump' to the mouse after the first drag
- _time_axis_view_grab_x = _point->get_x();
- _time_axis_view_grab_y = _point->get_y();
+ _fixed_grab_x = _point->get_x();
+ _fixed_grab_y = _point->get_y();
float const fraction = 1 - (_point->get_y() / _point->line().height());
- _point->line().start_drag_single (_point, _time_axis_view_grab_x, fraction);
+ _point->line().start_drag_single (_point, _fixed_grab_x, fraction);
_editor->set_verbose_canvas_cursor (_point->line().get_verbose_cursor_string (fraction),
event->button.x + 10, event->button.y + 10);
dy *= 0.1;
}
- /* 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;
+ /* coordinate in pixels relative to the start of the region (for region-based automation)
+ or track (for track-based automation) */
+ double cx = _fixed_grab_x + _cumulative_x_drag + dx;
+ double cy = _fixed_grab_y + _cumulative_y_drag + dy;
// calculate zero crossing point. back off by .01 to stay on the
// positive side of zero
}
if (_x_constrained) {
- cx = _time_axis_view_grab_x;
+ cx = _fixed_grab_x;
}
if (_y_constrained) {
- cy = _time_axis_view_grab_y;
+ cy = _fixed_grab_y;
}
- _cumulative_x_drag = cx - _time_axis_view_grab_x;
- _cumulative_y_drag = cy - _time_axis_view_grab_y;
+ _cumulative_x_drag = cx - _fixed_grab_x;
+ _cumulative_y_drag = cy - _fixed_grab_y;
cx = max (0.0, cx);
cy = max (0.0, cy);
cy = min ((double) _point->line().height(), cy);
- nframes64_t cx_frames = _editor->unit_to_frame (cx);
-
+ framepos_t cx_frames = _editor->unit_to_frame (cx);
+
if (!_x_constrained) {
_editor->snap_to_with_modifier (cx_frames, event);
}
+ cx_frames = min (cx_frames, _point->line().maximum_time());
+
float const fraction = 1.0 - (cy / _point->line().height());
bool const push = Keyboard::modifier_state_contains (event->button.state, Keyboard::PrimaryModifier);
/* just a click */
- if ((event->type == GDK_BUTTON_RELEASE) && (event->button.button == 1) && Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
+ if (Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
_editor->reset_point_selection ();
}
} else {
motion (event, false);
}
+
_point->line().end_drag ();
+ _editor->session()->commit_reversible_command ();
}
void
-ControlPointDrag::aborted ()
+ControlPointDrag::aborted (bool)
{
_point->line().reset ();
}
_line (0),
_cumulative_y_drag (0)
{
-
+ DEBUG_TRACE (DEBUG::Drags, "New LineDrag\n");
}
+
void
LineDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*cursor*/)
{
_line->parent_group().w2i (cx, cy);
- nframes64_t const frame_within_region = (nframes64_t) floor (cx * _editor->frames_per_unit);
+ framecnt_t const frame_within_region = (framecnt_t) floor (cx * _editor->frames_per_unit);
uint32_t before;
uint32_t after;
return;
}
- Drag::start_grab (event, _editor->fader_cursor);
+ Drag::start_grab (event, _editor->cursors()->fader);
/* store grab start in parent frame */
- _time_axis_view_grab_x = cx;
- _time_axis_view_grab_y = cy;
+ _fixed_grab_x = cx;
+ _fixed_grab_y = cy;
double fraction = 1.0 - (cy / _line->height());
dy *= 0.1;
}
- double cy = _time_axis_view_grab_y + _cumulative_y_drag + dy;
+ double cy = _fixed_grab_y + _cumulative_y_drag + dy;
- _cumulative_y_drag = cy - _time_axis_view_grab_y;
+ _cumulative_y_drag = cy - _fixed_grab_y;
cy = max (0.0, cy);
cy = min ((double) _line->height(), cy);
{
motion (event, false);
_line->end_drag ();
+ _editor->session()->commit_reversible_command ();
}
void
-LineDrag::aborted ()
+LineDrag::aborted (bool)
{
_line->reset ();
}
_line (0),
_cumulative_x_drag (0)
{
-
+ DEBUG_TRACE (DEBUG::Drags, "New FeatureLineDrag\n");
}
+
void
FeatureLineDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*cursor*/)
{
-
Drag::start_grab (event);
_line = reinterpret_cast<SimpleLine*> (_item);
}
void
-FeatureLineDrag::motion (GdkEvent* event, bool)
+FeatureLineDrag::motion (GdkEvent*, bool)
{
double dx = _drags->current_pointer_x() - last_pointer_x();
}
void
-FeatureLineDrag::finished (GdkEvent* event, bool)
+FeatureLineDrag::finished (GdkEvent*, bool)
{
_arv = reinterpret_cast<AudioRegionView*> (_item->get_data ("regionview"));
_arv->update_transient(_before, _line->property_x1());
}
void
-FeatureLineDrag::aborted ()
+FeatureLineDrag::aborted (bool)
{
//_line->reset ();
}
+RubberbandSelectDrag::RubberbandSelectDrag (Editor* e, ArdourCanvas::Item* i)
+ : Drag (e, i)
+{
+ DEBUG_TRACE (DEBUG::Drags, "New RubberbandSelectDrag\n");
+}
+
void
RubberbandSelectDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
{
void
RubberbandSelectDrag::motion (GdkEvent* event, bool)
{
- nframes64_t start;
- nframes64_t end;
+ framepos_t start;
+ framepos_t end;
double y1;
double y2;
- nframes64_t const pf = adjusted_current_frame (event, Config->get_rubberbanding_snaps_to_grid ());
+ framepos_t const pf = adjusted_current_frame (event, Config->get_rubberbanding_snaps_to_grid ());
- nframes64_t grab = grab_frame ();
+ framepos_t grab = grab_frame ();
if (Config->get_rubberbanding_snaps_to_grid ()) {
_editor->snap_to_with_modifier (grab, event);
}
Selection::Operation op = ArdourKeyboard::selection_type (event->button.state);
- bool committed;
_editor->begin_reversible_command (_("rubberband selection"));
if (grab_frame() < last_pointer_frame()) {
- committed = _editor->select_all_within (grab_frame(), last_pointer_frame() - 1, y1, y2, _editor->track_views, op);
+ _editor->select_all_within (grab_frame(), last_pointer_frame() - 1, y1, y2, _editor->track_views, op, false);
} else {
- committed = _editor->select_all_within (last_pointer_frame(), grab_frame() - 1, y1, y2, _editor->track_views, op);
- }
-
- if (!committed) {
- _editor->commit_reversible_command ();
+ _editor->select_all_within (last_pointer_frame(), grab_frame() - 1, y1, y2, _editor->track_views, op, false);
}
+ _editor->commit_reversible_command ();
} else {
if (!getenv("ARDOUR_SAE")) {
_editor->selection->clear_tracks();
}
void
-RubberbandSelectDrag::aborted ()
+RubberbandSelectDrag::aborted (bool)
{
_editor->rubberband_rect->hide ();
}
+TimeFXDrag::TimeFXDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, std::list<RegionView*> const & v)
+ : RegionDrag (e, i, p, v)
+{
+ DEBUG_TRACE (DEBUG::Drags, "New TimeFXDrag\n");
+}
+
void
-TimeFXDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
+TimeFXDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
{
- Drag::start_grab (event);
+ Drag::start_grab (event, cursor);
_editor->show_verbose_time_cursor (adjusted_current_frame (event), 10);
}
{
RegionView* rv = _primary;
- nframes64_t const pf = adjusted_current_frame (event);
+ framepos_t const pf = adjusted_current_frame (event);
if (pf > rv->region()->position()) {
rv->get_time_axis_view().show_timestretch (rv->region()->position(), pf);
return;
}
- nframes64_t newlen = last_pointer_frame() - _primary->region()->position();
+ framecnt_t newlen = last_pointer_frame() - _primary->region()->position();
float percentage = (double) newlen / (double) _primary->region()->length();
}
void
-TimeFXDrag::aborted ()
+TimeFXDrag::aborted (bool)
{
_primary->get_time_axis_view().hide_timestretch ();
}
+ScrubDrag::ScrubDrag (Editor* e, ArdourCanvas::Item* i)
+ : Drag (e, i)
+{
+ DEBUG_TRACE (DEBUG::Drags, "New ScrubDrag\n");
+}
void
ScrubDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
}
void
-ScrubDrag::aborted ()
+ScrubDrag::aborted (bool)
{
/* XXX: TODO */
}
, _original_pointer_time_axis (-1)
, _last_pointer_time_axis (-1)
{
-
+ DEBUG_TRACE (DEBUG::Drags, "New SelectionDrag\n");
}
void
SelectionDrag::start_grab (GdkEvent* event, Gdk::Cursor*)
{
- nframes64_t start = 0;
- nframes64_t end = 0;
-
if (_editor->session() == 0) {
return;
}
} else {
_copy = false;
}
- cursor = _editor->selector_cursor;
+ cursor = _editor->cursors()->selector;
Drag::start_grab (event, cursor);
break;
if (_editor->clicked_axisview) {
_editor->clicked_axisview->order_selection_trims (_item, true);
}
- Drag::start_grab (event, _editor->left_side_trim_cursor);
- start = _editor->selection->time[_editor->clicked_selection].start;
- _pointer_frame_offset = grab_frame() - start;
+ Drag::start_grab (event, _editor->cursors()->left_side_trim);
break;
case SelectionEndTrim:
if (_editor->clicked_axisview) {
_editor->clicked_axisview->order_selection_trims (_item, false);
}
- Drag::start_grab (event, _editor->right_side_trim_cursor);
- end = _editor->selection->time[_editor->clicked_selection].end;
- _pointer_frame_offset = grab_frame() - end;
+ Drag::start_grab (event, _editor->cursors()->right_side_trim);
break;
case SelectionMove:
- start = _editor->selection->time[_editor->clicked_selection].start;
Drag::start_grab (event, cursor);
- _pointer_frame_offset = grab_frame() - start;
break;
}
if (_operation == SelectionMove) {
- _editor->show_verbose_time_cursor (start, 10);
+ _editor->show_verbose_time_cursor (_editor->selection->time[_editor->clicked_selection].start, 10);
} else {
_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
+SelectionDrag::setup_pointer_frame_offset ()
+{
+ switch (_operation) {
+ case CreateSelection:
+ _pointer_frame_offset = 0;
+ break;
+
+ case SelectionStartTrim:
+ case SelectionMove:
+ _pointer_frame_offset = raw_grab_frame() - _editor->selection->time[_editor->clicked_selection].start;
+ break;
+
+ case SelectionEndTrim:
+ _pointer_frame_offset = raw_grab_frame() - _editor->selection->time[_editor->clicked_selection].end;
+ break;
+ }
+}
+
void
SelectionDrag::motion (GdkEvent* event, bool first_move)
{
- nframes64_t start = 0;
- nframes64_t end = 0;
- nframes64_t length;
+ framepos_t start = 0;
+ framepos_t end = 0;
+ framecnt_t length;
pair<TimeAxisView*, int> const pending_time_axis = _editor->trackview_by_y_position (_drags->current_pointer_y ());
if (pending_time_axis.first == 0) {
return;
}
- nframes64_t const pending_position = adjusted_current_frame (event);
+ framepos_t const pending_position = adjusted_current_frame (event);
/* only alter selection if things have changed */
switch (_operation) {
case CreateSelection:
{
- nframes64_t grab = grab_frame ();
+ framepos_t grab = grab_frame ();
if (first_move) {
_editor->snap_to (grab);
if (_copy) {
/* adding to the selection */
- _editor->selection->add (_editor->clicked_axisview);
+ _editor->set_selected_track_as_side_effect (Selection::Add);
+ //_editor->selection->add (_editor->clicked_axisview);
_editor->clicked_selection = _editor->selection->add (start, end);
_copy = false;
} else {
/* new selection */
if (_editor->clicked_axisview && !_editor->selection->selected (_editor->clicked_axisview)) {
- _editor->selection->set (_editor->clicked_axisview);
+ //_editor->selection->set (_editor->clicked_axisview);
+ _editor->set_selected_track_as_side_effect (Selection::Set);
}
_editor->clicked_selection = _editor->selection->set (start, end);
/* 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->set_selected_track_as_side_effect (Selection::Add);
_editor->selection->add (pending_time_axis.first);
_added_time_axes.push_back (pending_time_axis.first);
}
}
void
-SelectionDrag::aborted ()
+SelectionDrag::aborted (bool)
{
/* XXX: TODO */
}
_operation (o),
_copy (false)
{
- _drag_rect = new ArdourCanvas::SimpleRect (*_editor->time_line_group, 0.0, 0.0, 0.0, _editor->physical_screen_height);
+ DEBUG_TRACE (DEBUG::Drags, "New RangeMarkerBarDrag\n");
+
+ _drag_rect = new ArdourCanvas::SimpleRect (*_editor->time_line_group, 0.0, 0.0, 0.0,
+ physical_screen_height (_editor->get_window()));
_drag_rect->hide ();
_drag_rect->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_RangeDragRect.get();
Gdk::Cursor* cursor = 0;
if (!_editor->temp_location) {
- _editor->temp_location = new Location;
+ _editor->temp_location = new Location (*_editor->session());
}
switch (_operation) {
} else {
_copy = false;
}
- cursor = _editor->selector_cursor;
+ cursor = _editor->cursors()->selector;
break;
}
void
RangeMarkerBarDrag::motion (GdkEvent* event, bool first_move)
{
- nframes64_t start = 0;
- nframes64_t end = 0;
+ framepos_t start = 0;
+ framepos_t end = 0;
ArdourCanvas::SimpleRect *crect;
switch (_operation) {
break;
}
- nframes64_t const pf = adjusted_current_frame (event);
+ framepos_t const pf = adjusted_current_frame (event);
if (_operation == CreateRangeMarker || _operation == CreateTransportMarker || _operation == CreateCDMarker) {
- nframes64_t grab = grab_frame ();
+ framepos_t grab = grab_frame ();
_editor->snap_to (grab);
if (pf < grab_frame()) {
flags = Location::IsRangeMarker;
_editor->range_bar_drag_rect->hide();
}
- newloc = new Location(_editor->temp_location->start(), _editor->temp_location->end(), rangename, (Location::Flags) flags);
+ newloc = new Location (
+ *_editor->session(), _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<Locations>(*(_editor->session()->locations()), &before, &after));
if (Keyboard::no_modifier_keys_pressed (&event->button) && _operation != CreateCDMarker) {
- nframes64_t start;
- nframes64_t end;
+ framepos_t start;
+ framepos_t end;
_editor->session()->locations()->marks_either_side (grab_frame(), start, end);
- if (end == max_frames) {
+ if (end == max_framepos) {
end = _editor->session()->current_end_frame ();
}
- if (start == max_frames) {
+ if (start == max_framepos) {
start = _editor->session()->current_start_frame ();
}
switch (_editor->mouse_mode) {
case MouseObject:
/* find the two markers on either side and then make the selection from it */
- _editor->select_all_within (start, end, 0.0f, FLT_MAX, _editor->track_views, Selection::Set);
+ _editor->select_all_within (start, end, 0.0f, FLT_MAX, _editor->track_views, Selection::Set, false);
break;
case MouseRange:
}
void
-RangeMarkerBarDrag::aborted ()
+RangeMarkerBarDrag::aborted (bool)
{
/* XXX: TODO */
}
_drag_rect->property_x2() = x2;
}
+MouseZoomDrag::MouseZoomDrag (Editor* e, ArdourCanvas::Item* i)
+ : Drag (e, i)
+ , _zoom_out (false)
+{
+ DEBUG_TRACE (DEBUG::Drags, "New MouseZoomDrag\n");
+}
+
void
MouseZoomDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
{
- Drag::start_grab (event, _editor->zoom_cursor);
+ if (Keyboard::the_keyboard().key_is_down (GDK_Control_L)) {
+ Drag::start_grab (event, _editor->cursors()->zoom_out);
+ _zoom_out = true;
+ } else {
+ Drag::start_grab (event, _editor->cursors()->zoom_in);
+ _zoom_out = false;
+ }
+
_editor->show_verbose_time_cursor (adjusted_current_frame (event), 10);
}
void
MouseZoomDrag::motion (GdkEvent* event, bool first_move)
{
- nframes64_t start;
- nframes64_t end;
+ framepos_t start;
+ framepos_t end;
- nframes64_t const pf = adjusted_current_frame (event);
+ framepos_t const pf = adjusted_current_frame (event);
- nframes64_t grab = grab_frame ();
+ framepos_t grab = grab_frame ();
_editor->snap_to_with_modifier (grab, event);
/* base start and end on initial click position */
_editor->temporal_zoom_by_frame (last_pointer_frame(), grab_frame(), "mouse zoom");
}
} else {
- _editor->temporal_zoom_to_frame (false, grab_frame());
- /*
- temporal_zoom_step (false);
- center_screen (grab_frame());
- */
+ _editor->temporal_zoom_to_frame (_zoom_out, grab_frame());
}
_editor->zoom_rect->hide();
}
void
-MouseZoomDrag::aborted ()
+MouseZoomDrag::aborted (bool)
{
_editor->zoom_rect->hide ();
}
NoteDrag::NoteDrag (Editor* e, ArdourCanvas::Item* i)
: Drag (e, i)
+ , _cumulative_dx (0)
+ , _cumulative_dy (0)
{
- CanvasNoteEvent* cnote = dynamic_cast<CanvasNoteEvent*>(_item);
- region = &cnote->region_view();
+ DEBUG_TRACE (DEBUG::Drags, "New NoteDrag\n");
+
+ _primary = dynamic_cast<CanvasNoteEvent*> (_item);
+ _region = &_primary->region_view ();
+ _note_height = _region->midi_stream_view()->note_height ();
}
void
{
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<CanvasNoteEvent*>(_item);
-
- if (!(was_selected = cnote->selected())) {
+ if (!(_was_selected = _primary->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
bool add = Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier);
if (add) {
- region->note_selected (cnote, true);
+ _region->note_selected (_primary, true);
} else {
- region->unique_select (cnote);
+ _region->unique_select (_primary);
}
}
}
}
-void
-NoteDrag::motion (GdkEvent*, bool)
+/** @return Current total drag x change in frames */
+frameoffset_t
+NoteDrag::total_dx () const
{
- 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);
+ /* dx in frames */
+ frameoffset_t const dx = _editor->unit_to_frame (_drags->current_pointer_x() - grab_x());
- event_x = region->snap_to_pixel(event_x);
+ /* primary note time */
+ frameoffset_t const n = _region->beats_to_frames (_primary->note()->time ());
+
+ /* new time of the primary note relative to the region position */
+ frameoffset_t const st = n + dx;
- double dx = event_x - last_x;
- double dy = event_y - last_y;
- last_x = event_x;
+ /* snap and return corresponding delta */
+ return _region->snap_frame_to_frame (st) - n;
+}
- drag_delta_x += dx;
+/** @return Current total drag y change in notes */
+int8_t
+NoteDrag::total_dy () const
+{
+ /* this is `backwards' to make increasing note number go in the right direction */
+ double const dy = _drags->current_pointer_y() - grab_y();
- // Snap to note rows
+ /* dy in notes */
+ int8_t ndy = 0;
- if (abs (dy) < streamview->note_height()) {
- dy = 0.0;
- } else {
- int8_t this_delta_note;
+ if (abs (dy) >= _note_height) {
if (dy > 0) {
- this_delta_note = (int8_t)ceil(dy / streamview->note_height() / 2.0);
+ ndy = (int8_t) ceil (dy / _note_height / 2.0);
} else {
- this_delta_note = (int8_t)floor(dy / streamview->note_height() / 2.0);
+ ndy = (int8_t) floor (dy / _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) {
-
- CanvasNoteEvent* cnote = dynamic_cast<CanvasNoteEvent*>(_item);
- Evoral::MusicalTime new_time;
-
- if (drag_delta_x) {
- nframes64_t start_frames = region->beats_to_frames(cnote->note()->time());
- if (drag_delta_x >= 0) {
- start_frames += region->snap_frame_to_frame(_editor->pixel_to_frame(drag_delta_x));
- } else {
- start_frames -= region->snap_frame_to_frame(_editor->pixel_to_frame(-drag_delta_x));
- }
- new_time = region->frames_to_beats(start_frames);
- } else {
- new_time = cnote->note()->time();
- }
+ /* more positive value = higher pitch and higher y-axis position on track,
+ which is the inverse of the X-centric geometric universe
+ */
+
+ return -ndy;
+}
+
+void
+NoteDrag::motion (GdkEvent *, bool)
+{
+ /* Total change in x and y since the start of the drag */
+ frameoffset_t const dx = total_dx ();
+ int8_t const dy = -total_dy ();
+
+ /* Now work out what we have to do to the note canvas items to set this new drag delta */
+ double const tdx = _editor->frame_to_unit (dx) - _cumulative_dx;
+ double const tdy = dy * _note_height - _cumulative_dy;
+
+ if (tdx || tdy) {
+ _cumulative_dx += tdx;
+ _cumulative_dy += tdy;
+
+ int8_t note_delta = total_dy();
+
+ _region->move_selection (tdx, tdy, note_delta);
+
+ char buf[12];
+ snprintf (buf, sizeof (buf), "%s (%d)", Evoral::midi_note_name (_primary->note()->note() + note_delta).c_str(),
+ (int) floor (_primary->note()->note() + note_delta));
- boost::shared_ptr<Evoral::Note<Evoral::MusicalTime> > check_note (
- new Evoral::Note<Evoral::MusicalTime> (cnote->note()->channel(),
- new_time,
- cnote->note()->length(),
- cnote->note()->note() + drag_delta_note,
- cnote->note()->velocity()));
-
- region->move_selection (dx, dy);
-
- char buf[12];
- snprintf (buf, sizeof (buf), "%s (%d)", Evoral::midi_note_name (cnote->note()->note()).c_str(),
- (int) floor ((cnote->note()->note() + drag_delta_note)));
_editor->show_verbose_canvas_cursor_with (buf);
- }
+ }
}
void
NoteDrag::finished (GdkEvent* ev, bool moved)
{
- ArdourCanvas::CanvasNote* cnote = dynamic_cast<ArdourCanvas::CanvasNote*>(_item);
-
if (!moved) {
if (_editor->current_mouse_mode() == Editing::MouseObject) {
- if (was_selected) {
+ if (_was_selected) {
bool add = Keyboard::modifier_state_equals (ev->button.state, Keyboard::PrimaryModifier);
if (add) {
- region->note_deselected (cnote);
+ _region->note_deselected (_primary);
}
} 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);
+ if (!extend && !add && _region->selection_size() > 1) {
+ _region->unique_select (_primary);
} else if (extend) {
- region->note_selected (cnote, true, true);
+ _region->note_selected (_primary, true, true);
} else {
/* it was added during button press */
}
}
}
} else {
- region->note_dropped (cnote, drag_delta_x, drag_delta_note);
+ _region->note_dropped (_primary, total_dx(), total_dy());
}
}
void
-NoteDrag::aborted ()
+NoteDrag::aborted (bool)
{
/* XXX: TODO */
}
-AutomationRangeDrag::AutomationRangeDrag (Editor* e
, ArdourCanvas::Item* i, list<AudioRange> const & r)
- : Drag (e, i)
+AutomationRangeDrag::AutomationRangeDrag (Editor* e
ditor, ArdourCanvas::Item* item, list<AudioRange> const & r)
+ : Drag (editor, item)
, _ranges (r)
, _nothing_to_drag (false)
{
+ DEBUG_TRACE (DEBUG::Drags, "New AutomationRangeDrag\n");
+
_atav = reinterpret_cast<AutomationTimeAxisView*> (_item->get_data ("trackview"));
assert (_atav);
- _line = _atav->line ();
+ /* get all lines in the automation view */
+ list<boost::shared_ptr<AutomationLine> > lines = _atav->lines ();
+
+ /* find those that overlap the ranges being dragged */
+ list<boost::shared_ptr<AutomationLine> >::iterator i = lines.begin ();
+ while (i != lines.end ()) {
+ list<boost::shared_ptr<AutomationLine> >::iterator j = i;
+ ++j;
+
+ pair<framepos_t, framepos_t> const r = (*i)->get_point_x_range ();
+
+ /* check this range against all the AudioRanges that we are using */
+ list<AudioRange>::const_iterator k = _ranges.begin ();
+ while (k != _ranges.end()) {
+ if (k->coverage (r.first, r.second) != OverlapNone) {
+ break;
+ }
+ ++k;
+ }
+
+ /* add it to our list if it overlaps at all */
+ if (k != _ranges.end()) {
+ Line n;
+ n.line = *i;
+ n.state = 0;
+ n.range = r;
+ _lines.push_back (n);
+ }
+
+ i = j;
+ }
+
+ /* Now ::lines contains the AutomationLines that somehow overlap our drag */
}
void
{
Drag::start_grab (event, cursor);
- list<ControlPoint*> points;
+ /* Get line states before we start changing things */
+ for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
+ i->state = &i->line->get_state ();
+ }
- 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));
+
+ /* No selected time ranges: drag all points */
+ for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
+ uint32_t const N = i->line->npoints ();
+ for (uint32_t j = 0; j < N; ++j) {
+ i->points.push_back (i->line->nth (j));
+ }
}
} else {
- boost::shared_ptr<AutomationList> the_list = _line->the_list ();
- for (list<AudioRange>::const_iterator j = _ranges.begin(); j != _ranges.end(); ++j) {
+ for (list<AudioRange>::const_iterator i = _ranges.begin(); i != _ranges.end(); ++i) {
- /* 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;
+ framecnt_t const half = (i->start + i->end) / 2;
+
+ /* find the line that this audio range starts in */
+ list<Line>::iterator j = _lines.begin();
+ while (j != _lines.end() && (j->range.first > i->start || j->range.second < i->start)) {
+ ++j;
}
- nframes64_t b = j->end - 64;
- if (b < h) {
- b = h;
+
+ if (j != _lines.end()) {
+ boost::shared_ptr<AutomationList> the_list = j->line->the_list ();
+
+ /* j is the line that this audio range starts in; fade into it;
+ 64 samples length plucked out of thin air.
+ */
+
+ framepos_t a = i->start + 64;
+ if (a > half) {
+ a = half;
+ }
+
+ double const p = j->line->time_converter().from (i->start - j->line->time_converter().origin_b ());
+ double const q = j->line->time_converter().from (a - j->line->time_converter().origin_b ());
+
+ the_list->add (p, the_list->eval (p));
+ j->line->add_always_in_view (p);
+ the_list->add (q, the_list->eval (q));
+ j->line->add_always_in_view (q);
}
+
+ /* same thing for the end */
- 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);
+ j = _lines.begin();
+ while (j != _lines.end() && (j->range.first > i->end || j->range.second < i->end)) {
+ ++j;
+ }
+
+ if (j != _lines.end()) {
+ boost::shared_ptr<AutomationList> the_list = j->line->the_list ();
+
+ /* j is the line that this audio range starts in; fade out of it;
+ 64 samples length plucked out of thin air.
+ */
+
+ framepos_t b = i->end - 64;
+ if (b < half) {
+ b = half;
+ }
+
+ double const p = j->line->time_converter().from (b - j->line->time_converter().origin_b ());
+ double const q = j->line->time_converter().from (i->end - j->line->time_converter().origin_b ());
+
+ the_list->add (p, the_list->eval (p));
+ j->line->add_always_in_view (p);
+ the_list->add (q, the_list->eval (q));
+ j->line->add_always_in_view (q);
+ }
}
- uint32_t const N = _line->npoints ();
- for (uint32_t i = 0; i < N; ++i) {
+ _nothing_to_drag = true;
+
+ /* Find all the points that should be dragged and put them in the relevant
+ points lists in the Line structs.
+ */
- ControlPoint* p = _line->nth (i);
+ for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
- list<AudioRange>::const_iterator j = _ranges.begin ();
- while (j != _ranges.end() && (j->start >= (*p->model())->when || j->end <= (*p->model())->when)) {
- ++j;
- }
+ uint32_t const N = i->line->npoints ();
+ for (uint32_t j = 0; j < N; ++j) {
+
+ /* here's a control point on this line */
+ ControlPoint* p = i->line->nth (j);
+ double const w = i->line->time_converter().to ((*p->model())->when) + i->line->time_converter().origin_b ();
- if (j != _ranges.end()) {
- points.push_back (p);
+ /* see if it's inside a range */
+ list<AudioRange>::const_iterator k = _ranges.begin ();
+ while (k != _ranges.end() && (k->start >= w || k->end <= w)) {
+ ++k;
+ }
+
+ if (k != _ranges.end()) {
+ /* dragging this point */
+ _nothing_to_drag = false;
+ i->points.push_back (p);
+ }
}
}
}
- if (points.empty()) {
- _nothing_to_drag = true;
+ if (_nothing_to_drag) {
return;
}
- _line->start_drag_multiple (points, 1 - (_drags->current_pointer_y() / _line->height ()), state);
+ for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
+ i->line->start_drag_multiple (i->points, 1 - (_drags->current_pointer_y() / i->line->height ()), i->state);
+ }
}
void
-AutomationRangeDrag::motion (GdkEvent* event, bool first_move)
+AutomationRangeDrag::motion (GdkEvent*, 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);
+ for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
+ float const f = 1 - (_drags->current_pointer_y() / i->line->height());
+
+ /* we are ignoring x position for this drag, so we can just pass in anything */
+ i->line->drag_motion (0, f, true, false);
+ }
}
void
}
motion (event, false);
- _line->end_drag ();
- _line->clear_always_in_view ();
+ for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
+ i->line->end_drag ();
+ i->line->clear_always_in_view ();
+ }
+
+ _editor->session()->commit_reversible_command ();
}
void
-AutomationRangeDrag::aborted ()
+AutomationRangeDrag::aborted (bool)
{
- _line->clear_always_in_view ();
- _line->reset ();
+ for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
+ i->line->clear_always_in_view ();
+ i->line->reset ();
+ }
}
-DraggingView::DraggingView (RegionView* v)
+DraggingView::DraggingView (RegionView* v, RegionDrag* parent)
: view (v)
{
+ time_axis_view = parent->find_time_axis_view (&v->get_time_axis_view ());
+ layer = v->region()->layer ();
initial_y = v->get_canvas_group()->property_y ();
+ initial_playlist = v->region()->playlist ();
+ initial_position = v->region()->position ();
+ initial_end = v->region()->position () + v->region()->length ();
+}
+
+PatchChangeDrag::PatchChangeDrag (Editor* e, CanvasPatchChange* i, MidiRegionView* r)
+ : Drag (e, i)
+ , _region_view (r)
+ , _patch_change (i)
+ , _cumulative_dx (0)
+{
+ DEBUG_TRACE (DEBUG::Drags, "New PatchChangeDrag\n");
+}
+
+void
+PatchChangeDrag::motion (GdkEvent* ev, bool)
+{
+ framepos_t f = adjusted_current_frame (ev);
+ boost::shared_ptr<Region> r = _region_view->region ();
+ f = max (f, r->position ());
+ f = min (f, r->last_frame ());
+
+ framecnt_t const dxf = f - grab_frame();
+ double const dxu = _editor->frame_to_unit (dxf);
+ _patch_change->move (dxu - _cumulative_dx, 0);
+ _cumulative_dx = dxu;
+}
+
+void
+PatchChangeDrag::finished (GdkEvent* ev, bool movement_occurred)
+{
+ if (!movement_occurred) {
+ return;
+ }
+
+ boost::shared_ptr<Region> r (_region_view->region ());
+
+ framepos_t f = adjusted_current_frame (ev);
+ f = max (f, r->position ());
+ f = min (f, r->last_frame ());
+
+ _region_view->move_patch_change (
+ *_patch_change,
+ _region_view->frames_to_beats (f - r->position() - r->start())
+ );
+}
+
+void
+PatchChangeDrag::aborted (bool)
+{
+ _patch_change->move (-_cumulative_dx, 0);
+}
+
+void
+PatchChangeDrag::setup_pointer_frame_offset ()
+{
+ boost::shared_ptr<Region> region = _region_view->region ();
+ _pointer_frame_offset = raw_grab_frame() - _region_view->beats_to_frames (_patch_change->patch()->time()) - region->position() + region->start();
}
+
projects / ardour.git / blobdiff