#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"
}
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());
might be wrong.
*/
framecnt_t len = map.frame_at_beat (map.beat_at_frame (pos) + 1.0) - pos;
- return view->add_region (grab_frame(), len, commit);
+ 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);
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
+ , _editor->get_grid_music_divisions (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, _editor->get_grid_music_divisions (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;
/* 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, _editor->get_grid_music_divisions (ev_state)
);
if (new_view == 0) {
playlist->freeze ();
}
- rv->region()->set_position (where);
+ rv->region()->set_position (where, _editor->get_grid_music_divisions (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();
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
+ , _editor->get_grid_music_divisions (event->button.state));
+
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, _editor->get_grid_music_divisions (event->button.state));
if (changed && _preserve_fade_anchor) {
AudioRegionView* arv = dynamic_cast<AudioRegionView*> (i->view);
if (arv) {
}
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");
void
MeterMarkerDrag::motion (GdkEvent* event, bool first_move)
{
- if (!_marker->meter().movable()) {
- //return;
- }
-
if (first_move) {
-
// create a dummy marker to catch events, then hide it.
char name[64];
} else {
--bbt.bars;
}
- const double beat = map.bbt_to_beats (bbt);
-
- if (_real_section->position_lock_style() == AudioTime) {
- _real_section = map.add_meter (Meter (_marker->meter().divisions_per_bar(), _marker->meter().note_divisor())
- , map.frame_time (bbt), beat, bbt);
- } else {
- _real_section = map.add_meter (Meter (_marker->meter().divisions_per_bar(), _marker->meter().note_divisor()), beat, bbt);
+ 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, map.frame_at_bbt (bbt), _real_section->position_lock_style());
+ if (!_real_section) {
+ aborted (true);
+ return;
}
- }
- }
- framepos_t const pf = adjusted_current_frame (event, false);
- if (_marker->meter().position_lock_style() == MusicTime) {
- TempoMap& map (_editor->session()->tempo_map());
- Timecode::BBT_Time bbt;
- map.bbt_time (pf, bbt);
- /* round bbt to bars */
- map.round_bbt (bbt, -1, RoundNearest);
-
- if (Keyboard::modifier_state_contains (event->button.state, ArdourKeyboard::constraint_modifier ())) {
- /* adjust previous tempo to match meter frame */
- _editor->session()->tempo_map().gui_dilate_tempo (_real_section, pf);
- } else if ((bbt.bars != _real_section->bbt().bars && pf > last_pointer_frame())
- || (bbt.bars < _real_section->bbt().bars && pf < last_pointer_frame())) {
- /* move meter beat-based */
- _editor->session()->tempo_map().gui_move_meter (_real_section, bbt);
}
- } else {
- /* AudioTime */
- if (Keyboard::modifier_state_contains (event->button.state, ArdourKeyboard::constraint_modifier ())) {
- /* currently disabled in the lib for AudioTime */
- if (_real_section->movable()) {
- _editor->session()->tempo_map().gui_dilate_tempo (_real_section, pf);
- }
- } else {
- _editor->session()->tempo_map().gui_move_meter (_real_section, pf);
+ /* 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);
}
}
- _marker->set_position (pf);
+
+ framepos_t pf = adjusted_current_frame (event);
+
+ 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());
}
return;
}
+ /* reinstate old snap setting */
+ _editor->set_snap_to (_old_snap_type);
+ _editor->set_snap_mode (_old_snap_mode);
+
TempoMap& map (_editor->session()->tempo_map());
XMLNode &after = map.get_state();
{
_marker->set_position (_marker->meter().frame ());
if (moved) {
+ /* 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.
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
if (!_real_section->active()) {
return;
}
+
if (first_move) {
// mvc drag - create a dummy marker to catch events, hide it.
TempoMap& map (_editor->session()->tempo_map());
/* get current state */
before_state = &map.get_state();
+
if (!_copy) {
_editor->begin_reversible_command (_("move tempo mark"));
+
} 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"));
- framepos_t frame;
- bool use_snap = false;
- if (!_editor->snap_musical()) {
- frame = adjusted_current_frame (event);
+ if (_real_section->position_lock_style() == MusicTime) {
+ _real_section = map.add_tempo (tempo, map.pulse_at_frame (frame), 0, type, MusicTime);
} else {
- frame = adjusted_current_frame (event, false);
- if (ArdourKeyboard::indicates_snap (event->button.state)) {
- if (_editor->snap_mode() == Editing::SnapOff) {
- use_snap = true;
- } else {
- use_snap = false;
- }
- } else {
- if (_editor->snap_mode() == Editing::SnapOff) {
- use_snap = false;
- } else {
- use_snap = true;
- }
- }
+ _real_section = map.add_tempo (tempo, 0.0, frame, type, AudioTime);
}
- Timecode::BBT_Time bbt;
- map.bbt_time (frame, bbt);
-
- /* add new tempo section to map, ensuring we don't refer to existing tempos for snap */
-
- if (_real_section->position_lock_style() == MusicTime) {
- if (use_snap && _editor->snap_type() == SnapToBar) {
- map.round_bbt (bbt, -1, (frame > _real_section->frame()) ? RoundUpMaybe : RoundDownMaybe);
- } else if (use_snap) {
- map.round_bbt (bbt, _editor->get_grid_beat_divisions (0), RoundNearest);
- }
- double const pulse = map.predict_tempo_pulse (_real_section, map.frame_time (bbt));
- _real_section = map.add_tempo (_marker->tempo(), pulse, _real_section->type());
- } else {
- if (use_snap && _editor->snap_type() == SnapToBar) {
- map.round_bbt (bbt, -1, (frame > _real_section->frame()) ? RoundUpMaybe : RoundDownMaybe);
- } else if (use_snap) {
- map.round_bbt (bbt, _editor->get_grid_beat_divisions (0), RoundNearest);
- }
- if (use_snap) {
- frame = map.predict_tempo_frame (_real_section, bbt);
- }
- _real_section = map.add_tempo (_marker->tempo(), frame, _real_section->type());
+ if (!_real_section) {
+ aborted (true);
+ return;
}
}
}
- framepos_t pf;
-
if (Keyboard::modifier_state_contains (event->button.state, ArdourKeyboard::constraint_modifier ())) {
+ /* use vertical movement to alter tempo .. should be log */
double new_bpm = _real_section->beats_per_minute() + ((last_pointer_y() - current_pointer_y()) / 5.0);
- _editor->session()->tempo_map().gui_change_tempo (_real_section, Tempo (new_bpm, _real_section->note_type()));
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()) {
- if (!_editor->snap_musical()) {
- /* snap normally (this is not self-referential).*/
- pf = adjusted_current_frame (event);
- } else {
- /* but this is.
- we can't use the map for anything related to tempo,
- so we round bbt using meters, which have no dependency
- on pulse for this kind of thing.
- */
- bool use_snap;
- TempoMap& map (_editor->session()->tempo_map());
- pf = adjusted_current_frame (event, false);
- if (ArdourKeyboard::indicates_snap (event->button.state)) {
- if (_editor->snap_mode() == Editing::SnapOff) {
- use_snap = true;
- } else {
- use_snap = false;
- }
- } else {
- if (_editor->snap_mode() == Editing::SnapOff) {
- use_snap = false;
- } else {
- use_snap = true;
- }
- }
+ } else if (_movable && !_real_section->locked_to_meter()) {
+ const framepos_t pf = adjusted_current_frame (event);
+ TempoMap& map (_editor->session()->tempo_map());
- Timecode::BBT_Time when;
- map.bbt_time (pf, when);
+ /* snap to beat is 1, snap to bar is -1 (sorry) */
+ int sub_num = _editor->get_grid_music_divisions (event->button.state);
- if (_real_section->position_lock_style() == MusicTime) {
-
- const double pulse = map.predict_tempo_pulse (_real_section, pf);
- when = map.pulse_to_bbt (pulse);
- if (use_snap && _editor->snap_type() == SnapToBar) {
- map.round_bbt (when, -1, (pf > _real_section->frame()) ? RoundUpMaybe : RoundDownMaybe);
- } else if (use_snap) {
- map.round_bbt (when, _editor->get_grid_beat_divisions (0), RoundNearest);
- }
- const double beat = map.bbt_to_beats (when);
- map.gui_move_tempo_beat (_real_section, beat);
- } else {
- if (use_snap && _editor->snap_type() == SnapToBar) {
- map.round_bbt (when, -1, (pf > _real_section->frame()) ? RoundUpMaybe : RoundDownMaybe);
- } else if (use_snap) {
- map.round_bbt (when, _editor->get_grid_beat_divisions (0), RoundNearest);
- }
- if (use_snap) {
- pf = map.predict_tempo_frame (_real_section, when);
- }
- map.gui_move_tempo_frame (_real_section, pf);
- }
- }
+ map.gui_move_tempo (_real_section, pf, sub_num);
show_verbose_cursor_time (_real_section->frame());
}
- _marker->set_position (pf);
+ _marker->set_position (adjusted_current_frame (event, false));
}
void
if (moved) {
TempoMap& map (_editor->session()->tempo_map());
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 the dummy (hidden) marker we used for events while moving.
delete _marker;
}
}
BBTRulerDrag::BBTRulerDrag (Editor* e, ArdourCanvas::Item* i)
: Drag (e, i)
, _pulse (0.0)
- , _beat (0.0)
, _tempo (0)
, before_state (0)
{
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;
- _tempo = const_cast<TempoSection*> (&map.tempo_section_at (raw_grab_frame()));
- sstr << "^" << fixed << setprecision(3) << map.tempo_at (adjusted_current_frame (event)).beats_per_minute() << "\n";
+ sstr << "^" << fixed << setprecision(3) << map.tempo_at_frame (adjusted_current_frame (event)).beats_per_minute() << "\n";
sstr << "<" << fixed << setprecision(3) << _tempo->beats_per_minute();
show_verbose_cursor_text (sstr.str());
finished (event, false);
TempoMap& map (_editor->session()->tempo_map());
const double beat_at_frame = 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);
+ 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);
+ beat = floor (beat_at_frame) + (floor (((beat_at_frame - floor (beat_at_frame)) * 4)) / 4);
}
- _pulse = map.pulse_at_beat (_beat);
- _pointer_frame_offset = raw_grab_frame() - map.frame_at_beat (_beat);
+
+ _pulse = map.pulse_at_beat (beat);
+
+ _pointer_frame_offset = raw_grab_frame() - map.frame_at_pulse (_pulse);
+
}
void
_editor->begin_reversible_command (_("dilate tempo"));
}
- framepos_t const pf = adjusted_current_frame (event, false);
+ framepos_t pf;
+
+ if (_editor->snap_musical()) {
+ pf = adjusted_current_frame (event, false);
+ } else {
+ pf = adjusted_current_frame (event);
+ }
if (Keyboard::modifier_state_contains (event->button.state, ArdourKeyboard::constraint_modifier())) {
/* adjust previous tempo to match pointer frame */
_editor->session()->tempo_map().gui_dilate_tempo (_tempo, map.frame_at_pulse (_pulse), pf, _pulse);
}
ostringstream sstr;
- sstr << "^" << fixed << setprecision(3) << map.tempo_at (pf).beats_per_minute() << "\n";
+ sstr << "^" << fixed << setprecision(3) << map.tempo_at_frame (pf).beats_per_minute() << "\n";
sstr << "<" << fixed << setprecision(3) << _tempo->beats_per_minute();
show_verbose_cursor_text (sstr.str());
}
} else {
location->set (((*x).location)->start(), ((*x).location)->end());
}
+
+ if (location->is_session_range()) {
+ _editor->session()->set_end_is_free (false);
+ }
}
}
/* 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;
}
}
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()) )
PatchChangeDrag::finished (GdkEvent* ev, bool movement_occurred)
{
if (!movement_occurred) {
+ if (was_double_click()) {
+ _region_view->edit_patch_change (_patch_change);
+ }
return;
}
}
void
-RegionCutDrag::finished (GdkEvent*, bool)
+RegionCutDrag::finished (GdkEvent* event, bool)
{
_editor->get_track_canvas()->canvas()->re_enter();
return;
}
- _editor->split_regions_at (pos, rs);
+ _editor->split_regions_at (pos, rs, _editor->get_grid_music_divisions (event->button.state));
}
void
projects / ardour.git / blobdiff