{
_ending = true;
- cerr << "Aborting drag\n";
-
for (list<Drag*>::const_iterator i = _drags.begin(); i != _drags.end(); ++i) {
(*i)->abort ();
delete *i;
: _editor (e)
, _item (i)
, _pointer_frame_offset (0)
+ , _x_constrained (false)
+ , _y_constrained (false)
, _trackview_only (trackview_only)
, _move_threshold_passed (false)
, _starting_point_passed (false)
, _raw_grab_frame (0)
, _grab_frame (0)
, _last_pointer_frame (0)
+ , _snap_delta (0)
{
}
void
Drag::start_grab (GdkEvent* event, Gdk::Cursor *cursor)
{
- // if dragging with button2, the motion is x constrained, with Alt-button2 it is y constrained
- if (Keyboard::is_button2_event (&event->button)) {
- if (Keyboard::modifier_state_equals (event->button.state, Keyboard::SecondaryModifier)) {
- _y_constrained = true;
- _x_constrained = false;
- } else {
- _y_constrained = false;
- _x_constrained = true;
- }
- } else {
- _x_constrained = false;
- _y_constrained = false;
- }
+ /* we set up x/y dragging constraints on first move */
_raw_grab_frame = _editor->canvas_event_sample (event, &_grab_x, &_grab_y);
+
setup_pointer_frame_offset ();
_grab_frame = adjusted_frame (_raw_grab_frame, event);
_last_pointer_frame = _grab_frame;
return adjusted_frame (_drags->current_pointer_frame (), event, snap);
}
+frameoffset_t
+Drag::snap_delta (guint state) const
+{
+ if (ArdourKeyboard::indicates_snap_delta (state)) {
+ return _snap_delta;
+ }
+
+ return 0;
+}
+
double
Drag::current_pointer_x() const
{
return _drags->current_pointer_y () - _editor->get_trackview_group()->canvas_origin().y;
}
+void
+Drag::setup_snap_delta (framepos_t pos)
+{
+ framepos_t temp = pos;
+ _editor->snap_to (temp, ARDOUR::RoundNearest, false, true);
+ _snap_delta = temp - pos;
+}
+
bool
Drag::motion_handler (GdkEvent* event, bool from_autoscroll)
{
} else {
_initially_vertical = false;
}
+ /** check constraints for this drag.
+ * Note that the current convention is to use "contains" for
+ * key modifiers during motion and "equals" when initiating a drag.
+ * In this case we haven't moved yet, so "equals" applies here.
+ */
+ if (Config->get_edit_mode() != Lock) {
+ if (event->motion.state & Gdk::BUTTON2_MASK) {
+ // if dragging with button2, the motion is x constrained, with constraint modifier it is y constrained
+ if (Keyboard::modifier_state_equals (event->button.state, ArdourKeyboard::constraint_modifier ())) {
+ _x_constrained = false;
+ _y_constrained = true;
+ } else {
+ _x_constrained = true;
+ _y_constrained = false;
+ }
+ } else if (Keyboard::modifier_state_equals (event->button.state, ArdourKeyboard::constraint_modifier ())) {
+ // if dragging normally, the motion is constrained to the first direction of movement.
+ if (_initially_vertical) {
+ _x_constrained = true;
+ _y_constrained = false;
+ } else {
+ _x_constrained = false;
+ _y_constrained = true;
+ }
+ }
+ } else {
+ if (event->button.state & Gdk::BUTTON2_MASK) {
+ _x_constrained = false;
+ } else {
+ _x_constrained = true;
+ }
+ _y_constrained = false;
+ }
}
if (!from_autoscroll) {
};
RegionDrag::RegionDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v)
- : Drag (e, i),
- _primary (p)
+ : Drag (e, i)
+ , _primary (p)
+ , _ntracks (0)
{
_editor->visible_order_range (&_visible_y_low, &_visible_y_high);
, _total_x_delta (0)
, _last_pointer_time_axis_view (0)
, _last_pointer_layer (0)
- , _single_axis (false)
+ , _ndropzone (0)
+ , _pdropzone (0)
+ , _ddropzone (0)
{
DEBUG_TRACE (DEBUG::Drags, "New RegionMotionDrag\n");
}
RegionMotionDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
{
Drag::start_grab (event, cursor);
-
- if (Keyboard::modifier_state_contains (event->button.state, Keyboard::TertiaryModifier)) {
- _single_axis = true;
- }
+ setup_snap_delta (_last_frame_position);
show_verbose_cursor_time (_last_frame_position);
assert(_last_pointer_time_axis_view >= 0);
_last_pointer_layer = tv.first->layer_display() == Overlaid ? 0 : tv.second;
}
+
+ if (_brushing) {
+ /* cross track dragging seems broken here. disabled for now. */
+ _y_constrained = true;
+ }
}
double
/* 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);
+ *pending_region_position = adjusted_frame (_drags->current_pointer_frame () + snap_delta (event->button.state), event, true);
framepos_t sync_frame;
framecnt_t sync_offset;
*/
if (sync_dir >= 0 || (sync_dir < 0 && *pending_region_position >= sync_offset)) {
- sync_frame = *pending_region_position + (sync_dir*sync_offset);
+ sync_frame = *pending_region_position + (sync_dir * sync_offset);
_editor->snap_to_with_modifier (sync_frame, event);
- *pending_region_position = _primary->region()->adjust_to_sync (sync_frame);
+ *pending_region_position = _primary->region()->adjust_to_sync (sync_frame) - snap_delta (event->button.state);
} else {
*pending_region_position = _last_frame_position;
double dx = 0;
- /* 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;
+ bool const x_move_allowed = !_x_constrained;
if ((*pending_region_position != _last_frame_position) && x_move_allowed) {
}
int
-RegionDrag::apply_track_delta (const int start, const int delta, const int skip) const
+RegionDrag::apply_track_delta (const int start, const int delta, const int skip, const bool distance_only) const
{
if (delta == 0) {
return start;
}
+ const int tavsize = _time_axis_views.size();
const int dt = delta > 0 ? +1 : -1;
- int current = start;
- int target = start + delta - skip;
+ int current = start;
+ int target = start + delta - skip;
- assert (current < 0 || current >= _time_axis_views.size() || !_time_axis_views[current]->hidden());
+ assert (current < 0 || current >= tavsize || !_time_axis_views[current]->hidden());
assert (skip == 0 || (skip < 0 && delta < 0) || (skip > 0 && delta > 0));
-#ifdef DEBUG_DROPZONEDRAG
- if (current >= _time_axis_views.size() && target >= 0 && target < _time_axis_views.size()) {
- printf("MOVE OUT OF THE ZONE cur: %d d: %d s: %d\n", start, delta, skip);
- }
-#endif
-
while (current >= 0 && current != target) {
current += dt;
- if (current < 0 || current >= _time_axis_views.size()) {
+ if (current < 0 && dt < 0) {
+ break;
+ }
+ if (current >= tavsize && dt > 0) {
+ break;
+ }
+ if (current < 0 || current >= tavsize) {
continue;
}
- if (_time_axis_views[current]->hidden()) {
+
+ RouteTimeAxisView const * rtav = dynamic_cast<RouteTimeAxisView const *> (_time_axis_views[current]);
+ if (_time_axis_views[current]->hidden() || !rtav || !rtav->is_track()) {
target += dt;
}
+
+ if (distance_only && current == start + delta) {
+ break;
+ }
}
return target;
}
return false;
}
+ const int tavsize = _time_axis_views.size();
for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
int n = apply_track_delta (i->time_axis_view, delta_track, skip_invisible);
-#ifdef DEBUG_DROPZONEDRAG
- printf("Y MOVEMENT CHECK: from %d to %d skip: %d\n", i->time_axis_view, i->time_axis_view + delta_track, skip_invisible);
-#endif
- assert (n < 0 || n >= _time_axis_views.size() || !_time_axis_views[n]->hidden());
+ assert (n < 0 || n >= tavsize || !_time_axis_views[n]->hidden());
- if (i->time_axis_view < 0 || i->time_axis_view >= _time_axis_views.size()) {
+ if (i->time_axis_view < 0 || i->time_axis_view >= tavsize) {
/* already in the drop zone */
if (delta_track >= 0) {
- /* downward motion - might be OK if others are still not in the dropzone,
- so check at the end of the loop if that is the case.
- */
+ /* downward motion - OK if others are still not in the dropzone */
continue;
}
- /* upward motion - set n to the track we would end up in if motion
- is successful, and check validity below. */
- n = _time_axis_views.size() + delta_track;
}
if (n < 0) {
/* off the top */
return false;
- } else if (n >= int (_time_axis_views.size())) {
+ } else if (n >= tavsize) {
/* downward motion into drop zone. That's fine. */
continue;
}
return true;
}
+struct DraggingViewSorter {
+ bool operator() (const DraggingView& a, const DraggingView& b) {
+ return a.time_axis_view < b.time_axis_view;
+ }
+};
+
void
RegionMotionDrag::motion (GdkEvent* event, bool first_move)
{
assert (!_views.empty ());
- if (first_move) {
- if (_single_axis) {
- if (initially_vertical()) {
- _y_constrained = false;
- _x_constrained = true;
- } else {
- _y_constrained = true;
- _x_constrained = false;
- }
- }
- }
-
-#ifdef DEBUG_DROPZONEDRAG
- printf("--------- LAST AXIS: %d\n", _last_pointer_time_axis_view);
-#endif
/* Note: time axis views in this method are often expressed as an index into the _time_axis_views vector */
/* Find the TimeAxisView that the pointer is now over */
-
- pair<TimeAxisView*, double> const r = _editor->trackview_by_y_position (current_pointer_y ());
+ const double cur_y = current_pointer_y ();
+ pair<TimeAxisView*, double> const r = _editor->trackview_by_y_position (cur_y);
TimeAxisView* tv = r.first;
- if (!tv && current_pointer_y() < 0) {
+ if (!tv && cur_y < 0) {
/* above trackview area, autoscroll hasn't moved us since last time, nothing to do */
return;
}
+ /* find drop-zone y-position */
+ Coord last_track_bottom_edge;
+ last_track_bottom_edge = 0;
+ for (std::vector<TimeAxisView*>::reverse_iterator t = _time_axis_views.rbegin(); t != _time_axis_views.rend(); ++t) {
+ if (!(*t)->hidden()) {
+ last_track_bottom_edge = (*t)->canvas_display()->canvas_origin ().y + (*t)->effective_height();
+ break;
+ }
+ }
+
if (tv && tv->view()) {
+ /* the mouse is over a track */
double layer = r.second;
if (first_move && tv->view()->layer_display() == Stacked) {
/* Work out the change in y */
- if (_last_pointer_time_axis_view < 0) {
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tv);
+ if (!rtv || !rtv->is_track()) {
+ /* ignore busses early on. we can't move any regions on them */
+ } else if (_last_pointer_time_axis_view < 0) {
/* Was in the drop-zone, now over a track.
* Hence it must be an upward move (from the bottom)
*
* move up the correct number of tracks from the bottom.
*
* This is necessary because steps may be skipped if
- * the bottom-most track is not a valid target,
+ * the bottom-most track is not a valid target and/or
+ * if there are hidden tracks at the bottom.
+ * Hence the initial offset (_ddropzone) as well as the
+ * last valid pointer position (_pdropzone) need to be
+ * taken into account.
*/
-#ifdef DEBUG_DROPZONEDRAG
- printf("MOVE OUT OF THE ZONE...\n");
-#endif
- delta_time_axis_view = current_pointer_time_axis_view - _time_axis_views.size ();
+ delta_time_axis_view = current_pointer_time_axis_view - _time_axis_views.size () + _ddropzone - _pdropzone;
} else {
delta_time_axis_view = current_pointer_time_axis_view - _last_pointer_time_axis_view;
}
delta_layer = current_pointer_layer - _last_pointer_layer;
}
- /* for automation lanes, there is a TimeAxisView but no ->view() */
- else if (!tv && current_pointer_y() >= 0 && _last_pointer_time_axis_view >= 0) {
- /* Moving into the drop-zone..
- *
- * TODO allow moving further down in drop-zone:
- * e.g. 2 Tracks, select a region on both of them.
- *
- * A) grab the upper, drag 2 down, both regions are in the dropzone: all fine (works)
- *
- * B) grab the lower, drag 1 down, region (and mouse) are in dropzone, The End.
- * upper region is only down one track and cannot be moved into the zone.
- *
- * Proposed solution:
- * keep track of how many regions are in the DZ (private var),
- * also count from how many tracks the dragged-regions come from (first move)
- *
- * if not all regions are in the DZ, keep going.
+ /* for automation lanes, there is a TimeAxisView but no ->view()
+ * if (!tv) -> dropzone
+ */
+ else if (!tv && cur_y >= 0 && _last_pointer_time_axis_view >= 0) {
+ /* Moving into the drop-zone.. */
+ delta_time_axis_view = _time_axis_views.size () - _last_pointer_time_axis_view;
+ /* delta_time_axis_view may not be sufficient to move into the DZ
+ * the mouse may enter it, but it may not be a valid move due to
+ * constraints.
*
- * Using 'default height' H for all dropzone regions will make things
- * a lot simpler: (number_of_DZ_entries * H + Pointer_YPOS - DZ_YPOS) / H.
- * (because at this point in time PlaylistDropzoneMap is not yet populated)
+ * -> remember the delta needed to move into the dropzone
*/
- delta_time_axis_view = _time_axis_views.size () - _last_pointer_time_axis_view;
-#ifdef DEBUG_DROPZONEDRAG
- printf("INTO THE ZONE DELTA: %d\n", delta_time_axis_view);
-#endif
+ _ddropzone = delta_time_axis_view;
+ /* ..but subtract hidden tracks (or routes) at the bottom.
+ * we silently move mover them
+ */
+ _ddropzone -= apply_track_delta(_last_pointer_time_axis_view, delta_time_axis_view, 0, true)
+ - _time_axis_views.size();
+ }
+ else if (!tv && cur_y >= 0 && _last_pointer_time_axis_view < 0) {
+ /* move around inside the zone.
+ * This allows to move further down until all regions are in the zone.
+ */
+ const double ptr_y = cur_y + _editor->get_trackview_group()->canvas_origin().y;
+ assert(ptr_y >= last_track_bottom_edge);
+ assert(_ddropzone > 0);
+
+ /* calculate mouse position in 'tracks' below last track. */
+ const double dzi_h = TimeAxisView::preset_height (HeightNormal);
+ uint32_t dzpos = _ddropzone + floor((1 + ptr_y - last_track_bottom_edge) / dzi_h);
+
+ if (dzpos > _pdropzone && _ndropzone < _ntracks) {
+ // move further down
+ delta_time_axis_view = dzpos - _pdropzone;
+ } else if (dzpos < _pdropzone && _ndropzone > 0) {
+ // move up inside the DZ
+ delta_time_axis_view = dzpos - _pdropzone;
+ }
}
/* Work out the change in x */
double const x_delta = compute_x_delta (event, &pending_region_position);
_last_frame_position = pending_region_position;
- /* calculate hidden tracks in current delta */
+ /* calculate hidden tracks in current y-axis delta */
int delta_skip = 0;
- if (_last_pointer_time_axis_view < 0) {
- // Moving out of the zone, check for hidden tracks at the bottom.
- delta_skip = apply_track_delta(_time_axis_views.size(), delta_time_axis_view, 0)
+ if (_last_pointer_time_axis_view < 0 && _pdropzone > 0) {
+ /* The mouse is more than one track below the dropzone.
+ * distance calculation is not needed (and would not work, either
+ * because the dropzone is "packed").
+ *
+ * Except when [partially] moving regions out of dropzone in a large step.
+ * (the mouse may or may not remain in the DZ)
+ * Hidden tracks at the bottom of the TAV need to be skipped.
+ *
+ * This also handles the case if the mouse entered the DZ
+ * in a large step (exessive delta), either due to fast-movement,
+ * autoscroll, laggy UI. _ddropzone copensates for that (see "move into dz" above)
+ */
+ if (delta_time_axis_view < 0 && (int)_ddropzone - delta_time_axis_view >= (int)_pdropzone) {
+ const int dt = delta_time_axis_view + (int)_pdropzone - (int)_ddropzone;
+ assert(dt <= 0);
+ delta_skip = apply_track_delta(_time_axis_views.size(), dt, 0, true)
+ -_time_axis_views.size() - dt;
+ }
+ }
+ else if (_last_pointer_time_axis_view < 0) {
+ /* Moving out of the zone. Check for hidden tracks at the bottom. */
+ delta_skip = apply_track_delta(_time_axis_views.size(), delta_time_axis_view, 0, true)
-_time_axis_views.size() - delta_time_axis_view;
-#ifdef DEBUG_DROPZONEDRAG
- printf("NOW WHAT?? last: %d delta %d || skip %d\n", _last_pointer_time_axis_view, delta_time_axis_view, delta_skip);
-#endif
} else {
- // calculate hidden tracks that are skipped by the pointer movement
- delta_skip = apply_track_delta(_last_pointer_time_axis_view, delta_time_axis_view, 0)
+ /* calculate hidden tracks that are skipped by the pointer movement */
+ delta_skip = apply_track_delta(_last_pointer_time_axis_view, delta_time_axis_view, 0, true)
- _last_pointer_time_axis_view
- delta_time_axis_view;
-#ifdef DEBUG_DROPZONEDRAG
- printf("Drag from %d to %d || skip %d\n",
- _last_pointer_time_axis_view,
- _last_pointer_time_axis_view + delta_time_axis_view,
- delta_skip);
-#endif
}
/* Verify change in y */
delta_time_axis_view = 0;
delta_layer = 0;
delta_skip = 0;
-#ifdef DEBUG_DROPZONEDRAG
- printf(" ** NOT ALLOWED\n");
-#endif
}
if (x_delta == 0 && (tv && tv->view() && delta_time_axis_view == 0) && delta_layer == 0 && !first_move) {
return;
}
- typedef pair<int,double> NewTrackIndexAndPosition;
- typedef map<boost::shared_ptr<Playlist>,NewTrackIndexAndPosition> PlaylistDropzoneMap;
+ typedef map<boost::shared_ptr<Playlist>, double> PlaylistDropzoneMap;
PlaylistDropzoneMap playlist_dropzone_map;
- int biggest_drop_zone_offset = 0;
+ _ndropzone = 0; // number of elements currently in the dropzone
- /* find drop-zone y-position */
- Coord last_track_bottom_edge;
- last_track_bottom_edge = 0;
- for (std::vector<TimeAxisView*>::reverse_iterator t = _time_axis_views.rbegin(); t != _time_axis_views.rend(); ++t) {
- if (!(*t)->hidden()) {
- last_track_bottom_edge = (*t)->canvas_display()->canvas_origin ().y + (*t)->effective_height();
- break;
+ if (first_move) {
+ /* sort views by time_axis.
+ * This retains track order in the dropzone, regardless
+ * of actual selection order
+ */
+ _views.sort (DraggingViewSorter());
+
+ /* count number of distinct tracks of all regions
+ * being dragged, used for dropzone.
+ */
+ int prev_track = -1;
+ for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
+ if (i->time_axis_view != prev_track) {
+ prev_track = i->time_axis_view;
+ ++_ntracks;
+ }
}
+#ifndef NDEBUG
+ int spread =
+ _views.back().time_axis_view -
+ _views.front().time_axis_view;
+
+ spread -= apply_track_delta (_views.front().time_axis_view, spread, 0, true)
+ - _views.back().time_axis_view;
+
+ printf("Dragging region(s) from %d different track(s), max dist: %d\n", _ntracks, spread);
+#endif
}
for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
this_delta_layer = - i->layer;
}
- int this_delta_time_axis_view = delta_time_axis_view;
- this_delta_time_axis_view = apply_track_delta(i->time_axis_view, delta_time_axis_view, delta_skip) - i->time_axis_view;
+ int this_delta_time_axis_view = apply_track_delta(i->time_axis_view, delta_time_axis_view, delta_skip) - i->time_axis_view;
int track_index = i->time_axis_view + this_delta_time_axis_view;
assert(track_index >= 0);
if (track_index < 0 || track_index >= (int) _time_axis_views.size()) {
+ /* Track is in the Dropzone */
+
i->time_axis_view = track_index;
-#ifdef DEBUG_DROPZONEDRAG
- printf("IN THE ZONE\n");
-#endif
- assert(i->time_axis_view >= _time_axis_views.size());
- if (current_pointer_y() >= 0) {
+ assert(i->time_axis_view >= (int) _time_axis_views.size());
+ if (cur_y >= 0) {
- int dzoffset;
- NewTrackIndexAndPosition ip;
+ double yposition = 0;
PlaylistDropzoneMap::iterator pdz = playlist_dropzone_map.find (i->view->region()->playlist());
+ rv->set_height (TimeAxisView::preset_height (HeightNormal));
+ ++_ndropzone;
/* store index of each new playlist as a negative count, starting at -1 */
if (pdz == playlist_dropzone_map.end()) {
-
- /* TODO
- * retain the ordering top -> bottom in the drop-zone
- * this can be done by sorting the regions according to
- * i->time_axis_view Y, prior to iterating over DraggingView
- */
-
- int n = playlist_dropzone_map.size() + 1;
-
/* compute where this new track (which doesn't exist yet) will live
on the y-axis.
*/
-
- ip.first = -n; /* in time axis units, negative to signify "in drop zone " */
- ip.second = last_track_bottom_edge; /* where to place the top edge of the regionview */
+ yposition = last_track_bottom_edge; /* where to place the top edge of the regionview */
/* How high is this region view ? */
last_track_bottom_edge += bbox.height();
- playlist_dropzone_map.insert (make_pair (i->view->region()->playlist(), ip));
- dzoffset = -n;
+ playlist_dropzone_map.insert (make_pair (i->view->region()->playlist(), yposition));
} else {
- ip = pdz->second;
- dzoffset = ip.first;
+ yposition = pdz->second;
}
/* values are zero or negative, hence the use of min() */
- biggest_drop_zone_offset = min (biggest_drop_zone_offset, dzoffset);
- y_delta = ip.second - rv->get_canvas_group()->canvas_origin().y;
+ y_delta = yposition - rv->get_canvas_group()->canvas_origin().y;
}
} else {
show_verbose_cursor_time (_last_frame_position);
}
+ /* keep track of pointer movement */
if (tv) {
-
/* the pointer is currently over a time axis view */
if (_last_pointer_time_axis_view < 0) {
-
- /* last motion event was not over a time axis view */
-
+ /* last motion event was not over a time axis view
+ * or last y-movement out of the dropzone was not valid
+ */
+ int dtz = 0;
if (delta_time_axis_view < 0) {
- /* was in the drop zone, moving up */
+ /* in the drop zone, moving up */
+
+ /* _pdropzone is the last known pointer y-axis position inside the DZ.
+ * We do not use negative _last_pointer_time_axis_view because
+ * the dropzone is "packed" (the actual track offset is ignored)
+ *
+ * As opposed to the actual number
+ * of elements in the dropzone (_ndropzone)
+ * _pdropzone is not constrained. This is necessary
+ * to allow moving multiple regions with y-distance
+ * into the DZ.
+ *
+ * There can be 0 elements in the dropzone,
+ * even though the drag-pointer is inside the DZ.
+ *
+ * example:
+ * [ Audio-track, Midi-track, Audio-track, DZ ]
+ * move regions from both audio tracks at the same time into the
+ * DZ by grabbing the region in the bottom track.
+ */
assert(current_pointer_time_axis_view >= 0);
- _last_pointer_time_axis_view = current_pointer_time_axis_view;
- } else {
- /* was in the drop zone, moving down ... not possible */
+ dtz = std::min((int)_pdropzone, (int)_ddropzone - delta_time_axis_view);
+ _pdropzone -= dtz;
}
+ /* only move out of the zone if the movement is OK */
+ if (_pdropzone == 0 && delta_time_axis_view != 0) {
+ assert(delta_time_axis_view < 0);
+ _last_pointer_time_axis_view = current_pointer_time_axis_view;
+ /* if all logic and maths are correct, there is no need to assign the 'current' pointer.
+ * the current position can be calculated as follows:
+ */
+ // a well placed oofus attack can still throw this off.
+ // likley auto-scroll related, printf() debugging may tell, commented out for now.
+ //assert (current_pointer_time_axis_view == _time_axis_views.size() - dtz + _ddropzone + delta_time_axis_view);
+ }
} else {
-
/* last motion event was also over a time axis view */
-
_last_pointer_time_axis_view += delta_time_axis_view;
assert(_last_pointer_time_axis_view >= 0);
}
} else {
/* the pointer is not over a time axis view */
-
- _last_pointer_time_axis_view = biggest_drop_zone_offset;
+ assert ((delta_time_axis_view > 0) || (((int)_pdropzone) >= (delta_skip - delta_time_axis_view)));
+ _pdropzone += delta_time_axis_view - delta_skip;
+ _last_pointer_time_axis_view = -1; // <0 : we're in the zone, value does not matter.
}
_last_pointer_layer += delta_layer;
RegionMoveDrag::motion (GdkEvent* event, bool first_move)
{
if (_copy && first_move) {
-
- if (_x_constrained) {
+ if (_x_constrained && !_brushing) {
_editor->begin_reversible_command (Operations::fixed_time_region_copy);
- } else {
+ } else if (!_brushing) {
_editor->begin_reversible_command (Operations::region_copy);
+ } else if (_brushing) {
+ _editor->begin_reversible_command (Operations::drag_region_brush);
}
-
/* duplicate the regionview(s) and region(s) */
list<DraggingView> new_regionviews;
}
} else if (!_copy && first_move) {
-
- if (_x_constrained) {
+ if (_x_constrained && !_brushing) {
_editor->begin_reversible_command (_("fixed time region drag"));
- } else {
+ } else if (!_brushing) {
_editor->begin_reversible_command (Operations::region_drag);
+ } else if (_brushing) {
+ _editor->begin_reversible_command (Operations::drag_region_brush);
}
}
-
RegionMotionDrag::motion (event, first_move);
}
return;
}
- /* reverse this here so that we have the correct logic to finalize
- the drag.
- */
-
- if (Config->get_edit_mode() == Lock) {
- _x_constrained = !_x_constrained;
- }
-
assert (!_views.empty ());
/* We might have hidden region views so that they weren't visible during the drag
try {
if (boost::dynamic_pointer_cast<AudioRegion> (region)) {
list<boost::shared_ptr<AudioTrack> > audio_tracks;
- audio_tracks = _editor->session()->new_audio_track (region->n_channels(), region->n_channels(), ARDOUR::Normal, 0, 1, region->name());
+ uint32_t output_chan = region->n_channels();
+ if ((Config->get_output_auto_connect() & AutoConnectMaster) && _editor->session()->master_out()) {
+ output_chan = _editor->session()->master_out()->n_inputs().n_audio();
+ }
+ audio_tracks = _editor->session()->new_audio_track (region->n_channels(), output_chan, ARDOUR::Normal, 0, 1, region->name());
RouteTimeAxisView* rtav = _editor->axis_view_from_route (audio_tracks.front());
if (rtav) {
rtav->set_height (original->current_height());
where = i->view->region()->position();
}
- if (i->time_axis_view < 0 || i->time_axis_view >= _time_axis_views.size()) {
+ if (i->time_axis_view < 0 || i->time_axis_view >= (int)_time_axis_views.size()) {
/* dragged to drop zone */
PlaylistMapping::iterator pm;
set<RouteTimeAxisView*> views_to_update;
RouteTimeAxisView* new_time_axis_view = 0;
- if (_brushing) {
- /* all changes were made during motion event handlers */
- _editor->commit_reversible_command ();
- return;
- }
-
typedef map<boost::shared_ptr<Playlist>, RouteTimeAxisView*> PlaylistMapping;
PlaylistMapping playlist_mapping;
continue;
}
- if (i->time_axis_view < 0 || i->time_axis_view >= _time_axis_views.size()) {
+ if (i->time_axis_view < 0 || i->time_axis_view >= (int)_time_axis_views.size()) {
/* dragged to drop zone */
PlaylistMapping::iterator pm;
}
rv->region()->set_position (where);
-
_editor->session()->add_command (new StatefulDiffCommand (rv->region()));
}
/* write commands for the accumulated diffs for all our modified playlists */
add_stateful_diff_commands_for_playlists (modified_playlists);
-
+ /* applies to _brushing */
_editor->commit_reversible_command ();
/* We have futzed with the layering of canvas items on our streamviews.
RegionInsertDrag::finished (GdkEvent *, bool)
{
int pos = _views.front().time_axis_view;
- assert(pos >= 0 && pos < _time_axis_views.size());
+ assert(pos >= 0 && pos < (int)_time_axis_views.size());
RouteTimeAxisView* dest_rtv = dynamic_cast<RouteTimeAxisView*> (_time_axis_views[pos]);
NoteResizeDrag::NoteResizeDrag (Editor* e, ArdourCanvas::Item* i)
: Drag (e, i)
, region (0)
+ , relative (false)
+ , at_front (true)
+ , _snap_delta (0)
{
DEBUG_TRACE (DEBUG::Drags, "New NoteResizeDrag\n");
}
region = &cnote->region_view();
+ double temp;
+ temp = region->snap_to_pixel (cnote->x0 (), true);
+ _snap_delta = temp - cnote->x0 ();
+
_item->grab ();
- if (event->motion.state & Keyboard::PrimaryModifier) {
+ if (event->motion.state & ArdourKeyboard::note_size_relative_modifier ()) {
relative = false;
} else {
relative = true;
}
-
MidiRegionSelection& ms (_editor->get_selection().midi_regions);
-
if (ms.size() > 1) {
/* has to be relative, may make no sense otherwise */
relative = true;
}
-
/* select this note; if it is already selected, preserve the existing selection,
otherwise make this note the only one selected.
*/
region->note_selected (cnote, cnote->selected ());
-
- _editor->begin_reversible_command (_("resize notes"));
-
- for (MidiRegionSelection::iterator r = ms.begin(); r != ms.end(); ) {
- MidiRegionSelection::iterator next;
- next = r;
- ++next;
- MidiRegionView* mrv = dynamic_cast<MidiRegionView*>(*r);
- if (mrv) {
- mrv->begin_resizing (at_front);
- }
- r = next;
- }
}
void
-NoteResizeDrag::motion (GdkEvent* /*event*/, bool /*first_move*/)
+NoteResizeDrag::motion (GdkEvent* event, bool first_move)
{
MidiRegionSelection& ms (_editor->get_selection().midi_regions);
+ if (first_move) {
+ _editor->begin_reversible_command (_("resize notes"));
+
+ for (MidiRegionSelection::iterator r = ms.begin(); r != ms.end(); ) {
+ MidiRegionSelection::iterator next;
+ next = r;
+ ++next;
+ MidiRegionView* mrv = dynamic_cast<MidiRegionView*>(*r);
+ if (mrv) {
+ mrv->begin_resizing (at_front);
+ }
+ r = next;
+ }
+ }
+
for (MidiRegionSelection::iterator r = ms.begin(); r != ms.end(); ++r) {
NoteBase* nb = reinterpret_cast<NoteBase*> (_item->get_data ("notebase"));
assert (nb);
MidiRegionView* mrv = dynamic_cast<MidiRegionView*>(*r);
if (mrv) {
- mrv->update_resizing (nb, at_front, _drags->current_pointer_x() - grab_x(), relative);
+ double sd = 0.0;
+ bool snap = true;
+ bool apply_snap_delta = ArdourKeyboard::indicates_snap_delta (event->button.state);
+
+ if (ArdourKeyboard::indicates_snap (event->button.state)) {
+ if (_editor->snap_mode () != SnapOff) {
+ snap = false;
+ }
+ } else {
+ if (_editor->snap_mode () == SnapOff) {
+ snap = false;
+ /* inverted logic here - we;re in snapoff but we've pressed the snap delta modifier */
+ if (apply_snap_delta) {
+ snap = true;
+ }
+ }
+ }
+
+ if (apply_snap_delta) {
+ sd = _snap_delta;
+ }
+
+ mrv->update_resizing (nb, at_front, _drags->current_pointer_x() - grab_x(), relative, sd, snap);
}
}
}
void
-NoteResizeDrag::finished (GdkEvent*, bool /*movement_occurred*/)
+NoteResizeDrag::finished (GdkEvent* event, bool movement_occurred)
{
+ if (!movement_occurred) {
+ return;
+ }
+
MidiRegionSelection& ms (_editor->get_selection().midi_regions);
for (MidiRegionSelection::iterator r = ms.begin(); r != ms.end(); ++r) {
NoteBase* nb = reinterpret_cast<NoteBase*> (_item->get_data ("notebase"));
assert (nb);
MidiRegionView* mrv = dynamic_cast<MidiRegionView*>(*r);
+ double sd = 0.0;
+ bool snap = true;
+ bool apply_snap_delta = ArdourKeyboard::indicates_snap_delta (event->button.state);
if (mrv) {
- mrv->commit_resizing (nb, at_front, _drags->current_pointer_x() - grab_x(), relative);
+ if (ArdourKeyboard::indicates_snap (event->button.state)) {
+ if (_editor->snap_mode () != SnapOff) {
+ snap = false;
+ }
+ } else {
+ if (_editor->snap_mode () == SnapOff) {
+ snap = false;
+ /* inverted logic here - we;re in snapoff but we've pressed the snap delta modifier */
+ if (apply_snap_delta) {
+ snap = true;
+ }
+ }
+ }
+
+ if (apply_snap_delta) {
+ sd = _snap_delta;
+ }
+
+ mrv->commit_resizing (nb, at_front, _drags->current_pointer_x() - grab_x(), relative, sd, snap);
}
}
framecnt_t const region_length = (framecnt_t) (_primary->region()->length() / speed);
framepos_t const pf = adjusted_current_frame (event);
+ setup_snap_delta (region_start);
- if (Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
+ if (Keyboard::modifier_state_equals (event->button.state, ArdourKeyboard::trim_contents_modifier ())) {
/* Move the contents of the region around without changing the region bounds */
_operation = ContentsTrim;
Drag::start_grab (event, _editor->cursors()->trimmer);
if (pf < (region_start + region_length/2)) {
/* closer to front */
_operation = StartTrim;
-
- if (Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
+ if (Keyboard::modifier_state_equals (event->button.state, ArdourKeyboard::trim_anchored_modifier ())) {
Drag::start_grab (event, _editor->cursors()->anchored_left_side_trim);
} else {
Drag::start_grab (event, _editor->cursors()->left_side_trim);
} else {
/* closer to end */
_operation = EndTrim;
- if (Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
+ if (Keyboard::modifier_state_equals (event->button.state, ArdourKeyboard::trim_anchored_modifier ())) {
Drag::start_grab (event, _editor->cursors()->anchored_right_side_trim);
} else {
Drag::start_grab (event, _editor->cursors()->right_side_trim);
}
}
}
-
- if (Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
+ /* jump trim disabled for now
+ if (Keyboard::modifier_state_equals (event->button.state, Keyboard::trim_jump_modifier ())) {
_jump_position_when_done = true;
}
+ */
switch (_operation) {
case StartTrim:
}
break;
case EndTrim:
- show_verbose_cursor_time (region_end);
+ show_verbose_cursor_duration (region_start, region_end);
break;
case ContentsTrim:
show_verbose_cursor_time (pf);
if (tv && tv->is_track()) {
speed = tv->track()->speed();
}
-
- framecnt_t dt = adjusted_current_frame (event) - raw_grab_frame () + _pointer_frame_offset;
+ framecnt_t adj_frame = adjusted_frame (_drags->current_pointer_frame () + snap_delta (event->button.state), event, true);
+ framecnt_t dt = adj_frame - raw_grab_frame () + _pointer_frame_offset - snap_delta (event->button.state);
if (first_move) {
bool non_overlap_trim = false;
- if (event && Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
+ if (event && Keyboard::modifier_state_contains (event->button.state, ArdourKeyboard::trim_overlap_modifier ())) {
non_overlap_trim = true;
}
show_verbose_cursor_time ((framepos_t) (rv->region()->position() / speed));
break;
case EndTrim:
- show_verbose_cursor_time ((framepos_t) (rv->region()->last_frame() / speed));
+ show_verbose_cursor_duration ((framepos_t) rv->region()->position() / speed, (framepos_t) rv->region()->last_frame() / speed);
break;
case ContentsTrim:
// show_verbose_cursor_time (frame_delta);
}
}
-
void
TrimDrag::finished (GdkEvent* event, bool movement_occurred)
{
CursorDrag::start_grab (GdkEvent* event, Gdk::Cursor* c)
{
Drag::start_grab (event, c);
+ setup_snap_delta (_editor->playhead_cursor->current_frame ());
_grab_zoom = _editor->samples_per_pixel;
- framepos_t where = _editor->canvas_event_sample (event);
+ framepos_t where = _editor->canvas_event_sample (event) + snap_delta (event->button.state);
_editor->snap_to_with_modifier (where, event);
}
}
- fake_locate (where);
+ fake_locate (where - snap_delta (event->button.state));
}
void
CursorDrag::motion (GdkEvent* event, bool)
{
- framepos_t const adjusted_frame = adjusted_current_frame (event);
- if (adjusted_frame != last_pointer_frame()) {
- fake_locate (adjusted_frame);
+ framepos_t where = _editor->canvas_event_sample (event) + snap_delta (event->button.state);
+ _editor->snap_to_with_modifier (where, event);
+ if (where != last_pointer_frame()) {
+ fake_locate (where - snap_delta (event->button.state));
}
}
AudioRegionView* arv = dynamic_cast<AudioRegionView*> (_primary);
boost::shared_ptr<AudioRegion> const r = arv->audio_region ();
+ setup_snap_delta (r->position ());
show_verbose_cursor_duration (r->position(), r->position() + r->fade_in()->back()->when, 32);
}
FadeInDrag::motion (GdkEvent* event, bool)
{
framecnt_t fade_length;
- framepos_t const pos = adjusted_current_frame (event);
+
+ framepos_t pos = _editor->canvas_event_sample (event) + snap_delta (event->button.state);
+ _editor->snap_to_with_modifier (pos, event);
+ pos -= snap_delta (event->button.state);
+
boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (_primary->region ());
if (pos < (region->position() + 64)) {
}
framecnt_t fade_length;
-
- framepos_t const pos = adjusted_current_frame (event);
+ framepos_t pos = _editor->canvas_event_sample (event) + snap_delta (event->button.state);
+ _editor->snap_to_with_modifier (pos, event);
+ pos -= snap_delta (event->button.state);
boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (_primary->region ());
fade_length = pos - region->position();
}
- _editor->begin_reversible_command (_("change fade in length"));
+ bool in_command = false;
for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
tmp->audio_region()->set_fade_in_length (fade_length);
tmp->audio_region()->set_fade_in_active (true);
+ if (!in_command) {
+ _editor->begin_reversible_command (_("change fade in length"));
+ in_command = true;
+ }
XMLNode &after = alist->get_state();
_editor->session()->add_command(new MementoCommand<AutomationList>(*alist.get(), &before, &after));
}
- _editor->commit_reversible_command ();
+ if (in_command) {
+ _editor->commit_reversible_command ();
+ }
}
void
AudioRegionView* arv = dynamic_cast<AudioRegionView*> (_primary);
boost::shared_ptr<AudioRegion> r = arv->audio_region ();
+ setup_snap_delta (r->last_frame ());
show_verbose_cursor_duration (r->last_frame() - r->fade_out()->back()->when, r->last_frame());
}
{
framecnt_t fade_length;
- framepos_t const pos = adjusted_current_frame (event);
+ framepos_t pos = _editor->canvas_event_sample (event) + snap_delta (event->button.state);
+ _editor->snap_to_with_modifier (pos, event);
+ pos -= snap_delta (event->button.state);
boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (_primary->region ());
framecnt_t fade_length;
- framepos_t const pos = adjusted_current_frame (event);
+ framepos_t pos = _editor->canvas_event_sample (event) + snap_delta (event->button.state);
+ _editor->snap_to_with_modifier (pos, event);
+ pos -= snap_delta (event->button.state);
boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (_primary->region ());
fade_length = region->last_frame() - pos;
}
- _editor->begin_reversible_command (_("change fade out length"));
+ bool in_command = false;
for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
tmp->audio_region()->set_fade_out_length (fade_length);
tmp->audio_region()->set_fade_out_active (true);
+ if (!in_command) {
+ _editor->begin_reversible_command (_("change fade out length"));
+ in_command = false;
+ }
XMLNode &after = alist->get_state();
_editor->session()->add_command(new MementoCommand<AutomationList>(*alist.get(), &before, &after));
}
- _editor->commit_reversible_command ();
+ if (in_command) {
+ _editor->commit_reversible_command ();
+ }
}
void
{
DEBUG_TRACE (DEBUG::Drags, "New MarkerDrag\n");
- _marker = reinterpret_cast<Marker*> (_item->get_data ("marker"));
+ _marker = reinterpret_cast<ArdourMarker*> (_item->get_data ("marker"));
assert (_marker);
_points.push_back (ArdourCanvas::Duple (0, 0));
}
}
-MarkerDrag::CopiedLocationMarkerInfo::CopiedLocationMarkerInfo (Location* l, Marker* m)
+MarkerDrag::CopiedLocationMarkerInfo::CopiedLocationMarkerInfo (Location* l, ArdourMarker* m)
{
location = new Location (*l);
markers.push_back (m);
case Selection::Extend:
{
Locations::LocationList ll;
- list<Marker*> to_add;
+ list<ArdourMarker*> to_add;
framepos_t s, e;
_editor->selection->markers.range (s, e);
s = min (_marker->position(), s);
framepos_t const newframe = adjusted_current_frame (event);
framepos_t next = newframe;
- if (Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
+ if (Keyboard::modifier_state_contains (event->button.state, ArdourKeyboard::push_points_modifier ())) {
move_both = true;
}
switch (_marker->type()) {
- case Marker::SessionStart:
- case Marker::RangeStart:
- case Marker::LoopStart:
- case Marker::PunchIn:
+ case ArdourMarker::SessionStart:
+ case ArdourMarker::RangeStart:
+ case ArdourMarker::LoopStart:
+ case ArdourMarker::PunchIn:
f_delta = newframe - copy_location->start();
break;
- case Marker::SessionEnd:
- case Marker::RangeEnd:
- case Marker::LoopEnd:
- case Marker::PunchOut:
+ case ArdourMarker::SessionEnd:
+ case ArdourMarker::RangeEnd:
+ case ArdourMarker::LoopEnd:
+ case ArdourMarker::PunchOut:
f_delta = newframe - copy_location->end();
break;
default:
_editor->_dragging_edit_point = false;
- _editor->begin_reversible_command ( _("move marker") );
XMLNode &before = _editor->session()->locations()->get_state();
+ bool in_command = false;
MarkerSelection::iterator i;
CopiedLocationInfo::iterator x;
if (location) {
if (location->locked()) {
- return;
+ continue;
+ }
+ if (!in_command) {
+ _editor->begin_reversible_command ( _("move marker") );
+ in_command = true;
}
-
if (location->is_mark()) {
location->set_start (((*x).location)->start());
} else {
}
}
- XMLNode &after = _editor->session()->locations()->get_state();
- _editor->session()->add_command(new MementoCommand<Locations>(*(_editor->session()->locations()), &before, &after));
- _editor->commit_reversible_command ();
+ if (in_command) {
+ XMLNode &after = _editor->session()->locations()->get_state();
+ _editor->session()->add_command(new MementoCommand<Locations>(*(_editor->session()->locations()), &before, &after));
+ _editor->commit_reversible_command ();
+ }
}
void
/* move all markers to their original location */
- for (vector<Marker*>::iterator m = x->markers.begin(); m != x->markers.end(); ++m) {
+ for (vector<ArdourMarker*>::iterator m = x->markers.begin(); m != x->markers.end(); ++m) {
bool is_start;
Location * location = _editor->find_location_from_marker (*m, is_start);
_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, _fixed_grab_x, fraction);
+ framepos_t pos = _editor->pixel_to_sample (_fixed_grab_x);
+ setup_snap_delta (pos);
+ float const fraction = 1 - (_point->get_y() / _point->line().height());
show_verbose_cursor_text (_point->line().get_verbose_cursor_string (fraction));
- _pushing = Keyboard::modifier_state_contains (event->button.state, Keyboard::PrimaryModifier);
+ _pushing = Keyboard::modifier_state_equals (event->button.state, ArdourKeyboard::push_points_modifier ());
if (!_point->can_slide ()) {
_x_constrained = true;
}
void
-ControlPointDrag::motion (GdkEvent* event, bool)
+ControlPointDrag::motion (GdkEvent* event, bool first_motion)
{
double dx = _drags->current_pointer_x() - last_pointer_x();
double dy = current_pointer_y() - last_pointer_y();
- if (event->button.state & Keyboard::SecondaryModifier) {
+ if (event->button.state & ArdourKeyboard::fine_adjust_modifier ()) {
dx *= 0.1;
dy *= 0.1;
}
// positive side of zero
double const zero_gain_y = (1.0 - _zero_gain_fraction) * _point->line().height() - .01;
- // make sure we hit zero when passing through
- if ((cy < zero_gain_y && (cy - dy) > zero_gain_y) || (cy > zero_gain_y && (cy - dy) < zero_gain_y)) {
- cy = zero_gain_y;
- }
-
if (_x_constrained) {
cx = _fixed_grab_x;
}
_cumulative_x_drag = cx - _fixed_grab_x;
_cumulative_y_drag = cy - _fixed_grab_y;
+ // make sure we hit zero when passing through
+ if ((cy < zero_gain_y && (cy - dy) > zero_gain_y) || (cy > zero_gain_y && (cy - dy) < zero_gain_y)) {
+ cy = zero_gain_y;
+ }
+
cx = max (0.0, cx);
cy = max (0.0, cy);
cy = min ((double) _point->line().height(), cy);
- framepos_t cx_frames = _editor->pixel_to_sample (cx);
+ framepos_t cx_frames = _editor->pixel_to_sample (cx) + snap_delta (event->button.state);
if (!_x_constrained) {
_editor->snap_to_with_modifier (cx_frames, event);
}
+ cx_frames -= snap_delta (event->button.state);
cx_frames = min (cx_frames, _point->line().maximum_time());
float const fraction = 1.0 - (cy / _point->line().height());
+ if (first_motion) {
+ _editor->begin_reversible_command (_("automation event move"));
+ _point->line().start_drag_single (_point, _fixed_grab_x, fraction);
+ }
+
_point->line().drag_motion (_editor->sample_to_pixel_unrounded (cx_frames), fraction, false, _pushing, _final_index);
show_verbose_cursor_text (_point->line().get_verbose_cursor_string (fraction));
if (!movement_occurred) {
/* just a click */
-
- if (Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
+ if (Keyboard::modifier_state_equals (event->button.state, Keyboard::ModifierMask (Keyboard::TertiaryModifier))) {
_editor->reset_point_selection ();
}
} else {
motion (event, false);
+ _point->line().end_drag (_pushing, _final_index);
+ _editor->commit_reversible_command ();
}
-
- _point->line().end_drag (_pushing, _final_index);
- _editor->commit_reversible_command ();
}
void
}
LineDrag::LineDrag (Editor* e, ArdourCanvas::Item* i)
- : Drag (e, i),
- _line (0),
- _cumulative_y_drag (0)
+ : Drag (e, i)
+ , _line (0)
+ , _cumulative_y_drag (0)
+ , _before (0)
+ , _after (0)
{
DEBUG_TRACE (DEBUG::Drags, "New LineDrag\n");
}
framecnt_t const frame_within_region = (framecnt_t) floor (cx * _editor->samples_per_pixel);
- uint32_t before;
- uint32_t after;
-
- if (!_line->control_points_adjacent (frame_within_region, before, after)) {
+ if (!_line->control_points_adjacent (frame_within_region, _before, _after)) {
/* no adjacent points */
return;
}
double fraction = 1.0 - (cy / _line->height());
- _line->start_drag_line (before, after, fraction);
-
show_verbose_cursor_text (_line->get_verbose_cursor_string (fraction));
}
void
-LineDrag::motion (GdkEvent* event, bool)
+LineDrag::motion (GdkEvent* event, bool first_move)
{
double dy = current_pointer_y() - last_pointer_y();
- if (event->button.state & Keyboard::SecondaryModifier) {
+ if (event->button.state & ArdourKeyboard::fine_adjust_modifier ()) {
dy *= 0.1;
}
double const fraction = 1.0 - (cy / _line->height());
uint32_t ignored;
+ if (first_move) {
+ _editor->begin_reversible_command (_("automation range move"));
+ _line->start_drag_line (_before, _after, fraction);
+ }
+
/* we are ignoring x position for this drag, so we can just pass in anything */
_line->drag_motion (0, fraction, true, false, ignored);
if (movement_occured) {
motion (event, false);
_line->end_drag (false, 0);
+ _editor->commit_reversible_command ();
} else {
/* add a new control point on the line */
AutomationTimeAxisView* atv;
- _line->end_drag (false, 0);
-
if ((atv = dynamic_cast<AutomationTimeAxisView*>(_editor->clicked_axisview)) != 0) {
framepos_t where = _editor->window_event_sample (event, 0, 0);
atv->add_automation_event (event, where, event->button.y, false);
}
}
-
- _editor->commit_reversible_command ();
}
void
{
Drag::start_grab (event, cursor);
- show_verbose_cursor_time (adjusted_current_frame (event));
+ _editor->get_selection().add (_primary);
+
+ framepos_t where = _primary->region()->position();
+ setup_snap_delta (where);
+
+ show_verbose_cursor_duration (where, adjusted_current_frame (event), 0);
}
void
pair<TimeAxisView*, double> const tv = _editor->trackview_by_y_position (grab_y());
int layer = tv.first->layer_display() == Overlaid ? 0 : tv.second;
int layers = tv.first->layer_display() == Overlaid ? 1 : cv->layers();
-
- framepos_t const pf = adjusted_current_frame (event);
+ framepos_t pf = _editor->canvas_event_sample (event) + snap_delta (event->button.state);
+ _editor->snap_to_with_modifier (pf, event);
+ pf -= snap_delta (event->button.state);
if (pf > rv->region()->position()) {
rv->get_time_axis_view().show_timestretch (rv->region()->position(), pf, layers, layer);
}
- show_verbose_cursor_time (pf);
+ show_verbose_cursor_duration (_primary->region()->position(), pf, 0);
}
void
: Drag (e, i)
, _operation (o)
, _add (false)
- , _original_pointer_time_axis (-1)
, _time_selection_at_start (!_editor->get_selection().time.empty())
{
DEBUG_TRACE (DEBUG::Drags, "New SelectionDrag\n");
} else {
show_verbose_cursor_time (adjusted_current_frame (event));
}
-
- _original_pointer_time_axis = _editor->trackview_by_y_position (current_pointer_y ()).first->order ();
}
void
/* XXX what if its a music time selection? */
if (s) {
- if ( s->get_play_range() && s->transport_rolling() ) {
+ if (s->get_play_range() && s->transport_rolling()) {
s->request_play_range (&_editor->selection->time, true);
} else {
if (ARDOUR_UI::config()->get_follow_edits() && !s->transport_rolling()) {
s->request_locate (_editor->get_selection().time.start());
}
}
- }
+ if (_editor->get_selection().time.length() != 0) {
+ s->set_range_selection (_editor->get_selection().time.start(), _editor->get_selection().time.end_frame());
+ } else {
+ s->clear_range_selection ();
+ }
+ }
+
} else {
/* just a click, no pointer movement.
*/
case CreateTransportMarker:
case CreateCDMarker:
- if (Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
+ if (Keyboard::modifier_state_equals (event->button.state, Keyboard::CopyModifier)) {
_copy = true;
} else {
_copy = false;
NoteDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
{
Drag::start_grab (event);
+ setup_snap_delta (_region->source_beats_to_absolute_frames (_primary->note()->time ()));
if (!(_was_selected = _primary->selected())) {
/** @return Current total drag x change in frames */
frameoffset_t
-NoteDrag::total_dx () const
+NoteDrag::total_dx (const guint state) const
{
/* dx in frames */
frameoffset_t const dx = _editor->pixel_to_sample (_drags->current_pointer_x() - grab_x());
frameoffset_t const n = _region->source_beats_to_absolute_frames (_primary->note()->time ());
/* new time of the primary note in session frames */
- frameoffset_t st = n + dx;
+ frameoffset_t st = n + dx + snap_delta (state);
framepos_t const rp = _region->region()->position ();
/* prevent the note being dragged earlier than the region's position */
st = max (st, rp);
- /* snap and return corresponding delta */
- return _region->snap_frame_to_frame (st - rp) + rp - n;
+ /* possibly snap and return corresponding delta */
+
+ bool snap = true;
+
+ if (ArdourKeyboard::indicates_snap (state)) {
+ if (_editor->snap_mode () != SnapOff) {
+ snap = false;
+ }
+ } else {
+ if (_editor->snap_mode () == SnapOff) {
+ snap = false;
+ /* inverted logic here - we;re in snapoff but we've pressed the snap delta modifier */
+ if (ArdourKeyboard::indicates_snap_delta (state)) {
+ snap = true;
+ }
+ }
+ }
+
+ frameoffset_t ret;
+ if (snap) {
+ ret = _region->snap_frame_to_frame (st - rp) + rp - n - snap_delta (state);
+ } else {
+ ret = st - n - snap_delta (state);
+ }
+ return ret;
}
/** @return Current total drag y change in note number */
}
void
-NoteDrag::motion (GdkEvent *, bool)
+NoteDrag::motion (GdkEvent * event, bool)
{
/* Total change in x and y since the start of the drag */
- frameoffset_t const dx = total_dx ();
+ frameoffset_t const dx = total_dx (event->button.state);
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 */
}
}
} else {
- _region->note_dropped (_primary, total_dx(), total_dy());
+ _region->note_dropped (_primary, total_dx (ev->button.state), total_dy());
}
}
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->editor_add (p, value (the_list, p));
- the_list->editor_add (q, value (the_list, q));
+ the_list->editor_add (p, value (the_list, p), false);
+ the_list->editor_add (q, value (the_list, q), false);
}
/* same thing for the end */
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->editor_add (p, value (the_list, p));
- the_list->editor_add (q, value (the_list, q));
+ the_list->editor_add (p, value (the_list, p), false);
+ the_list->editor_add (q, value (the_list, q), false);
}
}
if (_nothing_to_drag) {
return;
}
-
- for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
- i->line->start_drag_multiple (i->points, y_fraction (i->line, current_pointer_y()), i->state);
- }
}
void
-AutomationRangeDrag::motion (GdkEvent*, bool /*first_move*/)
+AutomationRangeDrag::motion (GdkEvent*, bool first_move)
{
if (_nothing_to_drag) {
return;
}
+ if (first_move) {
+ _editor->begin_reversible_command (_("automation range move"));
+ for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
+ i->line->start_drag_multiple (i->points, y_fraction (i->line, current_pointer_y()), i->state);
+ }
+ }
+
for (list<Line>::iterator l = _lines.begin(); l != _lines.end(); ++l) {
float const f = y_fraction (l->line, current_pointer_y());
/* we are ignoring x position for this drag, so we can just pass in anything */
}
void
-AutomationRangeDrag::finished (GdkEvent* event, bool)
+AutomationRangeDrag::finished (GdkEvent* event, bool motion_occurred)
{
- if (_nothing_to_drag) {
+ if (_nothing_to_drag || !motion_occurred) {
return;
}
projects / ardour.git / blobdiff