#include "canvas/scroll_group.h"
#include "editor.h"
-#include "i18n.h"
+#include "pbd/i18n.h"
#include "keyboard.h"
#include "audio_region_view.h"
#include "automation_region_view.h"
, _grab_frame (0)
, _last_pointer_frame (0)
, _snap_delta (0)
+ , _constraint_pressed (false)
{
}
{
/* we set up x/y dragging constraints on first move */
+ _constraint_pressed = ArdourKeyboard::indicates_constraint (event->button.state);
_raw_grab_frame = _editor->canvas_event_sample (event, &_grab_x, &_grab_y);
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 ())) {
+ if (_constraint_pressed) {
_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 ())) {
+ } else if (_constraint_pressed) {
// if dragging normally, the motion is constrained to the first direction of movement.
if (_initially_vertical) {
_x_constrained = true;
}
boost::shared_ptr<Region>
-Drag::add_midi_region (MidiTimeAxisView* view, bool commit)
+Drag::add_midi_region (MidiTimeAxisView* view, bool commit, const int32_t sub_num)
{
if (_editor->session()) {
const TempoMap& map (_editor->session()->tempo_map());
framecnt_t pos = grab_frame();
- const Meter& m = map.meter_at (pos);
/* not that the frame rate used here can be affected by pull up/down which
might be wrong.
*/
- framecnt_t len = m.frames_per_bar (map.tempo_at (pos), _editor->session()->frame_rate());
- return view->add_region (grab_frame(), len, commit);
+ framecnt_t len = map.frame_at_beat (max (0.0, map.beat_at_frame (pos)) + 1.0) - pos;
+ return view->add_region (grab_frame(), len, commit, sub_num);
}
return boost::shared_ptr<Region>();
}
-struct EditorOrderTimeAxisViewSorter {
+struct PresentationInfoTimeAxisViewSorter {
bool operator() (TimeAxisView* a, TimeAxisView* b) {
- RouteTimeAxisView* ra = dynamic_cast<RouteTimeAxisView*> (a);
- RouteTimeAxisView* rb = dynamic_cast<RouteTimeAxisView*> (b);
- assert (ra && rb);
- return ra->route()->order_key () < rb->route()->order_key ();
+ return a->stripable()->presentation_info().order() < b->stripable()->presentation_info().order();
}
};
*/
TrackViewList track_views = _editor->track_views;
- track_views.sort (EditorOrderTimeAxisViewSorter ());
+ track_views.sort (PresentationInfoTimeAxisViewSorter ());
for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
_time_axis_views.push_back (*i);
return i;
}
+/** determines if @pos is the closest frame to an exact musical division when using SnapMagnetic.
+ * (SnapMagnetic may snap to an exact division or no division at all).
+ * this is a hotfix for musical region position/trim. we should really
+ * deliver musical divisors when snapping magnetically to avoid this.
+*/
+int32_t
+RegionDrag::current_music_divisor (framepos_t pos, int32_t button_state)
+{
+ int32_t divisions = _editor->get_grid_music_divisions (button_state);
+
+ if (_editor->snap_mode() == Editing::SnapMagnetic && !ArdourKeyboard::indicates_snap (button_state)) {
+ TempoMap& tmap (_editor->session()->tempo_map());
+ const framepos_t exact_qn_pos = tmap.frame_at_quarter_note (tmap.exact_qn_at_frame (pos, divisions));
+
+ if (pos != exact_qn_pos) {
+ /* magnetic has not snapped */
+ divisions = 0;
+ }
+ }
+
+ return divisions;
+}
+
RegionMotionDrag::RegionMotionDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v, bool b)
: RegionDrag (e, i, p, v)
, _brushing (b)
RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tv);
if (!rtv || !rtv->is_track()) {
- /* ignore busses early on. we can't move any regions on them */
+ /* ignore non-tracks 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)
MidiRegionView* mrv = dynamic_cast<MidiRegionView*>(rv);
const boost::shared_ptr<const Region> original = rv->region();
- boost::shared_ptr<Region> region_copy = RegionFactory::create (original, true);
- region_copy->set_position (original->position());
+ boost::shared_ptr<Region> region_copy = RegionFactory::create (original, true
+ , current_music_divisor (original->position(), event->button.state));
/* need to set this so that the drop zone code can work. This doesn't
actually put the region into the playlist, but just sets a weak pointer
to it.
finished_copy (
changed_position,
changed_tracks,
- drag_delta
+ drag_delta,
+ ev->button.state
);
} else {
finished_no_copy (
changed_position,
changed_tracks,
- drag_delta
+ drag_delta,
+ ev->button.state
);
}
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());
+ audio_tracks = _editor->session()->new_audio_track (region->n_channels(), output_chan, 0, 1, region->name(), PresentationInfo::max_order);
+ TimeAxisView* tav =_editor->axis_view_from_stripable (audio_tracks.front());
+ if (tav) {
+ tav->set_height (original->current_height());
}
- return rtav;
+ return dynamic_cast<RouteTimeAxisView*>(tav);
} else {
ChanCount one_midi_port (DataType::MIDI, 1);
list<boost::shared_ptr<MidiTrack> > midi_tracks;
- midi_tracks = _editor->session()->new_midi_track (one_midi_port, one_midi_port, boost::shared_ptr<ARDOUR::PluginInfo>(), ARDOUR::Normal, 0, 1, region->name());
- RouteTimeAxisView* rtav = _editor->axis_view_from_route (midi_tracks.front());
- if (rtav) {
- rtav->set_height (original->current_height());
+ midi_tracks = _editor->session()->new_midi_track (one_midi_port, one_midi_port, boost::shared_ptr<ARDOUR::PluginInfo>(),
+ (ARDOUR::Plugin::PresetRecord*) 0,
+ (ARDOUR::RouteGroup*) 0, 1, region->name(), PresentationInfo::max_order);
+ TimeAxisView* tav = _editor->axis_view_from_stripable (midi_tracks.front());
+ if (tav) {
+ tav->set_height (original->current_height());
}
- return rtav;
+ return dynamic_cast<RouteTimeAxisView*> (tav);
}
} catch (...) {
error << _("Could not create new track after region placed in the drop zone") << endmsg;
}
void
-RegionMoveDrag::finished_copy (bool const changed_position, bool const /*changed_tracks*/, framecnt_t const drag_delta)
+RegionMoveDrag::finished_copy (bool const changed_position, bool const /*changed_tracks*/, framecnt_t const drag_delta, int32_t const ev_state)
{
RegionSelection new_views;
PlaylistSet modified_playlists;
}
if (dest_rtv != 0) {
- RegionView* new_view = insert_region_into_playlist (i->view->region(), dest_rtv, i->layer, where, modified_playlists);
+ RegionView* new_view = insert_region_into_playlist (i->view->region(), dest_rtv, i->layer, where,
+ modified_playlists, current_music_divisor (where, ev_state));
+
if (new_view != 0) {
new_views.push_back (new_view);
}
RegionMoveDrag::finished_no_copy (
bool const changed_position,
bool const changed_tracks,
- framecnt_t const drag_delta
+ framecnt_t const drag_delta,
+ int32_t const ev_state
)
{
RegionSelection new_views;
typedef map<boost::shared_ptr<Playlist>, RouteTimeAxisView*> PlaylistMapping;
PlaylistMapping playlist_mapping;
+ std::set<boost::shared_ptr<const Region> > uniq;
for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ) {
RegionView* rv = i->view;
continue;
}
+ if (uniq.find (rv->region()) != uniq.end()) {
+ /* prevent duplicate moves when selecting regions from shared playlists */
+ ++i;
+ continue;
+ }
+ uniq.insert(rv->region());
+
if (i->time_axis_view < 0 || i->time_axis_view >= (int)_time_axis_views.size()) {
/* dragged to drop zone */
/* insert into new playlist */
RegionView* new_view = insert_region_into_playlist (
- RegionFactory::create (rv->region (), true), dest_rtv, dest_layer, where, modified_playlists
+ RegionFactory::create (rv->region (), true), dest_rtv, dest_layer, where,
+ modified_playlists, current_music_divisor (where, ev_state)
);
if (new_view == 0) {
playlist->freeze ();
}
- rv->region()->set_position (where);
+ rv->region()->set_position (where, current_music_divisor (where, ev_state));
_editor->session()->add_command (new StatefulDiffCommand (rv->region()));
}
RouteTimeAxisView* dest_rtv,
layer_t dest_layer,
framecnt_t where,
- PlaylistSet& modified_playlists
+ PlaylistSet& modified_playlists,
+ const int32_t sub_num
)
{
boost::shared_ptr<Playlist> dest_playlist = dest_rtv->playlist ();
if (r.second) {
dest_playlist->clear_changes ();
}
-
- dest_playlist->add_region (region, where);
+ dest_playlist->add_region (region, where, 1.0, false, sub_num);
if (dest_rtv->view()->layer_display() == Stacked || dest_rtv->view()->layer_display() == Expanded) {
dest_playlist->set_layer (region, dest_layer);
}
void
-RegionInsertDrag::finished (GdkEvent *, bool)
+RegionInsertDrag::finished (GdkEvent * event, bool)
{
int pos = _views.front().time_axis_view;
assert(pos >= 0 && pos < (int)_time_axis_views.size());
{
if (first_move) {
_editor->begin_reversible_command (_("create region"));
- _region = add_midi_region (_view, false);
+ _region = add_midi_region (_view, false, _editor->get_grid_music_divisions (event->button.state));
_view->playlist()->freeze ();
} else {
if (_region) {
*/
framecnt_t const len = (framecnt_t) fabs ((double)(f - grab_frame () - 1));
- _region->set_length (len < 1 ? 1 : len);
+ _region->set_length (len < 1 ? 1 : len, _editor->get_grid_music_divisions (event->button.state));
}
}
}
void
-RegionCreateDrag::finished (GdkEvent*, bool movement_occurred)
+RegionCreateDrag::finished (GdkEvent* event, bool movement_occurred)
{
if (!movement_occurred) {
- add_midi_region (_view, true);
+ add_midi_region (_view, true, _editor->get_grid_music_divisions (event->button.state));
} else {
_view->playlist()->thaw ();
_editor->commit_reversible_command();
for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
RegionView* rv = i->view;
- rv->enable_display (false);
rv->region()->playlist()->clear_owned_changes ();
if (_operation == StartTrim) {
}
}
+ int32_t divisions = current_music_divisor (adj_frame, event->button.state);
switch (_operation) {
case StartTrim:
for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
- bool changed = i->view->trim_front (i->initial_position + dt, non_overlap_trim);
+ bool changed = i->view->trim_front (i->initial_position + dt, non_overlap_trim
+ , divisions);
+
if (changed && _preserve_fade_anchor) {
AudioRegionView* arv = dynamic_cast<AudioRegionView*> (i->view);
if (arv) {
case EndTrim:
for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
- bool changed = i->view->trim_end (i->initial_end + dt, non_overlap_trim);
+ bool changed = i->view->trim_end (i->initial_end + dt, non_overlap_trim, divisions);
if (changed && _preserve_fade_anchor) {
AudioRegionView* arv = dynamic_cast<AudioRegionView*> (i->view);
if (arv) {
behind which may be slightly odd from the user's point of view.
*/
- finished (0, true);
+ GdkEvent ev;
+ finished (&ev, true);
if (movement_occurred) {
- _editor->undo ();
+ _editor->session()->undo (1);
}
for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
}
MeterMarkerDrag::MeterMarkerDrag (Editor* e, ArdourCanvas::Item* i, bool c)
- : Drag (e, i),
- _copy (c)
+ : Drag (e, i)
+ , _copy (c)
+ , _old_snap_type (e->snap_type())
+ , _old_snap_mode (e->snap_mode())
, before_state (0)
{
DEBUG_TRACE (DEBUG::Drags, "New MeterMarkerDrag\n");
_marker = reinterpret_cast<MeterMarker*> (_item->get_data ("marker"));
assert (_marker);
+ _real_section = &_marker->meter();
+
}
void
void
MeterMarkerDrag::motion (GdkEvent* event, bool first_move)
{
- if (!_marker->meter().movable()) {
- return;
- }
-
if (first_move) {
-
- // create a dummy marker for visual representation of moving the
- // section, because whether its a copy or not, we're going to
- // leave or lose the original marker (leave if its a copy; lose if its
- // not, because we'll remove it from the map).
-
- MeterSection section (_marker->meter());
-
- if (!section.movable()) {
- return;
- }
+ // create a dummy marker to catch events, then hide it.
char name[64];
snprintf (name, sizeof(name), "%g/%g", _marker->meter().divisions_per_bar(), _marker->meter().note_divisor ());
/* use the new marker for the grab */
swap_grab (&_marker->the_item(), 0, GDK_CURRENT_TIME);
+ _marker->hide();
+
+ TempoMap& map (_editor->session()->tempo_map());
+ /* get current state */
+ before_state = &map.get_state();
if (!_copy) {
- TempoMap& map (_editor->session()->tempo_map());
- /* get current state */
- before_state = &map.get_state();
- /* remove the section while we drag it */
- map.remove_meter (section, true);
+ _editor->begin_reversible_command (_("move meter mark"));
+ } else {
+ _editor->begin_reversible_command (_("copy meter mark"));
+
+ Timecode::BBT_Time bbt = _real_section->bbt();
+
+ /* we can't add a meter where one currently exists */
+ if (_real_section->frame() < adjusted_current_frame (event, false)) {
+ ++bbt.bars;
+ } else {
+ --bbt.bars;
+ }
+ const double beat = map.beat_at_bbt (bbt);
+ _real_section = map.add_meter (Meter (_marker->meter().divisions_per_bar(), _marker->meter().note_divisor())
+ , beat, bbt, _real_section->position_lock_style());
+ if (!_real_section) {
+ aborted (true);
+ return;
+ }
+
+ }
+ /* only snap to bars. leave snap mode alone for audio locked meters.*/
+ if (_real_section->position_lock_style() != AudioTime) {
+ _editor->set_snap_to (SnapToBar);
+ _editor->set_snap_mode (SnapNormal);
}
}
- framepos_t const pf = adjusted_current_frame (event);
+ framepos_t pf = adjusted_current_frame (event);
- _marker->set_position (pf);
- show_verbose_cursor_time (pf);
+ if (_real_section->position_lock_style() == AudioTime && _editor->snap_musical()) {
+ /* never snap to music for audio locked */
+ pf = adjusted_current_frame (event, false);
+ }
+
+ _editor->session()->tempo_map().gui_move_meter (_real_section, pf);
+
+ /* fake marker meeds to stay under the mouse, unlike the real one. */
+ _marker->set_position (adjusted_current_frame (event, false));
+
+ show_verbose_cursor_time (_real_section->frame());
}
void
return;
}
- if (!_marker->meter().movable()) {
- return;
- }
-
- motion (event, false);
-
- Timecode::BBT_Time when;
+ /* reinstate old snap setting */
+ _editor->set_snap_to (_old_snap_type);
+ _editor->set_snap_mode (_old_snap_mode);
TempoMap& map (_editor->session()->tempo_map());
- map.bbt_time (_marker->position(), when);
-
- if (_copy == true) {
- _editor->begin_reversible_command (_("copy meter mark"));
- XMLNode &before = map.get_state();
- map.add_meter (_marker->meter(), when);
- XMLNode &after = map.get_state();
- _editor->session()->add_command(new MementoCommand<TempoMap>(map, &before, &after));
- _editor->commit_reversible_command ();
-
- } else {
- _editor->begin_reversible_command (_("move meter mark"));
-
- /* we removed it before, so add it back now */
- map.add_meter (_marker->meter(), when);
- XMLNode &after = map.get_state();
- _editor->session()->add_command(new MementoCommand<TempoMap>(map, before_state, &after));
- _editor->commit_reversible_command ();
- }
+ XMLNode &after = map.get_state();
+ _editor->session()->add_command(new MementoCommand<TempoMap>(map, before_state, &after));
+ _editor->commit_reversible_command ();
// delete the dummy marker we used for visual representation while moving.
// a new visual marker will show up automatically.
MeterMarkerDrag::aborted (bool moved)
{
_marker->set_position (_marker->meter().frame ());
-
if (moved) {
- TempoMap& map (_editor->session()->tempo_map());
- /* we removed it before, so add it back now */
- map.add_meter (_marker->meter(), _marker->meter().frame());
+ /* reinstate old snap setting */
+ _editor->set_snap_to (_old_snap_type);
+ _editor->set_snap_mode (_old_snap_mode);
+
+ _editor->session()->tempo_map().set_state (*before_state, Stateful::current_state_version);
// delete the dummy marker we used for visual representation while moving.
// a new visual marker will show up automatically.
delete _marker;
TempoMarkerDrag::TempoMarkerDrag (Editor* e, ArdourCanvas::Item* i, bool c)
: Drag (e, i)
, _copy (c)
+ , _grab_bpm (0.0)
, before_state (0)
{
DEBUG_TRACE (DEBUG::Drags, "New TempoMarkerDrag\n");
_marker = reinterpret_cast<TempoMarker*> (_item->get_data ("marker"));
+ _real_section = &_marker->tempo();
+ _movable = _real_section->movable();
+ _grab_bpm = _real_section->note_types_per_minute();
assert (_marker);
}
TempoMarkerDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
{
Drag::start_grab (event, cursor);
- show_verbose_cursor_time (adjusted_current_frame (event));
+ if (!_real_section->active()) {
+ show_verbose_cursor_text (_("inactive"));
+ } else {
+ show_verbose_cursor_time (adjusted_current_frame (event));
+ }
}
void
TempoMarkerDrag::setup_pointer_frame_offset ()
{
- _pointer_frame_offset = raw_grab_frame() - _marker->tempo().frame();
+ _pointer_frame_offset = raw_grab_frame() - _real_section->frame();
}
void
TempoMarkerDrag::motion (GdkEvent* event, bool first_move)
{
- if (!_marker->tempo().movable()) {
+ if (!_real_section->active()) {
return;
}
if (first_move) {
- // create a dummy marker for visual representation of moving the
- // section, because whether its a copy or not, we're going to
- // leave or lose the original marker (leave if its a copy; lose if its
- // not, because we'll remove it from the map).
-
- // create a dummy marker for visual representation of moving the copy.
- // The actual copying is not done before we reach the finish callback.
+ // mvc drag - create a dummy marker to catch events, hide it.
char name[64];
- snprintf (name, sizeof (name), "%.2f", _marker->tempo().beats_per_minute());
+ snprintf (name, sizeof (name), "%.2f", _marker->tempo().note_types_per_minute());
TempoSection section (_marker->tempo());
/* use the new marker for the grab */
swap_grab (&_marker->the_item(), 0, GDK_CURRENT_TIME);
+ _marker->hide();
+
+ TempoMap& map (_editor->session()->tempo_map());
+ /* get current state */
+ before_state = &map.get_state();
if (!_copy) {
_editor->begin_reversible_command (_("move tempo mark"));
- TempoMap& map (_editor->session()->tempo_map());
- /* get current state */
- before_state = &map.get_state();
- /* remove the section while we drag it */
- map.remove_tempo (section, true);
+
+ } else {
+ const Tempo tempo (_marker->tempo());
+ const framepos_t frame = adjusted_current_frame (event) + 1;
+ const TempoSection::Type type = _real_section->type();
+
+ _editor->begin_reversible_command (_("copy tempo mark"));
+
+ if (_real_section->position_lock_style() == MusicTime) {
+ const int32_t divisions = _editor->get_grid_music_divisions (event->button.state);
+ _real_section = map.add_tempo (tempo, map.exact_qn_at_frame (frame, divisions), 0, type, MusicTime);
+ } else {
+ _real_section = map.add_tempo (tempo, 0.0, frame, type, AudioTime);
+ }
+
+ if (!_real_section) {
+ aborted (true);
+ return;
+ }
}
+
}
- framepos_t const pf = adjusted_current_frame (event);
- _marker->set_position (pf);
- show_verbose_cursor_time (pf);
+ if (ArdourKeyboard::indicates_constraint (event->button.state)) {
+ /* use vertical movement to alter tempo .. should be log */
+ double new_bpm = max (1.5, _grab_bpm + ((grab_y() - min (-1.0, current_pointer_y())) / 5.0));
+ stringstream strs;
+ _editor->session()->tempo_map().gui_change_tempo (_real_section, Tempo (new_bpm, _real_section->note_type()));
+ strs << new_bpm;
+ show_verbose_cursor_text (strs.str());
+
+ } else if (_movable && !_real_section->locked_to_meter()) {
+ framepos_t pf;
+
+ if (_editor->snap_musical()) {
+ /* we can't snap to a grid that we are about to move.
+ * gui_move_tempo() will sort out snap using the supplied beat divisions.
+ */
+ pf = adjusted_current_frame (event, false);
+ } else {
+ pf = adjusted_current_frame (event);
+ }
+
+ TempoMap& map (_editor->session()->tempo_map());
+
+ /* snap to beat is 1, snap to bar is -1 (sorry) */
+ const int sub_num = _editor->get_grid_music_divisions (event->button.state);
+
+ map.gui_move_tempo (_real_section, pf, sub_num);
+
+ show_verbose_cursor_time (_real_section->frame());
+ }
+ _marker->set_position (adjusted_current_frame (event, false));
}
void
TempoMarkerDrag::finished (GdkEvent* event, bool movement_occurred)
{
+ if (!_real_section->active()) {
+ return;
+ }
if (!movement_occurred) {
if (was_double_click()) {
_editor->edit_tempo_marker (*_marker);
return;
}
- if (!_marker->tempo().movable()) {
- return;
- }
-
- motion (event, false);
-
TempoMap& map (_editor->session()->tempo_map());
- framepos_t beat_time = map.round_to_beat (_marker->position(), RoundNearest);
- Timecode::BBT_Time when;
- map.bbt_time (beat_time, when);
-
- if (_copy == true) {
- _editor->begin_reversible_command (_("copy tempo mark"));
- XMLNode &before = map.get_state();
- map.add_tempo (_marker->tempo(), when);
- XMLNode &after = map.get_state();
- _editor->session()->add_command (new MementoCommand<TempoMap>(map, &before, &after));
- _editor->commit_reversible_command ();
-
- } else {
- /* we removed it before, so add it back now */
- map.add_tempo (_marker->tempo(), when);
- XMLNode &after = map.get_state();
- _editor->session()->add_command (new MementoCommand<TempoMap>(map, before_state, &after));
- _editor->commit_reversible_command ();
- }
+ XMLNode &after = map.get_state();
+ _editor->session()->add_command (new MementoCommand<TempoMap>(map, before_state, &after));
+ _editor->commit_reversible_command ();
// delete the dummy marker we used for visual representation while moving.
// a new visual marker will show up automatically.
_marker->set_position (_marker->tempo().frame());
if (moved) {
TempoMap& map (_editor->session()->tempo_map());
- /* we removed it before, so add it back now */
- map.add_tempo (_marker->tempo(), _marker->tempo().start());
- // delete the dummy marker we used for visual representation while moving.
- // a new visual marker will show up automatically.
+ map.set_state (*before_state, Stateful::current_state_version);
+ // delete the dummy (hidden) marker we used for events while moving.
delete _marker;
}
}
+BBTRulerDrag::BBTRulerDrag (Editor* e, ArdourCanvas::Item* i)
+ : Drag (e, i)
+ , _grab_qn (0.0)
+ , _tempo (0)
+ , before_state (0)
+{
+ DEBUG_TRACE (DEBUG::Drags, "New BBTRulerDrag\n");
+
+}
+
+void
+BBTRulerDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
+{
+ Drag::start_grab (event, cursor);
+ TempoMap& map (_editor->session()->tempo_map());
+ _tempo = const_cast<TempoSection*> (&map.tempo_section_at_frame (raw_grab_frame()));
+ ostringstream sstr;
+
+ sstr << "^" << fixed << setprecision(3) << map.tempo_at_frame (adjusted_current_frame (event)).note_types_per_minute() << "\n";
+ sstr << "<" << fixed << setprecision(3) << _tempo->note_types_per_minute();
+ show_verbose_cursor_text (sstr.str());
+ finished (event, false);
+}
+
+void
+BBTRulerDrag::setup_pointer_frame_offset ()
+{
+ TempoMap& map (_editor->session()->tempo_map());
+ const double beat_at_frame = max (0.0, map.beat_at_frame (raw_grab_frame()));
+ const uint32_t divisions = _editor->get_grid_beat_divisions (0);
+ double beat = 0.0;
+
+ if (divisions > 0) {
+ beat = floor (beat_at_frame) + (floor (((beat_at_frame - floor (beat_at_frame)) * divisions)) / divisions);
+ } else {
+ /* while it makes some sense for the user to determine the division to 'grab',
+ grabbing a bar often leads to confusing results wrt the actual tempo section being altered
+ and the result over steep tempo curves. Use sixteenths.
+ */
+ beat = floor (beat_at_frame) + (floor (((beat_at_frame - floor (beat_at_frame)) * 4)) / 4);
+ }
+
+ _grab_qn = map.quarter_note_at_beat (beat);
+
+ _pointer_frame_offset = raw_grab_frame() - map.frame_at_quarter_note (_grab_qn);
+
+}
+
+void
+BBTRulerDrag::motion (GdkEvent* event, bool first_move)
+{
+ TempoMap& map (_editor->session()->tempo_map());
+
+ if (first_move) {
+ /* get current state */
+ before_state = &map.get_state();
+ _editor->begin_reversible_command (_("dilate tempo"));
+ }
+
+ framepos_t pf;
+
+ if (_editor->snap_musical()) {
+ pf = adjusted_current_frame (event, false);
+ } else {
+ pf = adjusted_current_frame (event);
+ }
+
+ if (ArdourKeyboard::indicates_constraint (event->button.state)) {
+ /* adjust previous tempo to match pointer frame */
+ _editor->session()->tempo_map().gui_dilate_tempo (_tempo, map.frame_at_quarter_note (_grab_qn), pf);
+ }
+ ostringstream sstr;
+ sstr << "^" << fixed << setprecision(3) << map.tempo_at_frame (pf).note_types_per_minute() << "\n";
+ sstr << "<" << fixed << setprecision(3) << _tempo->note_types_per_minute();
+ show_verbose_cursor_text (sstr.str());
+}
+
+void
+BBTRulerDrag::finished (GdkEvent* event, bool movement_occurred)
+{
+ if (!movement_occurred) {
+ return;
+ }
+
+ TempoMap& map (_editor->session()->tempo_map());
+
+ XMLNode &after = map.get_state();
+ _editor->session()->add_command(new MementoCommand<TempoMap>(map, before_state, &after));
+ _editor->commit_reversible_command ();
+}
+
+void
+BBTRulerDrag::aborted (bool moved)
+{
+ if (moved) {
+ _editor->session()->tempo_map().set_state (*before_state, Stateful::current_state_version);
+ }
+}
+
+
CursorDrag::CursorDrag (Editor* e, EditorCursor& c, bool s)
: Drag (e, &c.track_canvas_item(), false)
, _cursor (c)
, _selection_changed (false)
{
DEBUG_TRACE (DEBUG::Drags, "New MarkerDrag\n");
-
+ Gtk::Window* toplevel = _editor->current_toplevel();
_marker = reinterpret_cast<ArdourMarker*> (_item->get_data ("marker"));
+
assert (_marker);
_points.push_back (ArdourCanvas::Duple (0, 0));
- _points.push_back (ArdourCanvas::Duple (0, physical_screen_height (_editor->get_window())));
+
+ _points.push_back (ArdourCanvas::Duple (0, toplevel ? physical_screen_height (toplevel->get_window()) : 900));
}
MarkerDrag::~MarkerDrag ()
if (move_both || (*x).move_both) {
copy_location->set_start (new_start);
copy_location->set_end (new_end);
- } else if (new_start < copy_location->end()) {
+ } else if (new_start < copy_location->end()) {
copy_location->set_start (new_start);
} else if (newframe > 0) {
//_editor->snap_to (next, RoundUpAlways, true);
} else {
location->set (((*x).location)->start(), ((*x).location)->end());
}
+
+ if (location->is_session_range()) {
+ _editor->session()->set_end_is_free (false);
+ }
}
}
}
void
-MarkerDrag::aborted (bool movement_occured)
+MarkerDrag::aborted (bool movement_occurred)
{
- if (!movement_occured) {
+ if (!movement_occurred) {
return;
}
// start the grab at the center of the control point so
// the point doesn't 'jump' to the mouse after the first drag
- _fixed_grab_x = _point->get_x();
+ _fixed_grab_x = _point->get_x() + _editor->sample_to_pixel_unrounded (_point->line().offset());
_fixed_grab_y = _point->get_y();
framepos_t pos = _editor->pixel_to_sample (_fixed_grab_x);
}
framepos_t cx_frames = _editor->pixel_to_sample (cx) + snap_delta (event->button.state);
-
if (!_x_constrained && need_snap) {
_editor->snap_to_with_modifier (cx_frames, event);
}
cx_frames -= snap_delta (event->button.state);
- cx_frames = min (cx_frames, _point->line().maximum_time());
+ cx_frames = min (cx_frames, _point->line().maximum_time() + _point->line().offset());
float const fraction = 1.0 - (cy / _point->line().height());
}
void
-LineDrag::finished (GdkEvent* event, bool movement_occured)
+LineDrag::finished (GdkEvent* event, bool movement_occurred)
{
- if (movement_occured) {
+ if (movement_occurred) {
motion (event, false);
_line->end_drag (false, 0);
_editor->commit_reversible_command ();
/* MIDI track */
if (_editor->selection->empty() && _editor->mouse_mode == MouseDraw) {
/* nothing selected */
- add_midi_region (mtv, true);
+ add_midi_region (mtv, true, _editor->get_grid_music_divisions(event->button.state));
do_deselect = false;
}
}
}
void
-TimeFXDrag::finished (GdkEvent* /*event*/, bool movement_occurred)
+TimeFXDrag::finished (GdkEvent* event, bool movement_occurred)
{
- _primary->get_time_axis_view().hide_timestretch ();
+ /* this may have been a single click, no drag. We still want the dialog
+ to show up in that case, so that the user can manually edit the
+ parameters for the timestretch.
+ */
- if (!movement_occurred) {
- return;
- }
+ float fraction = 1.0;
- if (last_pointer_frame() < _primary->region()->position()) {
- /* backwards drag of the left edge - not usable */
- return;
- }
+ if (movement_occurred) {
+
+ motion (event, false);
+
+ _primary->get_time_axis_view().hide_timestretch ();
+
+ framepos_t adjusted_frame_pos = adjusted_current_frame (event);
- framecnt_t newlen = last_pointer_frame() - _primary->region()->position();
+ if (adjusted_frame_pos < _primary->region()->position()) {
+ /* backwards drag of the left edge - not usable */
+ return;
+ }
+
+ framecnt_t newlen = adjusted_frame_pos - _primary->region()->position();
- float percentage = (double) newlen / (double) _primary->region()->length();
+ fraction = (double) newlen / (double) _primary->region()->length();
#ifndef USE_RUBBERBAND
- // 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;
- }
+ // Soundtouch uses fraction / 100 instead of normal (/ 1)
+ if (_primary->region()->data_type() == DataType::AUDIO) {
+ fraction = (float) ((double) newlen - (double) _primary->region()->length()) / ((double) newlen) * 100.0f;
+ }
#endif
+ }
if (!_editor->get_selection().regions.empty()) {
/* primary will already be included in the selection, and edit
selection.
*/
- if (_editor->time_stretch (_editor->get_selection().regions, percentage) == -1) {
+ if (_editor->time_stretch (_editor->get_selection().regions, fraction) == -1) {
error << _("An error occurred while executing time stretch operation") << endmsg;
}
}
TrackViewList grouped_add = new_selection;
for (TrackViewList::const_iterator i = new_selection.begin(); i != new_selection.end(); ++i) {
RouteTimeAxisView *n = dynamic_cast<RouteTimeAxisView *>(*i);
- if ( n && n->route()->route_group() && n->route()->route_group()->is_active() && n->route()->route_group()->enabled_property (ARDOUR::Properties::select.property_id) ) {
+ if ( n && n->route()->route_group() && n->route()->route_group()->is_active() && n->route()->route_group()->enabled_property (ARDOUR::Properties::group_select.property_id) ) {
for (TrackViewList::const_iterator j = all_tracks.begin(); j != all_tracks.end(); ++j) {
RouteTimeAxisView *check = dynamic_cast<RouteTimeAxisView *>(*j);
if ( check && (n != check) && (check->route()->route_group() == n->route()->route_group()) )
_drag_rect = new ArdourCanvas::Rectangle (_editor->time_line_group,
ArdourCanvas::Rect (0.0, 0.0, 0.0,
- physical_screen_height (_editor->get_window())));
+ physical_screen_height (_editor->current_toplevel()->get_window())));
_drag_rect->hide ();
_drag_rect->set_fill_color (UIConfiguration::instance().color ("range drag rect"));
}
void
-RangeMarkerBarDrag::aborted (bool movement_occured)
+RangeMarkerBarDrag::aborted (bool movement_occurred)
{
- if (movement_occured) {
+ if (movement_occurred) {
_drag_rect->hide ();
}
}
frameoffset_t
NoteDrag::total_dx (const guint state) const
{
+ if (_x_constrained) {
+ return 0;
+ }
+ TempoMap& map (_editor->session()->tempo_map());
+
/* dx in frames */
frameoffset_t const dx = _editor->pixel_to_sample (_drags->current_pointer_x() - grab_x());
/* primary note time */
- frameoffset_t const n = _region->source_beats_to_absolute_frames (_primary->note()->time ());
+ double const quarter_note_start = _region->region()->quarter_note() - _region->midi_region()->start_beats();
+ frameoffset_t const n = map.frame_at_quarter_note (quarter_note_start + _primary->note()->time().to_double());
/* new time of the primary note in session frames */
frameoffset_t st = n + dx + snap_delta (state);
int8_t
NoteDrag::total_dy () const
{
+ if (_y_constrained) {
+ return 0;
+ }
+
MidiStreamView* msv = _region->midi_stream_view ();
double const y = _region->midi_view()->y_position ();
/* new current note */
int8_t const dy = total_dy ();
/* Now work out what we have to do to the note canvas items to set this new drag delta */
- double const tdx = _editor->sample_to_pixel (dx) - _cumulative_dx;
- double const tdy = -dy * _note_height - _cumulative_dy;
+ double const tdx = _x_constrained ? 0 : _editor->sample_to_pixel (dx) - _cumulative_dx;
+ double const tdy = _y_constrained ? 0 : -dy * _note_height - _cumulative_dy;
if (tdx || tdy) {
_cumulative_dx += tdx;
int8_t note_delta = total_dy();
- _region->move_selection (tdx, tdy, note_delta);
+ if (tdx || tdy) {
+ _region->move_selection (tdx, tdy, note_delta);
- /* the new note value may be the same as the old one, but we
- * don't know what that means because the selection may have
- * involved more than one note and we might be doing something
- * odd with them. so show the note value anyway, always.
- */
-
- char buf[12];
- uint8_t new_note = min (max (_primary->note()->note() + note_delta, 0), 127);
+ /* the new note value may be the same as the old one, but we
+ * don't know what that means because the selection may have
+ * involved more than one note and we might be doing something
+ * odd with them. so show the note value anyway, always.
+ */
- snprintf (buf, sizeof (buf), "%s (%d)", Evoral::midi_note_name (new_note).c_str(),
- (int) floor ((double)new_note));
+ uint8_t new_note = min (max (_primary->note()->note() + note_delta, 0), 127);
- show_verbose_cursor_text (buf);
+ _region->show_verbose_cursor_for_new_note_value (_primary->note(), new_note);
+ }
}
}
PatchChangeDrag::finished (GdkEvent* ev, bool movement_occurred)
{
if (!movement_occurred) {
+ if (was_double_click()) {
+ _region_view->edit_patch_change (_patch_change);
+ }
return;
}
framecnt_t
NoteCreateDrag::grid_frames (framepos_t t) const
{
- bool success;
- Evoral::Beats grid_beats = _editor->get_grid_type_as_beats (success, t);
- if (!success) {
- grid_beats = Evoral::Beats(1);
- }
- return _region_view->region_beats_to_region_frames (grid_beats);
+ const Evoral::Beats grid_beats = _region_view->get_grid_beats (t);
+ const Evoral::Beats t_beats = _region_view->region_frames_to_region_beats (t);
+
+ return _region_view->region_beats_to_region_frames (t_beats + grid_beats)
+ - _region_view->region_beats_to_region_frames (t_beats);
}
void
Drag::start_grab (event, cursor);
_drag_rect = new ArdourCanvas::Rectangle (_region_view->get_canvas_group ());
+ TempoMap& map (_editor->session()->tempo_map());
- framepos_t pf = _drags->current_pointer_frame ();
- framecnt_t const g = grid_frames (pf);
+ const framepos_t pf = _drags->current_pointer_frame ();
+ const int32_t divisions = _editor->get_grid_music_divisions (event->button.state);
- /* Hack so that we always snap to the note that we are over, instead of snapping
- to the next one if we're more than halfway through the one we're over.
- */
- if (_editor->snap_mode() == SnapNormal && pf > g / 2) {
- pf -= g / 2;
+ const Evoral::Beats grid_beats = _region_view->get_grid_beats (pf);
+
+ double eqaf = map.exact_qn_at_frame (pf, divisions);
+
+ if (divisions != 0) {
+
+ const double qaf = map.quarter_note_at_frame (pf);
+
+ /* Hack so that we always snap to the note that we are over, instead of snapping
+ to the next one if we're more than halfway through the one we're over.
+ */
+
+ const double rem = eqaf - qaf;
+ if (rem >= 0.0) {
+ eqaf -= grid_beats.to_double();
+ }
}
- _note[0] = adjusted_frame (pf, event) - _region_view->region()->position ();
- _note[1] = _note[0];
+ _note[0] = map.frame_at_quarter_note (eqaf) - _region_view->region()->position();
+ /* minimum initial length is grid beats */
+ _note[1] = map.frame_at_quarter_note (eqaf + grid_beats.to_double()) - _region_view->region()->position();
MidiStreamView* sv = _region_view->midi_stream_view ();
- double const x = _editor->sample_to_pixel (_note[0]);
+ double const x0 = _editor->sample_to_pixel (_note[0]);
+ double const x1 = _editor->sample_to_pixel (_note[1]);
double const y = sv->note_to_y (sv->y_to_note (y_to_region (event->button.y)));
- _drag_rect->set (ArdourCanvas::Rect (x, y, x, y + floor (_region_view->midi_stream_view()->note_height ())));
+ _drag_rect->set (ArdourCanvas::Rect (x0, y, x1, y + floor (_region_view->midi_stream_view()->note_height ())));
_drag_rect->set_outline_all ();
_drag_rect->set_outline_color (0xffffff99);
_drag_rect->set_fill_color (0xffffff66);
void
NoteCreateDrag::motion (GdkEvent* event, bool)
{
- _note[1] = max ((framepos_t)0, adjusted_current_frame (event) - _region_view->region()->position ());
+ TempoMap& map (_editor->session()->tempo_map());
+ const framepos_t pf = _drags->current_pointer_frame ();
+ const int32_t divisions = _editor->get_grid_music_divisions (event->button.state);
+ double eqaf = map.exact_qn_at_frame (pf, divisions);
+
+ if (divisions != 0) {
+
+ const Evoral::Beats grid_beats = _region_view->get_grid_beats (pf);
+
+ const double qaf = map.quarter_note_at_frame (pf);
+ /* Hack so that we always snap to the note that we are over, instead of snapping
+ to the next one if we're more than halfway through the one we're over.
+ */
+
+ const double rem = eqaf - qaf;
+ if (rem >= 0.0) {
+ eqaf -= grid_beats.to_double();
+ }
+
+ eqaf += grid_beats.to_double();
+ }
+ _note[1] = max ((framepos_t)0, map.frame_at_quarter_note (eqaf) - _region_view->region()->position ());
+
double const x0 = _editor->sample_to_pixel (_note[0]);
double const x1 = _editor->sample_to_pixel (_note[1]);
_drag_rect->set_x0 (std::min(x0, x1));
}
void
-NoteCreateDrag::finished (GdkEvent*, bool had_movement)
+NoteCreateDrag::finished (GdkEvent* ev, bool had_movement)
{
- if (!had_movement) {
- return;
- }
-
+ /* we create a note even if there was no movement */
framepos_t const start = min (_note[0], _note[1]);
- framecnt_t length = (framecnt_t) fabs ((double)(_note[0] - _note[1]));
-
+ framepos_t const start_sess_rel = start + _region_view->region()->position();
+ framecnt_t length = max (_editor->pixel_to_sample (1.0), (framecnt_t) fabs ((double)(_note[0] - _note[1])));
framecnt_t const g = grid_frames (start);
- Evoral::Beats const one_tick = Evoral::Beats::ticks(1);
- if (_editor->snap_mode() == SnapNormal && length < g) {
+ if (_editor->get_grid_music_divisions (ev->button.state) != 0 && length < g) {
length = g;
}
- Evoral::Beats length_beats = max (
- one_tick, _region_view->region_frames_to_region_beats (length) - one_tick);
+ TempoMap& map (_editor->session()->tempo_map());
+ const double qn_length = map.quarter_notes_between_frames (start_sess_rel, start_sess_rel + length);
+ Evoral::Beats qn_length_beats = max (Evoral::Beats::ticks(1), Evoral::Beats (qn_length));
- _region_view->create_note_at (start, _drag_rect->y0(), length_beats, false);
+ _region_view->create_note_at (start, _drag_rect->y0(), qn_length_beats, ev->button.state, false);
}
double
}
+HitCreateDrag::HitCreateDrag (Editor* e, ArdourCanvas::Item* i, MidiRegionView* rv)
+ : Drag (e, i)
+ , _region_view (rv)
+ , _last_pos (0)
+ , _last_y (0.0)
+{
+}
+
+HitCreateDrag::~HitCreateDrag ()
+{
+}
+
+void
+HitCreateDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
+{
+ Drag::start_grab (event, cursor);
+
+ TempoMap& map (_editor->session()->tempo_map());
+
+ const framepos_t pf = _drags->current_pointer_frame ();
+ const int32_t divisions = _editor->get_grid_music_divisions (event->button.state);
+
+ const double eqaf = map.exact_qn_at_frame (pf, divisions);
+
+ boost::shared_ptr<MidiRegion> mr = _region_view->midi_region();
+
+ if (eqaf >= mr->quarter_note() + mr->length_beats()) {
+ return;
+ }
+
+ const framepos_t start = map.frame_at_quarter_note (eqaf) - _region_view->region()->position();
+
+ MidiStreamView* sv = _region_view->midi_stream_view ();
+ const double y = sv->note_to_y (sv->y_to_note (y_to_region (event->button.y)));
+
+ Evoral::Beats length = _region_view->get_grid_beats (pf);
+
+ _region_view->create_note_at (start, y, length, event->button.state, false);
+
+ _last_pos = start;
+ _last_y = y;
+}
+
+void
+HitCreateDrag::motion (GdkEvent* event, bool)
+{
+ TempoMap& map (_editor->session()->tempo_map());
+
+ const framepos_t pf = _drags->current_pointer_frame ();
+ const int32_t divisions = _editor->get_grid_music_divisions (event->button.state);
+
+ if (divisions == 0) {
+ return;
+ }
+
+ const double eqaf = map.exact_qn_at_frame (pf, divisions);
+ const framepos_t start = map.frame_at_quarter_note (eqaf) - _region_view->region()->position ();
+
+ MidiStreamView* sv = _region_view->midi_stream_view ();
+ const double y = sv->note_to_y (sv->y_to_note (y_to_region (event->button.y)));
+
+ if (_last_pos == start && y == _last_y) {
+ return;
+ }
+
+ Evoral::Beats length = _region_view->get_grid_beats (pf);
+
+ boost::shared_ptr<MidiRegion> mr = _region_view->midi_region();
+ if (eqaf >= mr->quarter_note() + mr->length_beats()) {
+ return;
+ }
+
+ _region_view->create_note_at (start, y, length, event->button.state, false);
+
+ _last_pos = start;
+ _last_y = y;
+}
+
+void
+HitCreateDrag::finished (GdkEvent* /* ev */, bool /* had_movement */)
+{
+
+}
+
+double
+HitCreateDrag::y_to_region (double y) const
+{
+ double x = 0;
+ _region_view->get_canvas_group()->canvas_to_item (x, y);
+ return y;
+}
+
+void
+HitCreateDrag::aborted (bool)
+{
+ // umm..
+}
+
CrossfadeEdgeDrag::CrossfadeEdgeDrag (Editor* e, AudioRegionView* rv, ArdourCanvas::Item* i, bool start_yn)
: Drag (e, i)
, arv (rv)
{
line->set_position (pos);
line->show ();
+ line->track_canvas_item().reparent (_editor->_drag_motion_group);
}
RegionCutDrag::~RegionCutDrag ()
}
void
-RegionCutDrag::motion (GdkEvent*, bool)
+RegionCutDrag::start_grab (GdkEvent* event, Gdk::Cursor* c)
+{
+ Drag::start_grab (event, c);
+ motion (event, false);
+}
+
+void
+RegionCutDrag::motion (GdkEvent* event, bool)
{
- framepos_t where = _drags->current_pointer_frame();
- _editor->snap_to (where);
+ framepos_t pos = _drags->current_pointer_frame();
+ _editor->snap_to_with_modifier (pos, event);
- line->set_position (where);
+ line->set_position (pos);
}
void
-RegionCutDrag::finished (GdkEvent*, bool)
+RegionCutDrag::finished (GdkEvent* event, bool)
{
_editor->get_track_canvas()->canvas()->re_enter();
framepos_t pos = _drags->current_pointer_frame();
+ _editor->snap_to_with_modifier (pos, event);
line->hide ();
return;
}
- _editor->split_regions_at (pos, rs);
+ _editor->split_regions_at (pos, rs, _editor->get_grid_music_divisions (event->button.state),
+ false);
}
void
RegionCutDrag::aborted (bool)
{
}
+
+RulerZoomDrag::RulerZoomDrag (Editor* e, ArdourCanvas::Item* item)
+ : Drag (e, item, true)
+{
+}
+
+void
+RulerZoomDrag::start_grab (GdkEvent* event, Gdk::Cursor* c)
+{
+ Drag::start_grab (event, c);
+
+ framepos_t where = _editor->canvas_event_sample(event);
+
+ _editor->_dragging_playhead = true;
+
+ _editor->playhead_cursor->set_position (where);
+}
+
+void
+RulerZoomDrag::motion (GdkEvent* event, bool)
+{
+ framepos_t where = _editor->canvas_event_sample(event);
+
+ _editor->playhead_cursor->set_position (where);
+
+ const double movement_limit = 20.0;
+ const double scale = 1.08;
+ const double y_delta = last_pointer_y() - current_pointer_y();
+
+ if (y_delta > 0 && y_delta < movement_limit) {
+ _editor->temporal_zoom_step_mouse_focus_scale (true, scale);
+ } else if (y_delta < 0 && y_delta > -movement_limit) {
+ _editor->temporal_zoom_step_mouse_focus_scale (false, scale);
+ }
+}
+
+void
+RulerZoomDrag::finished (GdkEvent*, bool)
+{
+ _editor->_dragging_playhead = false;
+
+ Session* s = _editor->session ();
+ if (s) {
+ s->request_locate (_editor->playhead_cursor->current_frame (), _was_rolling);
+ _editor->_pending_locate_request = true;
+ }
+
+}
+
+void
+RulerZoomDrag::aborted (bool)
+{
+}
projects / ardour.git / blobdiff