/*
- Copyright (C) 2009 Paul Davis
+ Copyright (C) 2009 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include "editor_drag.h"
#include "audio_time_axis.h"
#include "midi_time_axis.h"
+#include "canvas-note.h"
+#include "selection.h"
+#include "midi_selection.h"
using namespace std;
using namespace ARDOUR;
using namespace sigc;
using namespace Gtk;
using namespace Editing;
+using namespace ArdourCanvas;
double const ControlPointDrag::_zero_gain_fraction = gain_to_slider_position (dB_to_coefficient (0.0));
Drag::end_grab (GdkEvent* event)
{
_ending = true;
-
+
_editor->stop_canvas_autoscroll ();
_item->ungrab (event ? event->button.time : 0);
_editor->hide_verbose_canvas_cursor();
- update_selection ();
-
_ending = false;
return _had_movement;
}
nframes64_t
-Drag::adjusted_current_frame () const
+Drag::adjusted_current_frame (GdkEvent* event) const
{
+ nframes64_t pos = 0;
+
if (_current_pointer_frame > _pointer_frame_offset) {
- return _current_pointer_frame - _pointer_frame_offset;
+ pos = _current_pointer_frame - _pointer_frame_offset;
}
- return 0;
+ _editor->snap_to_with_modifier (pos, event);
+
+ return pos;
}
bool
_current_pointer_frame = _editor->event_frame (event, &_current_pointer_x, &_current_pointer_y);
if (!from_autoscroll && !_move_threshold_passed) {
-
+
bool const xp = (::llabs ((nframes64_t) (_current_pointer_x - _grab_x)) > 4LL);
bool const yp = (::llabs ((nframes64_t) (_current_pointer_y - _grab_y)) > 4LL);
-
+
_move_threshold_passed = (xp || yp);
if (apply_move_threshold() && _move_threshold_passed) {
-
+
_grab_frame = _current_pointer_frame;
_grab_x = _current_pointer_x;
_grab_y = _current_pointer_y;
_last_pointer_frame = _grab_frame;
_pointer_frame_offset = _grab_frame - _last_frame_position;
-
+
}
}
if (event->motion.state & Gdk::BUTTON1_MASK || event->motion.state & Gdk::BUTTON2_MASK) {
if (!from_autoscroll) {
- _editor->maybe_autoscroll (&event->motion);
+ _editor->maybe_autoscroll (&event->motion, allow_vertical_autoscroll ());
}
motion (event, _had_movement != old_had_movement);
_views.remove (v);
}
-void
-RegionDrag::update_selection ()
-{
- list<Selectable*> s;
- copy (_views.begin(), _views.end(), back_inserter (s));
- _editor->selection->set (s);
-}
-
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)
{
-
+
}
RegionMotionDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
{
Drag::start_grab (event);
-
+
_editor->show_verbose_time_cursor (_last_frame_position, 10);
}
TimeAxisViewSummary sum;
_editor->visible_order_range (&sum.visible_y_low, &sum.visible_y_high);
-
+
/* get a bitmask representing the visible tracks */
for (Editor::TrackViewList::iterator i = _editor->track_views.begin(); i != _editor->track_views.end(); ++i) {
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) {
+ for (TimeAxisView::Children::iterator j = children_list.begin(); j != children_list.end(); ++j) {
sum.tracks = sum.tracks |= (0x01 << (rtv->order() + children));
sum.height_list[rtv->order() + children] = (*j)->current_height();
- children++;
+ children++;
}
}
}
}
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;
}
for (list<RegionView*>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
-
+
RegionView* rv = (*i);
if (rv->region()->locked()) {
/* 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 (current_pointer_layer == last_pointer_layer) {
/* No movement; clamp */
clamp_y_axis = true;
- }
+ }
}
if (!clamp_y_axis) {
RegionMotionDrag::compute_x_delta (GdkEvent const * event, nframes64_t* pending_region_position)
{
*pending_region_position = 0;
-
+
/* compute the amount of pointer motion in frames, and where
the region would be if we moved it by that much.
*/
nframes64_t sync_frame;
nframes64_t sync_offset;
int32_t sync_dir;
-
+
*pending_region_position = _current_pointer_frame - _pointer_frame_offset;
-
+
sync_offset = _primary->region()->sync_offset (sync_dir);
-
+
/* we don't handle a sync point that lies before zero.
*/
if (sync_dir >= 0 || (sync_dir < 0 && *pending_region_position >= sync_offset)) {
-
+
sync_frame = *pending_region_position + (sync_dir*sync_offset);
-
- /* we snap if the snap modifier is not enabled.
- */
-
- if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
- _editor->snap_to (sync_frame);
- }
-
+
+ _editor->snap_to_with_modifier (sync_frame, event);
+
*pending_region_position = _primary->region()->adjust_to_sync (sync_frame);
-
+
} else {
*pending_region_position = _last_frame_position;
}
-
+
}
-
+
if (*pending_region_position > max_frames - _primary->region()->length()) {
*pending_region_position = _last_frame_position;
}
double x_delta = 0;
-
+
if ((*pending_region_position != _last_frame_position) && x_move_allowed ()) {
-
+
/* now compute the canvas unit distance we need to move the regionview
to make it appear at the new location.
*/
x_delta = (static_cast<double> (*pending_region_position) - _last_frame_position) / _editor->frames_per_unit;
-
+
if (*pending_region_position <= _last_frame_position) {
-
+
for (list<RegionView*>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
-
+
RegionView* rv = (*i);
-
+
// If any regionview is at zero, we need to know so we can stop further leftward motion.
-
+
double ix1, ix2, iy1, iy2;
rv->get_canvas_frame()->get_bounds (ix1, iy1, ix2, iy2);
rv->get_canvas_frame()->i2w (ix1, iy1);
-
+
if (-x_delta > ix1 + _editor->horizontal_adjustment.get_value()) {
x_delta = 0;
*pending_region_position = _last_frame_position;
break;
}
}
-
+
}
-
+
_last_frame_position = *pending_region_position;
}
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 */
+ 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)) {
int32_t pointer_order_span;
int32_t pointer_layer_span;
int32_t canvas_pointer_order_span;
-
+
bool const clamp_y_axis = compute_y_delta (
last_pointer_view, current_pointer_view,
last_pointer_layer, current_pointer_layer, tavs,
}
/*************************************************************
- MOTION
+ MOTION
************************************************************/
pair<set<boost::shared_ptr<Playlist> >::iterator,bool> insert_result;
-
+
for (list<RegionView*>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
-
+
RegionView* rv = (*i);
-
+
if (rv->region()->locked()) {
continue;
}
-
+
/* here we are calculating the y distance from the
top of the first track view to the top of the region
area of the track view that we're working on */
-
+
/* this x value is just a dummy value so that we have something
to pass to i2w () */
-
+
double ix1 = 0;
-
+
/* distance from the top of this track view to the region area
of our track view is always 1 */
-
+
double iy1 = 1;
-
+
/* convert to world coordinates, ie distance from the top of
the ruler section */
-
+
rv->get_canvas_frame()->i2w (ix1, iy1);
-
+
/* compensate for the ruler section and the vertical scrollbar position */
iy1 += _editor->get_trackview_group_vertical_offset ();
-
+
if (first_move) {
-
- // hide any dependent views
-
+
+ // hide any dependent views
+
rv->get_time_axis_view().hide_dependent_views (*rv);
-
- /*
- reparent to a non scrolling group so that we can keep the
+
+ /*
+ reparent to a non scrolling group so that we can keep the
region selection above all time axis views.
- reparenting means we have to move the rv as the two
+ reparenting means we have to move the rv as the two
parent groups have different coordinates.
*/
-
+
rv->get_canvas_group()->property_y() = iy1 - 1;
rv->get_canvas_group()->reparent(*(_editor->_region_motion_group));
-
+
rv->fake_set_opaque (true);
}
-
+
/* current view for this particular region */
pair<TimeAxisView*, int> pos = _editor->trackview_by_y_position (iy1);
RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (pos.first);
-
+
if (pointer_order_span != 0 && !clamp_y_axis) {
-
+
/* INTER-TRACK MOVEMENT */
-
+
/* move through the height list to the track that the region is currently on */
vector<int32_t>::iterator j = tavs.height_list.begin ();
int32_t x = 0;
++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);
if (cv->layer_display () == Stacked) {
y_delta += (cv->layers() - current_pointer_layer - 1) * cv->child_height ();
}
-
+
/* And for being on a non-topmost layer on the new
track */
-
+
while (temp_pointer_order_span > 0) {
/* we're moving up canvas-wise,
so we need to find the next track height
*/
- if (j != tavs.height_list.begin()) {
+ if (j != tavs.height_list.begin()) {
j--;
}
-
+
if (x != last_pointer_order) {
if ((*j) == 0) {
++temp_pointer_order_span;
}
}
-
+
y_delta -= (*j);
temp_pointer_order_span--;
}
-
+
while (temp_pointer_order_span < 0) {
-
+
y_delta += (*j);
-
+
if (x != last_pointer_order) {
if ((*j) == 0) {
--temp_pointer_order_span;
}
}
-
- if (j != tavs.height_list.end()) {
+
+ if (j != tavs.height_list.end()) {
j++;
}
-
+
temp_pointer_order_span++;
}
-
-
+
+
/* find out where we'll be when we move and set height accordingly */
-
+
pair<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());
-
+
/* if you un-comment the following, the region colours will follow
the track colours whilst dragging; personally
i think this can confuse things, but never mind.
*/
-
+
//const GdkColor& col (temp_rtv->view->get_region_color());
//rv->set_color (const_cast<GdkColor&>(col));
}
}
-
+
if (pointer_order_span == 0 && pointer_layer_span != 0 && !clamp_y_axis) {
-
+
/* INTER-LAYER MOVEMENT in the same track */
y_delta = rtv->view()->child_height () * pointer_layer_span;
}
-
-
+
+
if (_brushing) {
_editor->mouse_brush_insert_region (rv, pending_region_position);
} else {
rv->move (x_delta, y_delta);
}
-
+
} /* foreach region */
if (first_move) {
}
void
-RegionMoveDrag::finished (GdkEvent* event, bool movement_occurred)
+RegionMoveDrag::finished (GdkEvent* /*event*/, bool movement_occurred)
{
- bool nocommit = true;
vector<RegionView*> copies;
- RouteTimeAxisView* source_tv;
boost::shared_ptr<Diskstream> ds;
boost::shared_ptr<Playlist> from_playlist;
- list<RegionView*> new_views;
+ RegionSelection new_views;
typedef set<boost::shared_ptr<Playlist> > PlaylistSet;
PlaylistSet modified_playlists;
PlaylistSet frozen_playlists;
pair<PlaylistSet::iterator,bool> insert_result, frozen_insert_result;
nframes64_t drag_delta;
bool changed_tracks, changed_position;
- pair<TimeAxisView*, int> tvp;
- map<RegionView*, RouteTimeAxisView*> final;
+ map<RegionView*, pair<RouteTimeAxisView*, int> > final;
+ RouteTimeAxisView* source_tv;
if (!movement_occurred) {
/* just a click */
- goto out;
+ return;
}
- nocommit = false;
-
if (Config->get_edit_mode() == Splice && !_editor->pre_drag_region_selection.empty()) {
_editor->selection->set (_editor->pre_drag_region_selection);
_editor->pre_drag_region_selection.clear ();
if (_brushing) {
/* all changes were made during motion event handlers */
-
+
if (_copy) {
for (list<RegionView*>::iterator i = _views.begin(); i != _views.end(); ++i) {
copies.push_back (*i);
/* reverse this here so that we have the correct logic to finalize
the drag.
*/
-
- if (Config->get_edit_mode() == Lock && !_copy) {
+
+ if (Config->get_edit_mode() == Lock) {
_x_constrained = !_x_constrained;
}
_editor->begin_reversible_command (_("fixed time region copy"));
} else {
_editor->begin_reversible_command (_("region copy"));
- }
+ }
} else {
if (_x_constrained) {
_editor->begin_reversible_command (_("fixed time region drag"));
}
changed_position = (_last_frame_position != (nframes64_t) (_primary->region()->position()));
- tvp = _editor->trackview_by_y_position (_current_pointer_y);
- changed_tracks = (tvp.first != &_primary->get_time_axis_view());
+ changed_tracks = (_dest_trackview != &_primary->get_time_axis_view());
drag_delta = _primary->region()->position() - _last_frame_position;
- _editor->track_canvas->update_now ();
+ _editor->update_canvas_now ();
/* make a list of where each region ended up */
- final = find_time_axis_views ();
+ final = find_time_axis_views_and_layers ();
for (list<RegionView*>::const_iterator i = _views.begin(); i != _views.end(); ) {
RegionView* rv = (*i);
- RouteTimeAxisView* dest_rtv = final[*i];
+ RouteTimeAxisView* dest_rtv = final[*i].first;
+ layer_t dest_layer = final[*i].second;
nframes64_t where;
} else {
where = rv->region()->position();
}
-
+
boost::shared_ptr<Region> new_region;
if (_copy) {
new_region = rv->region();
/* undo the previous hide_dependent_views so that xfades don't
- disappear on copying regions
+ disappear on copying regions
*/
-
+
//rv->get_time_axis_view().reveal_dependent_views (*rv);
-
+
} else if (changed_tracks && dest_rtv->playlist()) {
new_region = RegionFactory::create (rv->region());
}
if (changed_tracks || _copy) {
boost::shared_ptr<Playlist> to_playlist = dest_rtv->playlist();
-
+
if (!to_playlist) {
++i;
continue;
_editor->latest_regionviews.clear ();
sigc::connection c = dest_rtv->view()->RegionViewAdded.connect (mem_fun(*_editor, &Editor::collect_new_region_view));
-
+
insert_result = modified_playlists.insert (to_playlist);
-
+
if (insert_result.second) {
_editor->session->add_command (new MementoCommand<Playlist>(*to_playlist, &to_playlist->get_state(), 0));
}
to_playlist->add_region (new_region, where);
+ if (dest_rtv->view()->layer_display() == Stacked) {
+ new_region->set_layer (dest_layer);
+ new_region->set_pending_explicit_relayer (true);
+ }
c.disconnect ();
-
+
if (!_editor->latest_regionviews.empty()) {
// XXX why just the first one ? we only expect one
// commented out in nick_m's canvas reworking. is that intended?
}
} else {
- /*
- motion on the same track. plonk the previously reparented region
+ /*
+ motion on the same track. plonk the previously reparented region
back to its original canvas group (its streamview).
No need to do anything for copies as they are fake regions which will be deleted.
*/
rv->get_canvas_group()->reparent (*dest_rtv->view()->canvas_item());
rv->get_canvas_group()->property_y() = 0;
-
+
/* just change the model */
-
+
boost::shared_ptr<Playlist> playlist = dest_rtv->playlist();
+ if (dest_rtv->view()->layer_display() == Stacked) {
+ rv->region()->set_layer (dest_layer);
+ rv->region()->set_pending_explicit_relayer (true);
+ }
+
insert_result = modified_playlists.insert (playlist);
-
+
if (insert_result.second) {
_editor->session->add_command (new MementoCommand<Playlist>(*playlist, &playlist->get_state(), 0));
}
/* freeze to avoid lots of relayering in the case of a multi-region drag */
frozen_insert_result = frozen_playlists.insert(playlist);
-
+
if (frozen_insert_result.second) {
playlist->freeze();
}
because we may have copied the region and it has not been attached to a playlist.
*/
- assert ((source_tv = dynamic_cast<RouteTimeAxisView*> (&rv->get_time_axis_view())));
- assert ((ds = source_tv->get_diskstream()));
- assert ((from_playlist = ds->playlist()));
+ source_tv = dynamic_cast<RouteTimeAxisView*> (&rv->get_time_axis_view());
+ ds = source_tv->get_diskstream();
+ from_playlist = ds->playlist();
+
+ assert (source_tv);
+ assert (ds);
+ assert (from_playlist);
/* moved to a different audio track, without copying */
moved to the new one - we use a copy of it. as a result,
any existing editor for the region should no longer be
visible.
- */
-
+ */
+
rv->hide_region_editor();
rv->fake_set_opaque (false);
-
+
/* remove the region from the old playlist */
insert_result = modified_playlists.insert (from_playlist);
-
+
if (insert_result.second) {
_editor->session->add_command (new MementoCommand<Playlist>(*from_playlist, &from_playlist->get_state(), 0));
}
-
+
from_playlist->remove_region (rv->region());
-
+
/* OK, this is where it gets tricky. If the playlist was being used by >1 tracks, and the region
was selected in all of them, then removing it from a playlist will have removed all
trace of it from the selection (i.e. there were N regions selected, we removed 1,
if (_views.empty()) {
break;
- } else {
+ } else {
i = _views.begin();
}
} else {
++i;
}
-
+
if (_copy) {
copies.push_back (rv);
}
}
-
- if (new_views.empty()) {
- if (_copy) {
- /* the region(view)s that are being dragged around are copies and do not
- belong to any track. remove them from our list
- */
- _views.clear ();
- }
- } else {
- _views = new_views;
- _primary = _views.front ();
- }
+
+ _editor->selection->add (new_views);
for (set<boost::shared_ptr<Playlist> >::iterator p = frozen_playlists.begin(); p != frozen_playlists.end(); ++p) {
(*p)->thaw();
}
-
- out:
- if (!nocommit) {
- for (set<boost::shared_ptr<Playlist> >::iterator p = modified_playlists.begin(); p != modified_playlists.end(); ++p) {
- _editor->session->add_command (new MementoCommand<Playlist>(*(*p), 0, &(*p)->get_state()));
- }
- _editor->commit_reversible_command ();
+ out:
+ for (set<boost::shared_ptr<Playlist> >::iterator p = modified_playlists.begin(); p != modified_playlists.end(); ++p) {
+ _editor->session->add_command (new MementoCommand<Playlist>(*(*p), 0, &(*p)->get_state()));
}
+ _editor->commit_reversible_command ();
+
for (vector<RegionView*>::iterator x = copies.begin(); x != copies.end(); ++x) {
delete *x;
}
bool
-RegionMoveDrag::x_move_allowed () const
-{
- if (Config->get_edit_mode() == Lock) {
- if (_copy) {
- return !_x_constrained;
- } else {
- /* in locked edit mode, reverse the usual meaning of _x_constrained */
- return _x_constrained;
- }
- }
-
- return !_x_constrained;
-}
-
-bool
-RegionInsertDrag::x_move_allowed () const
+RegionMotionDrag::x_move_allowed () const
{
if (Config->get_edit_mode() == Lock) {
+ /* in locked edit mode, reverse the usual meaning of _x_constrained */
return _x_constrained;
}
/* duplicate the regionview(s) and region(s) */
list<RegionView*> new_regionviews;
-
+
for (list<RegionView*>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
-
+
RegionView* rv = (*i);
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);
} else {
continue;
}
-
+
nrv->get_canvas_group()->show ();
new_regionviews.push_back (nrv);
}
-
+
if (new_regionviews.empty()) {
return;
}
-
+
/* reflect the fact that we are dragging the copies */
-
+
_primary = new_regionviews.front();
_views = new_regionviews;
-
+
swap_grab (new_regionviews.front()->get_canvas_group (), 0, event ? event->motion.time : 0);
-
- /*
- sync the canvas to what we think is its current state
- without it, the canvas seems to
- "forget" to update properly after the upcoming reparent()
- ..only if the mouse is in rapid motion at the time of the grab.
+
+ /*
+ sync the canvas to what we think is its current state
+ without it, the canvas seems to
+ "forget" to update properly after the upcoming reparent()
+ ..only if the mouse is in rapid motion at the time of the grab.
something to do with regionview creation raking so long?
*/
- _editor->track_canvas->update_now();
+ _editor->update_canvas_now();
}
bool
(*tv) = dynamic_cast<RouteTimeAxisView*> (tvp.first);
(*layer) = tvp.second;
+ if (*tv && (*tv)->layer_display() == Overlaid) {
+ *layer = 0;
+ }
+
/* The region motion is only processed if the pointer is over
an audio track.
*/
-
+
if (!(*tv) || !(*tv)->is_track()) {
- /* To make sure we hide the verbose canvas cursor when the mouse is
- not held over and audiotrack.
+ /* To make sure we hide the verbose canvas cursor when the mouse is
+ not held over and audiotrack.
*/
_editor->hide_verbose_canvas_cursor ();
return false;
{
if (new_order != old_order) {
- /* this isn't the pointer track */
+ /* this isn't the pointer track */
if (y_span > 0) {
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 */
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;
_copy (c)
{
TimeAxisView* const tv = &_primary->get_time_axis_view ();
-
+
_dest_trackview = tv;
- _dest_layer = _primary->region()->layer ();
+ if (tv->layer_display() == Overlaid) {
+ _dest_layer = 0;
+ } else {
+ _dest_layer = _primary->region()->layer ();
+ }
double speed = 1;
RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tv);
RegionMoveDrag::start_grab (GdkEvent* event, Gdk::Cursor* c)
{
RegionMotionDrag::start_grab (event, c);
-
+
_pointer_frame_offset = _grab_frame - _last_frame_position;
}
(boost::dynamic_pointer_cast<MidiRegion> (r) && dynamic_cast<MidiTimeAxisView*> (v)));
_primary = v->view()->create_region_view (r, false, false);
-
+
_primary->get_canvas_group()->show ();
_primary->set_position (pos, 0);
_views.push_back (_primary);
_dest_layer = _primary->region()->layer ();
}
-map<RegionView*, RouteTimeAxisView*>
-RegionMotionDrag::find_time_axis_views ()
+map<RegionView*, pair<RouteTimeAxisView*, int> >
+RegionMotionDrag::find_time_axis_views_and_layers ()
{
- map<RegionView*, RouteTimeAxisView*> tav;
-
+ map<RegionView*, pair<RouteTimeAxisView*, int> > tav;
+
for (list<RegionView*>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
double ix1, ix2, iy1, iy2;
iy1 += _editor->vertical_adjustment.get_value() - _editor->canvas_timebars_vsize;
pair<TimeAxisView*, int> tv = _editor->trackview_by_y_position (iy1);
- tav[*i] = dynamic_cast<RouteTimeAxisView*> (tv.first);
+ tav[*i] = make_pair (dynamic_cast<RouteTimeAxisView*> (tv.first), tv.second);
}
return tav;
void
-RegionInsertDrag::finished (GdkEvent* event, bool movement_occurred)
+RegionInsertDrag::finished (GdkEvent* /*event*/, bool /*movement_occurred*/)
{
- _editor->track_canvas->update_now ();
+ _editor->update_canvas_now ();
+
+ map<RegionView*, pair<RouteTimeAxisView*, int> > final = find_time_axis_views_and_layers ();
- map<RegionView*, RouteTimeAxisView*> final = find_time_axis_views ();
-
- RouteTimeAxisView* dest_rtv = final[_primary];
+ RouteTimeAxisView* dest_rtv = final[_primary].first;
_primary->get_canvas_group()->reparent (*dest_rtv->view()->canvas_item());
_primary->get_canvas_group()->property_y() = 0;
};
void
-RegionSpliceDrag::motion (GdkEvent* event, bool)
+RegionSpliceDrag::motion (GdkEvent* /*event*/, bool)
{
RouteTimeAxisView* tv;
layer_t layer;
-
+
if (!check_possible (&tv, &layer)) {
return;
}
if (!playlist->region_is_shuffle_constrained ((*i)->region())) {
continue;
- }
+ }
if (dir > 0) {
if (_current_pointer_frame < (*i)->region()->last_frame() + 1) {
}
}
-
+
playlist->shuffle ((*i)->region(), dir);
_grab_x = _current_pointer_x;
}
void
-RegionSpliceDrag::finished (GdkEvent* event, bool)
+RegionSpliceDrag::finished (GdkEvent* /*event*/, bool)
{
-
+
}
: Drag (e, i),
_view (v)
{
-
+
}
void
RegionCreateDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
{
_dest_trackview = _view;
-
+
Drag::start_grab (event);
}
void
-RegionCreateDrag::motion (GdkEvent* event, bool first_move)
+RegionCreateDrag::motion (GdkEvent* /*event*/, bool first_move)
{
if (first_move) {
// TODO: create region-create-drag region view here
}
// TODO: resize region-create-drag region view here
-}
+}
void
RegionCreateDrag::finished (GdkEvent* event, bool movement_occurred)
{
MidiTimeAxisView* mtv = dynamic_cast<MidiTimeAxisView*> (_dest_trackview);
- if (!mtv) {
- return;
- }
- const boost::shared_ptr<MidiDiskstream> diskstream =
- boost::dynamic_pointer_cast<MidiDiskstream>(mtv->view()->trackview().track()->diskstream());
-
- if (!diskstream) {
- warning << "Cannot create non-MIDI region" << endl;
+ if (!mtv) {
return;
}
if (!movement_occurred) {
- _editor->begin_reversible_command (_("create region"));
- XMLNode &before = mtv->playlist()->get_state();
-
- nframes64_t start = _grab_frame;
- _editor->snap_to (start, -1);
- const Meter& m = _editor->session->tempo_map().meter_at(start);
- const Tempo& t = _editor->session->tempo_map().tempo_at(start);
- double length = floor (m.frames_per_bar(t, _editor->session->frame_rate()));
-
- boost::shared_ptr<Source> src = _editor->session->create_midi_source_for_session(*diskstream.get());
-
- mtv->playlist()->add_region (boost::dynamic_pointer_cast<MidiRegion>
- (RegionFactory::create(src, 0, (nframes_t) length,
- PBD::basename_nosuffix(src->name()))), start);
- XMLNode &after = mtv->playlist()->get_state();
- _editor->session->add_command(new MementoCommand<Playlist>(*mtv->playlist().get(), &before, &after));
- _editor->commit_reversible_command();
-
+ mtv->add_region (_grab_frame);
} else {
motion (event, false);
// TODO: create region-create-drag region here
}
}
+NoteResizeDrag::NoteResizeDrag (Editor* e, ArdourCanvas::Item* i)
+ : Drag (e, i)
+ , region (0)
+{
+
+}
+
+void
+NoteResizeDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
+{
+ Gdk::Cursor cursor;
+ ArdourCanvas::CanvasNote* cnote = dynamic_cast<ArdourCanvas::CanvasNote*>(_item);
+
+ Drag::start_grab (event);
+
+ region = &cnote->region_view();
+ double region_start = region->get_position_pixels();
+ double middle_point = region_start + cnote->x1() + (cnote->x2() - cnote->x1()) / 2.0L;
+
+ if (_grab_x <= middle_point) {
+ cursor = Gdk::Cursor(Gdk::LEFT_SIDE);
+ at_front = true;
+ } else {
+ cursor = Gdk::Cursor(Gdk::RIGHT_SIDE);
+ at_front = false;
+ }
+
+ _item->grab(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK, cursor, event->motion.time);
+
+ if (event->motion.state & Keyboard::PrimaryModifier) {
+ relative = false;
+ } else {
+ relative = true;
+ }
+ MidiRegionSelection& ms (_editor->get_selection().midi_regions);
+
+ if (ms.size() > 1) {
+ /* has to be relative, may make no sense otherwise */
+ relative = true;
+ }
+
+ region->note_selected (cnote, true);
+
+ for (MidiRegionSelection::iterator r = ms.begin(); r != ms.end(); ) {
+ MidiRegionSelection::iterator next;
+ next = r;
+ ++next;
+ (*r)->begin_resizing (at_front);
+ r = next;
+ }
+}
void
-RegionGainDrag::motion (GdkEvent* event, bool)
+NoteResizeDrag::motion (GdkEvent* /*event*/, bool /*first_move*/)
{
-
+ MidiRegionSelection& ms (_editor->get_selection().midi_regions);
+ for (MidiRegionSelection::iterator r = ms.begin(); r != ms.end(); ++r) {
+ (*r)->update_resizing (at_front, _current_pointer_x - _grab_x, relative);
+ }
+}
+
+void
+NoteResizeDrag::finished (GdkEvent*, bool /*movement_occurred*/)
+{
+ MidiRegionSelection& ms (_editor->get_selection().midi_regions);
+ for (MidiRegionSelection::iterator r = ms.begin(); r != ms.end(); ++r) {
+ (*r)->commit_resizing (at_front, _current_pointer_x - _grab_x, relative);
+ }
+}
+
+void
+RegionGainDrag::motion (GdkEvent* /*event*/, bool)
+{
+
}
void
if (tv && tv->is_track()) {
speed = tv->get_diskstream()->speed();
}
-
+
nframes64_t region_start = (nframes64_t) (_primary->region()->position() / speed);
nframes64_t region_end = (nframes64_t) (_primary->region()->last_frame() / speed);
nframes64_t region_length = (nframes64_t) (_primary->region()->length() / speed);
Drag::start_grab (event, _editor->trimmer_cursor);
-
+
if (Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
_operation = ContentsTrim;
} else {
switch (_operation) {
case StartTrim:
- _editor->show_verbose_time_cursor (region_start, 10);
+ _editor->show_verbose_time_cursor (region_start, 10);
break;
case EndTrim:
- _editor->show_verbose_time_cursor (region_end, 10);
+ _editor->show_verbose_time_cursor (region_end, 10);
break;
case ContentsTrim:
- _editor->show_verbose_time_cursor (_current_pointer_frame, 10);
+ _editor->show_verbose_time_cursor (_current_pointer_frame, 10);
break;
}
}
bool obey_snap = !Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier());
/* snap modifier works differently here..
- its' current state has to be passed to the
- various trim functions in order to work properly
- */
+ its' current state has to be passed to the
+ various trim functions in order to work properly
+ */
double speed = 1.0;
TimeAxisView* tvp = &_primary->get_time_axis_view ();
if (tv && tv->is_track()) {
speed = tv->get_diskstream()->speed();
}
-
+
if (_last_pointer_frame > _current_pointer_frame) {
left_direction = true;
} else {
left_direction = false;
}
- if (obey_snap) {
- _editor->snap_to (_current_pointer_frame);
- }
-
- if (_current_pointer_frame == _last_pointer_frame) {
- return;
- }
+ _editor->snap_to_with_modifier (_current_pointer_frame, event);
if (first_move) {
-
+
string trim_type;
switch (_operation) {
for (list<RegionView*>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
(*i)->fake_set_opaque(false);
(*i)->region()->freeze ();
-
+
AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
if (arv){
}
}
+ if (_current_pointer_frame == _last_pointer_frame) {
+ return;
+ }
+
if (left_direction) {
frame_delta = (_last_pointer_frame - _current_pointer_frame);
} else {
non_overlap_trim = true;
}
- switch (_operation) {
+ switch (_operation) {
case StartTrim:
if ((left_direction == false) && (_current_pointer_frame <= rv->region()->first_frame()/speed)) {
break;
}
break;
}
-
+
case EndTrim:
if ((left_direction == true) && (_current_pointer_frame > (nframes64_t) (rv->region()->last_frame()/speed))) {
break;
}
break;
}
-
+
case ContentsTrim:
{
bool swap_direction = false;
if (Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
swap_direction = true;
}
-
+
for (list<RegionView*>::const_iterator i = _views.begin(); i != _views.end(); ++i)
{
_editor->single_contents_trim (**i, frame_delta, left_direction, swap_direction, obey_snap);
switch (_operation) {
case StartTrim:
- _editor->show_verbose_time_cursor((nframes64_t) (rv->region()->position()/speed), 10);
+ _editor->show_verbose_time_cursor((nframes64_t) (rv->region()->position()/speed), 10);
break;
case EndTrim:
- _editor->show_verbose_time_cursor((nframes64_t) (rv->region()->last_frame()/speed), 10);
+ _editor->show_verbose_time_cursor((nframes64_t) (rv->region()->last_frame()/speed), 10);
break;
case ContentsTrim:
- _editor->show_verbose_time_cursor(_current_pointer_frame, 10);
+ _editor->show_verbose_time_cursor(_current_pointer_frame, 10);
break;
}
{
if (movement_occurred) {
motion (event, false);
-
+
if (!_editor->selection->selected (_primary)) {
- _editor->thaw_region_after_trim (*_primary);
+ _editor->thaw_region_after_trim (*_primary);
} else {
-
+
for (list<RegionView*>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
_editor->thaw_region_after_trim (**i);
(*i)->fake_set_opaque (true);
}
}
-
+
for (set<boost::shared_ptr<Playlist> >::iterator p = _editor->motion_frozen_playlists.begin(); p != _editor->motion_frozen_playlists.end(); ++p) {
(*p)->thaw ();
_editor->session->add_command (new MementoCommand<Playlist>(*(*p).get(), 0, &(*p)->get_state()));
}
-
+
_editor->motion_frozen_playlists.clear ();
_editor->commit_reversible_command();
// The actual copying is not done before we reach the finish callback.
char name[64];
snprintf (name, sizeof(name), "%g/%g", _marker->meter().beats_per_bar(), _marker->meter().note_divisor ());
- MeterMarker* new_marker = new MeterMarker(*_editor, *_editor->meter_group, ARDOUR_UI::config()->canvasvar_MeterMarker.get(), name,
+ MeterMarker* new_marker = new MeterMarker(*_editor, *_editor->meter_group, ARDOUR_UI::config()->canvasvar_MeterMarker.get(), name,
*new MeterSection (_marker->meter()));
_item = &new_marker->the_item ();
_marker = new_marker;
-
+
} else {
MetricSection& section (_marker->meter());
-
+
if (!section.movable()) {
return;
}
-
+
}
Drag::start_grab (event, cursor);
-
- _pointer_frame_offset = _grab_frame - _marker->meter().frame();
+
+ _pointer_frame_offset = _grab_frame - _marker->meter().frame();
_editor->show_verbose_time_cursor (_current_pointer_frame, 10);
}
void
MeterMarkerDrag::motion (GdkEvent* event, bool)
{
- nframes64_t adjusted_frame = adjusted_current_frame ();
-
- if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
- _editor->snap_to (adjusted_frame);
- }
-
+ nframes64_t const adjusted_frame = adjusted_current_frame (event);
+
if (adjusted_frame == _last_pointer_frame) {
return;
}
_marker->set_position (adjusted_frame);
-
+
_last_pointer_frame = adjusted_frame;
_editor->show_verbose_time_cursor (adjusted_frame, 10);
}
motion (event, false);
-
+
BBT_Time when;
-
+
TempoMap& map (_editor->session->tempo_map());
map.bbt_time (_last_pointer_frame, when);
-
+
if (_copy == true) {
_editor->begin_reversible_command (_("copy meter mark"));
XMLNode &before = map.get_state();
: Drag (e, i),
_copy (c)
{
- TempoMarker* _marker = reinterpret_cast<TempoMarker*> (_item->get_data ("marker"));
+ _marker = reinterpret_cast<TempoMarker*> (_item->get_data ("marker"));
assert (_marker);
}
{
if (_copy) {
-
+
// create a dummy marker for visual representation of moving the copy.
// The actual copying is not done before we reach the finish callback.
char name[64];
snprintf (name, sizeof (name), "%.2f", _marker->tempo().beats_per_minute());
- TempoMarker* new_marker = new TempoMarker(*_editor, *_editor->tempo_group, ARDOUR_UI::config()->canvasvar_TempoMarker.get(), name,
+ TempoMarker* new_marker = new TempoMarker(*_editor, *_editor->tempo_group, ARDOUR_UI::config()->canvasvar_TempoMarker.get(), name,
*new TempoSection (_marker->tempo()));
_item = &new_marker->the_item ();
} else {
MetricSection& section (_marker->tempo());
-
+
if (!section.movable()) {
return;
}
Drag::start_grab (event, cursor);
- _pointer_frame_offset = _grab_frame - _marker->tempo().frame();
+ _pointer_frame_offset = _grab_frame - _marker->tempo().frame();
_editor->show_verbose_time_cursor (_current_pointer_frame, 10);
}
void
TempoMarkerDrag::motion (GdkEvent* event, bool)
{
- nframes64_t adjusted_frame = adjusted_current_frame ();
+ nframes64_t const adjusted_frame = adjusted_current_frame (event);
- if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
- _editor->snap_to (adjusted_frame);
- }
-
if (adjusted_frame == _last_pointer_frame) {
return;
}
/* OK, we've moved far enough to make it worth actually move the thing. */
-
+
_marker->set_position (adjusted_frame);
-
+
_editor->show_verbose_time_cursor (adjusted_frame, 10);
_last_pointer_frame = adjusted_frame;
if (!movement_occurred) {
return;
}
-
+
motion (event, false);
-
+
BBT_Time when;
-
+
TempoMap& map (_editor->session->tempo_map());
map.bbt_time (_last_pointer_frame, when);
XMLNode &after = map.get_state();
_editor->session->add_command (new MementoCommand<TempoMap>(map, &before, &after));
_editor->commit_reversible_command ();
-
+
// delete the dummy marker we used for visual representation of copying.
// a new visual marker will show up automatically.
delete _marker;
Drag::start_grab (event, c);
if (!_stop) {
-
+
nframes64_t where = _editor->event_frame (event, 0, 0);
- _editor->snap_to (where);
+ _editor->snap_to_with_modifier (where, event);
_editor->playhead_cursor->set_position (where);
}
}
}
- _pointer_frame_offset = _grab_frame - _cursor->current_frame;
-
_editor->show_verbose_time_cursor (_cursor->current_frame, 10);
}
void
CursorDrag::motion (GdkEvent* event, bool)
{
- nframes64_t adjusted_frame = adjusted_current_frame ();
-
- if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
- if (_cursor == _editor->playhead_cursor) {
- _editor->snap_to (adjusted_frame);
- }
- }
-
+ nframes64_t const adjusted_frame = adjusted_current_frame (event);
+
if (adjusted_frame == _last_pointer_frame) {
return;
}
_editor->show_verbose_time_cursor (_cursor->current_frame, 10);
#ifdef GTKOSX
- _editor->track_canvas->update_now ();
+ _editor->update_canvas_now ();
#endif
_editor->UpdateAllTransportClocks (_cursor->current_frame);
if (!movement_occurred && _stop) {
return;
}
-
+
motion (event, false);
-
+
if (_item == &_editor->playhead_cursor->canvas_item) {
if (_editor->session) {
_editor->session->request_locate (_editor->playhead_cursor->current_frame, _was_rolling);
_editor->_pending_locate_request = true;
}
- }
+ }
}
FadeInDrag::FadeInDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v)
: RegionDrag (e, i, p, v)
{
-
+
}
void
AudioRegionView* a = dynamic_cast<AudioRegionView*> (_primary);
boost::shared_ptr<AudioRegion> const r = a->audio_region ();
-
- _pointer_frame_offset = _grab_frame - ((nframes64_t) r->fade_in()->back()->when + r->position());
+
+ _pointer_frame_offset = _grab_frame - ((nframes64_t) r->fade_in()->back()->when + r->position());
}
void
{
nframes64_t fade_length;
- nframes64_t pos = adjusted_current_frame ();
+ nframes64_t const pos = adjusted_current_frame (event);
- if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
- _editor->snap_to (pos);
- }
-
boost::shared_ptr<Region> region = _primary->region ();
if (pos < (region->position() + 64)) {
fade_length = region->length();
} else {
fade_length = pos - region->position();
- }
+ }
for (RegionSelection::iterator i = _views.begin(); i != _views.end(); ++i) {
AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*i);
-
+
if (!tmp) {
continue;
}
-
+
tmp->reset_fade_in_shape_width (fade_length);
}
nframes64_t fade_length;
- nframes64_t const pos = adjusted_current_frame ();
+ nframes64_t const pos = adjusted_current_frame (event);
boost::shared_ptr<Region> region = _primary->region ();
} else {
fade_length = pos - region->position();
}
-
+
_editor->begin_reversible_command (_("change fade in length"));
for (RegionSelection::iterator i = _views.begin(); i != _views.end(); ++i) {
AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*i);
-
+
if (!tmp) {
continue;
}
-
+
boost::shared_ptr<AutomationList> alist = tmp->audio_region()->fade_in();
XMLNode &before = alist->get_state();
tmp->audio_region()->set_fade_in_length (fade_length);
tmp->audio_region()->set_fade_in_active (true);
-
+
XMLNode &after = alist->get_state();
_editor->session->add_command(new MementoCommand<AutomationList>(*alist.get(), &before, &after));
}
FadeOutDrag::FadeOutDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v)
: RegionDrag (e, i, p, v)
{
-
+
}
void
AudioRegionView* a = dynamic_cast<AudioRegionView*> (_primary);
boost::shared_ptr<AudioRegion> r = a->audio_region ();
-
+
_pointer_frame_offset = _grab_frame - (r->length() - (nframes64_t) r->fade_out()->back()->when + r->position());
}
{
nframes64_t fade_length;
- nframes64_t pos = adjusted_current_frame ();
-
- if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
- _editor->snap_to (pos);
- }
+ nframes64_t const pos = adjusted_current_frame (event);
boost::shared_ptr<Region> region = _primary->region ();
-
+
if (pos > (region->last_frame() - 64)) {
fade_length = 64; // this should really be a minimum fade defined somewhere
}
else {
fade_length = region->last_frame() - pos;
}
-
+
for (RegionSelection::iterator i = _views.begin(); i != _views.end(); ++i) {
AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*i);
-
+
if (!tmp) {
continue;
}
-
+
tmp->reset_fade_out_shape_width (fade_length);
}
nframes64_t fade_length;
- nframes64_t pos = adjusted_current_frame ();
-
- if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
- _editor->snap_to (pos);
- }
+ nframes64_t const pos = adjusted_current_frame (event);
boost::shared_ptr<Region> region = _primary->region ();
for (RegionSelection::iterator i = _views.begin(); i != _views.end(); ++i) {
AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*i);
-
+
if (!tmp) {
continue;
}
-
+
boost::shared_ptr<AutomationList> alist = tmp->audio_region()->fade_out();
XMLNode &before = alist->get_state();
-
+
tmp->audio_region()->set_fade_out_length (fade_length);
tmp->audio_region()->set_fade_out_active (true);
MarkerDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
{
Drag::start_grab (event, cursor);
-
+
bool is_start;
Location *location = _editor->find_location_from_marker (_marker, is_start);
_editor->_dragging_edit_point = true;
- _pointer_frame_offset = _grab_frame - (is_start ? location->start() : location->end());
+ _pointer_frame_offset = _grab_frame - (is_start ? location->start() : location->end());
update_item (location);
Location *real_location;
Location *copy_location = 0;
- nframes64_t newframe = adjusted_current_frame ();
+ nframes64_t const newframe = adjusted_current_frame (event);
nframes64_t next = newframe;
- if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
- _editor->snap_to (newframe, 0, true);
- }
-
- if (_current_pointer_frame == _last_pointer_frame) {
+ if (_current_pointer_frame == _last_pointer_frame) {
return;
}
/* find the marker we're dragging, and compute the delta */
- for (i = _editor->selection->markers.begin(), x = _copied_locations.begin();
- x != _copied_locations.end() && i != _editor->selection->markers.end();
+ for (i = _editor->selection->markers.begin(), x = _copied_locations.begin();
+ x != _copied_locations.end() && i != _editor->selection->markers.end();
++i, ++x) {
copy_location = *x;
/* now move them all */
- for (i = _editor->selection->markers.begin(), x = _copied_locations.begin();
- x != _copied_locations.end() && i != _editor->selection->markers.end();
+ for (i = _editor->selection->markers.begin(), x = _copied_locations.begin();
+ x != _copied_locations.end() && i != _editor->selection->markers.end();
++i, ++x) {
copy_location = *x;
marker = *i;
/* call this to find out if its the start or end */
-
+
if ((real_location = _editor->find_location_from_marker (marker, is_start)) == 0) {
continue;
}
-
+
if (real_location->locked()) {
continue;
}
if (copy_location->is_mark()) {
/* just move it */
-
+
copy_location->set_start (copy_location->start() + f_delta);
} else {
-
+
nframes64_t new_start = copy_location->start() + f_delta;
nframes64_t new_end = copy_location->end() + f_delta;
-
+
if (is_start) { // start-of-range marker
-
+
if (move_both) {
copy_location->set_start (new_start);
copy_location->set_end (new_end);
} else if (new_start < copy_location->end()) {
copy_location->set_start (new_start);
- } else {
+ } else {
_editor->snap_to (next, 1, true);
copy_location->set_end (next);
copy_location->set_start (newframe);
}
-
+
} else { // end marker
-
+
if (move_both) {
copy_location->set_end (new_end);
copy_location->set_start (new_start);
_editor->show_verbose_time_cursor (newframe, 10);
#ifdef GTKOSX
- _editor->track_canvas->update_now ();
+ _editor->update_canvas_now ();
#endif
_editor->edit_point_clock.set (copy_location->start());
}
case Selection::Add:
break;
}
-
+
return;
}
_editor->_dragging_edit_point = false;
-
+
_editor->begin_reversible_command ( _("move marker") );
XMLNode &before = _editor->session->locations()->get_state();
list<Location*>::iterator x;
bool is_start;
- for (i = _editor->selection->markers.begin(), x = _copied_locations.begin();
- x != _copied_locations.end() && i != _editor->selection->markers.end();
+ for (i = _editor->selection->markers.begin(), x = _copied_locations.begin();
+ x != _copied_locations.end() && i != _editor->selection->markers.end();
++i, ++x) {
-
+
Location * location = _editor->find_location_from_marker (*i, is_start);
-
+
if (location) {
-
+
if (location->locked()) {
return;
}
-
+
if (location->is_mark()) {
location->set_start ((*x)->start());
} else {
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();
}
_cumulative_x_drag (0),
_cumulative_y_drag (0)
{
- ControlPoint* _point = reinterpret_cast<ControlPoint*> (_item->get_data ("control_point"));
+ _point = reinterpret_cast<ControlPoint*> (_item->get_data ("control_point"));
assert (_point);
}
void
-ControlPointDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
+ControlPointDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*cursor*/)
{
Drag::start_grab (event, _editor->fader_cursor);
_point->line().start_drag (_point, _grab_frame, 0);
float fraction = 1.0 - (_point->get_y() / _point->line().height());
- _editor->set_verbose_canvas_cursor (_point->line().get_verbose_cursor_string (fraction),
+ _editor->set_verbose_canvas_cursor (_point->line().get_verbose_cursor_string (fraction),
_current_pointer_x + 10, _current_pointer_y + 10);
_editor->show_verbose_canvas_cursor ();
//translate cx to frames
nframes64_t cx_frames = _editor->unit_to_frame (cx);
- if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier()) && !_x_constrained) {
- _editor->snap_to (cx_frames);
+ if (!_x_constrained) {
+ _editor->snap_to_with_modifier (cx_frames, event);
}
float const fraction = 1.0 - (cy / _point->line().height());
bool const push = Keyboard::modifier_state_contains (event->button.state, Keyboard::PrimaryModifier);
_point->line().point_drag (*_point, cx_frames, fraction, push);
-
+
_editor->set_verbose_canvas_cursor_text (_point->line().get_verbose_cursor_string (fraction));
}
if (!movement_occurred) {
/* just a click */
-
+
if ((event->type == GDK_BUTTON_RELEASE) && (event->button.button == 1) && Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
_editor->reset_point_selection ();
}
_point->line().end_drag (_point);
}
+bool
+ControlPointDrag::active (Editing::MouseMode m)
+{
+ if (m == Editing::MouseGain) {
+ /* always active in mouse gain */
+ return true;
+ }
+
+ /* otherwise active if the point is on an automation line (ie not if its on a region gain line) */
+ return dynamic_cast<AutomationLine*> (&(_point->line())) != 0;
+}
+
LineDrag::LineDrag (Editor* e, ArdourCanvas::Item* i)
: Drag (e, i),
_line (0),
}
void
-LineDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
+LineDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*cursor*/)
{
_line = reinterpret_cast<AutomationLine*> (_item->get_data ("line"));
assert (_line);
double fraction = 1.0 - (cy / _line->height());
_line->start_drag (0, _grab_frame, fraction);
-
+
_editor->set_verbose_canvas_cursor (_line->get_verbose_cursor_string (fraction),
_current_pointer_x + 10, _current_pointer_y + 10);
-
+
_editor->show_verbose_canvas_cursor ();
}
LineDrag::motion (GdkEvent* event, bool)
{
double dy = _current_pointer_y - _last_pointer_y;
-
+
if (event->button.state & Keyboard::SecondaryModifier) {
dy *= 0.1;
}
}
_line->line_drag (_before, _after, fraction, push);
-
+
_editor->set_verbose_canvas_cursor_text (_line->get_verbose_cursor_string (fraction));
}
return;
}
- if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier()) && Config->get_rubberbanding_snaps_to_grid()) {
+ if (Config->get_rubberbanding_snaps_to_grid()) {
if (first_move) {
- _editor->snap_to (_grab_frame);
- }
- _editor->snap_to (_current_pointer_frame);
+ _editor->snap_to_with_modifier (_grab_frame, event);
+ }
+ _editor->snap_to_with_modifier (_current_pointer_frame, event);
}
/* base start and end on initial click position */
y1 = _grab_y;
}
-
+
if (start != end || y1 != y2) {
double x1 = _editor->frame_to_pixel (start);
double x2 = _editor->frame_to_pixel (end);
-
+
_editor->rubberband_rect->property_x1() = x1;
_editor->rubberband_rect->property_y1() = y1;
_editor->rubberband_rect->property_x2() = x2;
_editor->rubberband_rect->show();
_editor->rubberband_rect->raise_to_top();
-
+
_last_pointer_frame = _current_pointer_frame;
_editor->show_verbose_time_cursor (_current_pointer_frame, 10);
Selection::Operation op = Keyboard::selection_type (event->button.state);
- bool commit;
+ bool committed;
_editor->begin_reversible_command (_("rubberband selection"));
if (_grab_frame < _last_pointer_frame) {
- commit = _editor->select_all_within (_grab_frame, _last_pointer_frame, y1, y2, _editor->track_views, op);
+ committed = _editor->select_all_within (_grab_frame, _last_pointer_frame - 1, y1, y2, _editor->track_views, op);
} else {
- commit = _editor->select_all_within (_last_pointer_frame, _grab_frame, y1, y2, _editor->track_views, op);
- }
+ committed = _editor->select_all_within (_last_pointer_frame, _grab_frame - 1, y1, y2, _editor->track_views, op);
+ }
- if (commit) {
+ if (!committed) {
_editor->commit_reversible_command ();
}
-
+
} else {
if (!getenv("ARDOUR_SAE")) {
_editor->selection->clear_tracks();
TimeFXDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
{
Drag::start_grab (event);
-
+
_editor->show_verbose_time_cursor (_current_pointer_frame, 10);
}
{
RegionView* rv = _primary;
- if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
- _editor->snap_to (_current_pointer_frame);
- }
+ _editor->snap_to_with_modifier (_current_pointer_frame, event);
if (_current_pointer_frame == _last_pointer_frame) {
return;
}
void
-TimeFXDrag::finished (GdkEvent* event, bool movement_occurred)
+TimeFXDrag::finished (GdkEvent* /*event*/, bool movement_occurred)
{
_primary->get_time_axis_view().hide_timestretch ();
/* backwards drag of the left edge - not usable */
return;
}
-
+
nframes64_t newlen = _last_pointer_frame - _primary->region()->position();
float percentage = (double) newlen / (double) _primary->region()->length();
-
+
#ifndef USE_RUBBERBAND
- // Soundtouch uses percentage / 100 instead of normal (/ 1)
+ // Soundtouch uses percentage / 100 instead of normal (/ 1)
if (_primary->region()->data_type() == DataType::AUDIO) {
percentage = (float) ((double) newlen - (double) _primary->region()->length()) / ((double) newlen) * 100.0f;
}
-#endif
-
+#endif
+
_editor->begin_reversible_command (_("timestretch"));
-
+
// XXX how do timeFX on multiple regions ?
-
+
RegionSelection rs;
rs.add (_primary);
}
}
+void
+ScrubDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
+{
+ Drag::start_grab (event);
+}
+
+void
+ScrubDrag::motion (GdkEvent* /*event*/, bool)
+{
+ _editor->scrub ();
+}
+
+void
+ScrubDrag::finished (GdkEvent* /*event*/, bool movement_occurred)
+{
+ if (movement_occurred && _editor->session) {
+ /* make sure we stop */
+ _editor->session->request_transport_speed (0.0);
+ }
+}
+
SelectionDrag::SelectionDrag (Editor* e, ArdourCanvas::Item* i, Operation o)
: Drag (e, i),
_operation (o),
case SelectionStartTrim:
if (_editor->clicked_axisview) {
_editor->clicked_axisview->order_selection_trims (_item, true);
- }
+ }
Drag::start_grab (event, cursor);
cursor = _editor->trimmer_cursor;
start = _editor->selection->time[_editor->clicked_selection].start;
- _pointer_frame_offset = _grab_frame - start;
+ _pointer_frame_offset = _grab_frame - start;
break;
-
+
case SelectionEndTrim:
if (_editor->clicked_axisview) {
_editor->clicked_axisview->order_selection_trims (_item, false);
Drag::start_grab (event, cursor);
cursor = _editor->trimmer_cursor;
end = _editor->selection->time[_editor->clicked_selection].end;
- _pointer_frame_offset = _grab_frame - end;
+ _pointer_frame_offset = _grab_frame - end;
break;
case SelectionMove:
start = _editor->selection->time[_editor->clicked_selection].start;
Drag::start_grab (event, cursor);
- _pointer_frame_offset = _grab_frame - start;
+ _pointer_frame_offset = _grab_frame - start;
break;
}
if (_operation == SelectionMove) {
- _editor->show_verbose_time_cursor (start, 10);
+ _editor->show_verbose_time_cursor (start, 10);
} else {
- _editor->show_verbose_time_cursor (_current_pointer_frame, 10);
+ _editor->show_verbose_time_cursor (_current_pointer_frame, 10);
}
}
nframes64_t end = 0;
nframes64_t length;
- nframes64_t pending_position = adjusted_current_frame ();
-
- if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
- _editor->snap_to (pending_position);
- }
+ nframes64_t const pending_position = adjusted_current_frame (event);
- /* only alter selection if the current frame is
+ /* only alter selection if the current frame is
different from the last frame position (adjusted)
*/
-
+
if (pending_position == _last_pointer_frame) {
return;
}
-
+
switch (_operation) {
case CreateSelection:
-
+
if (first_move) {
_editor->snap_to (_grab_frame);
}
-
+
if (pending_position < _grab_frame) {
start = pending_position;
end = _grab_frame;
end = pending_position;
start = _grab_frame;
}
-
+
/* first drag: Either add to the selection
or create a new selection->
*/
-
+
if (first_move) {
-
+
_editor->begin_reversible_command (_("range selection"));
-
+
if (_copy) {
/* adding to the selection */
_editor->clicked_selection = _editor->selection->add (start, end);
/* new selection-> */
_editor->clicked_selection = _editor->selection->set (_editor->clicked_axisview, start, end);
}
- }
+ }
break;
-
+
case SelectionStartTrim:
-
+
if (first_move) {
_editor->begin_reversible_command (_("trim selection start"));
}
-
+
start = _editor->selection->time[_editor->clicked_selection].start;
end = _editor->selection->time[_editor->clicked_selection].end;
start = pending_position;
}
break;
-
+
case SelectionEndTrim:
-
+
if (first_move) {
_editor->begin_reversible_command (_("trim selection end"));
}
-
+
start = _editor->selection->time[_editor->clicked_selection].start;
end = _editor->selection->time[_editor->clicked_selection].end;
} else {
end = pending_position;
}
-
+
break;
-
+
case SelectionMove:
-
+
if (first_move) {
_editor->begin_reversible_command (_("move selection"));
}
-
+
start = _editor->selection->time[_editor->clicked_selection].start;
end = _editor->selection->time[_editor->clicked_selection].end;
-
+
length = end - start;
-
+
start = pending_position;
_editor->snap_to (start);
-
+
end = start + length;
-
+
break;
}
-
- if (event->button.x >= _editor->horizontal_adjustment.get_value() + _editor->canvas_width) {
+
+ if (event->button.x >= _editor->horizontal_adjustment.get_value() + _editor->_canvas_width) {
_editor->start_canvas_autoscroll (1, 0);
}
_last_pointer_frame = pending_position;
if (_operation == SelectionMove) {
- _editor->show_verbose_time_cursor(start, 10);
+ _editor->show_verbose_time_cursor(start, 10);
} else {
- _editor->show_verbose_time_cursor(pending_position, 10);
+ _editor->show_verbose_time_cursor(pending_position, 10);
}
}
_editor->selection->clear_time();
- }
+ }
}
/* XXX what happens if its a music selection? */
if (!_editor->temp_location) {
_editor->temp_location = new Location;
}
-
+
switch (_operation) {
case CreateRangeMarker:
case CreateTransportMarker:
case CreateCDMarker:
-
+
if (Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
_copy = true;
} else {
Drag::start_grab (event, cursor);
- _editor->show_verbose_time_cursor (_current_pointer_frame, 10);
+ _editor->show_verbose_time_cursor (_current_pointer_frame, 10);
}
void
return;
break;
}
-
- if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
- _editor->snap_to (_current_pointer_frame);
- }
- /* only alter selection if the current frame is
+ _editor->snap_to_with_modifier (_current_pointer_frame, event);
+
+ /* only alter selection if the current frame is
different from the last frame position.
*/
-
+
if (_current_pointer_frame == _last_pointer_frame) {
return;
}
-
+
switch (_operation) {
case CreateRangeMarker:
case CreateTransportMarker:
if (first_move) {
_editor->snap_to (_grab_frame);
}
-
+
if (_current_pointer_frame < _grab_frame) {
start = _current_pointer_frame;
end = _grab_frame;
end = _current_pointer_frame;
start = _grab_frame;
}
-
+
/* first drag: Either add to the selection
or create a new selection.
*/
-
+
if (first_move) {
-
+
_editor->temp_location->set (start, end);
-
+
crect->show ();
update_item (_editor->temp_location);
_drag_rect->show();
//_drag_rect->raise_to_top();
-
- }
- break;
+
+ }
+ break;
}
-
- if (event->button.x >= _editor->horizontal_adjustment.get_value() + _editor->canvas_width) {
+
+ if (event->button.x >= _editor->horizontal_adjustment.get_value() + _editor->_canvas_width) {
_editor->start_canvas_autoscroll (1, 0);
}
-
+
if (start != end) {
_editor->temp_location->set (start, end);
_last_pointer_frame = _current_pointer_frame;
- _editor->show_verbose_time_cursor (_current_pointer_frame, 10);
-
+ _editor->show_verbose_time_cursor (_current_pointer_frame, 10);
+
}
void
Location * newloc = 0;
string rangename;
int flags;
-
+
if (movement_occurred) {
motion (event, false);
+ _drag_rect->hide();
switch (_operation) {
case CreateRangeMarker:
XMLNode &after = _editor->session->locations()->get_state();
_editor->session->add_command(new MementoCommand<Locations>(*(_editor->session->locations()), &before, &after));
_editor->commit_reversible_command ();
-
- _drag_rect->hide();
break;
}
case CreateTransportMarker:
// popup menu to pick loop or punch
_editor->new_transport_marker_context_menu (&event->button, _item);
-
break;
}
} else {
start = _editor->session->locations()->first_mark_before (_grab_frame);
end = _editor->session->locations()->first_mark_after (_grab_frame);
-
+
if (end == max_frames) {
end = _editor->session->current_end_frame ();
}
default:
break;
}
- }
+ }
}
_editor->stop_canvas_autoscroll ();
nframes64_t start;
nframes64_t end;
- if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
- _editor->snap_to (_current_pointer_frame);
-
- if (first_move) {
- _editor->snap_to (_grab_frame);
- }
+ _editor->snap_to_with_modifier (_current_pointer_frame, event);
+
+ if (first_move) {
+ _editor->snap_to_with_modifier (_grab_frame, event);
}
-
+
if (_current_pointer_frame == _last_pointer_frame) {
return;
}
end = _current_pointer_frame;
start = _grab_frame;
}
-
+
if (start != end) {
if (first_move) {
{
if (movement_occurred) {
motion (event, false);
-
+
if (_grab_frame < _last_pointer_frame) {
_editor->temporal_zoom_by_frame (_grab_frame, _last_pointer_frame, "mouse zoom");
} else {
_editor->temporal_zoom_by_frame (_last_pointer_frame, _grab_frame, "mouse zoom");
- }
+ }
} else {
_editor->temporal_zoom_to_frame (false, _grab_frame);
/*
_editor->zoom_rect->hide();
}
+
+NoteDrag::NoteDrag (Editor* e, ArdourCanvas::Item* i)
+ : Drag (e, i)
+{
+ CanvasNoteEvent* cnote = dynamic_cast<CanvasNoteEvent*>(_item);
+ region = &cnote->region_view();
+}
+
+void
+NoteDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
+{
+ Drag::start_grab (event);
+
+ drag_delta_x = 0;
+ drag_delta_note = 0;
+
+ double event_x;
+ double event_y;
+
+ event_x = _current_pointer_x;
+ event_y = _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())) {
+
+ /* tertiary-click means extend selection - we'll do that on button release,
+ so don't add it here, because otherwise we make it hard to figure
+ out the "extend-to" range.
+ */
+
+ bool extend = Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier);
+
+ if (!extend) {
+ bool add = Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier);
+
+ if (add) {
+ region->note_selected (cnote, true);
+ } else {
+ region->unique_select (cnote);
+ }
+ }
+ }
+}
+
+void
+NoteDrag::motion (GdkEvent*, bool)
+{
+ MidiStreamView* streamview = region->midi_stream_view();
+ double event_x;
+ double event_y;
+
+ event_x = _current_pointer_x;
+ event_y = _current_pointer_y;
+
+ _item->property_parent().get_value()->w2i(event_x, event_y);
+
+ event_x = region->snap_to_pixel(event_x);
+
+ double dx = event_x - last_x;
+ double dy = event_y - last_y;
+ last_x = event_x;
+
+ drag_delta_x += dx;
+
+ // Snap to note rows
+
+ if (abs (dy) < streamview->note_height()) {
+ dy = 0.0;
+ } else {
+ int8_t this_delta_note;
+ if (dy > 0) {
+ this_delta_note = (int8_t)ceil(dy / streamview->note_height() / 2.0);
+ } else {
+ this_delta_note = (int8_t)floor(dy / streamview->note_height() / 2.0);
+ }
+ drag_delta_note -= this_delta_note;
+ dy = streamview->note_height() * this_delta_note;
+ last_y = last_y + dy;
+ }
+
+ if (dx || dy) {
+ region->move_selection (dx, dy);
+
+ CanvasNoteEvent* cnote = dynamic_cast<CanvasNoteEvent*>(_item);
+ char buf[4];
+ snprintf (buf, sizeof (buf), "%g", (int) cnote->note()->note() + drag_delta_note);
+ //editor.show_verbose_canvas_cursor_with (Evoral::midi_note_name (ev->note()->note()));
+ _editor->show_verbose_canvas_cursor_with (buf);
+ }
+}
+
+void
+NoteDrag::finished (GdkEvent* ev, bool moved)
+{
+ ArdourCanvas::CanvasNote* cnote = dynamic_cast<ArdourCanvas::CanvasNote*>(_item);
+
+ if (!moved) {
+ if (_editor->current_mouse_mode() == Editing::MouseObject) {
+
+ if (was_selected) {
+ bool add = Keyboard::modifier_state_equals (ev->button.state, Keyboard::PrimaryModifier);
+ if (add) {
+ region->note_deselected (cnote);
+ }
+ } else {
+ bool extend = Keyboard::modifier_state_equals (ev->button.state, Keyboard::TertiaryModifier);
+ bool add = Keyboard::modifier_state_equals (ev->button.state, Keyboard::PrimaryModifier);
+
+ if (!extend && !add && region->selection_size() > 1) {
+ region->unique_select(cnote);
+ } else if (extend) {
+ region->note_selected (cnote, true, true);
+ } else {
+ /* it was added during button press */
+ }
+ }
+ }
+ } else {
+ region->note_dropped (cnote, drag_delta_x, drag_delta_note);
+ }
+}
projects / ardour.git / blobdiff