#include "ardour/playlist_factory.h"
#include "ardour/profile.h"
#include "ardour/quantize.h"
+#include "ardour/legatize.h"
#include "ardour/region_factory.h"
#include "ardour/reverse.h"
#include "ardour/session.h"
#include "mixer_strip.h"
#include "mouse_cursors.h"
#include "normalize_dialog.h"
+#include "note.h"
+#include "paste_context.h"
#include "patch_change_dialog.h"
#include "quantize_dialog.h"
#include "region_gain_line.h"
#include "strip_silence_dialog.h"
#include "time_axis_view.h"
#include "transpose_dialog.h"
+#include "transform_dialog.h"
#include "i18n.h"
if (_session) {
_session->undo (n);
+ if (_session->undo_depth() == 0) {
+ undo_action->set_sensitive(false);
+ }
+ redo_action->set_sensitive(true);
+ begin_selection_op_history ();
}
}
if (_session) {
_session->redo (n);
+ if (_session->redo_depth() == 0) {
+ redo_action->set_sensitive(false);
+ }
+ undo_action->set_sensitive(true);
+ begin_selection_op_history ();
}
}
a = tmp;
}
+ latest_regionviews.clear ();
+
vector<sigc::connection> region_added_connections;
for (list<RouteTimeAxisView*>::iterator i = used_trackviews.begin(); i != used_trackviews.end(); ++i) {
region_added_connections.push_back ((*i)->view()->RegionViewAdded.connect (sigc::mem_fun(*this, &Editor::collect_new_region_view)));
}
- latest_regionviews.clear ();
-
while (used_playlists.size() > 0) {
list <boost::shared_ptr<Playlist > >::iterator i = used_playlists.begin();
(*i)->thaw();
for (vector<sigc::connection>::iterator c = region_added_connections.begin(); c != region_added_connections.end(); ++c) {
(*c).disconnect ();
}
-
- commit_reversible_command ();
if (frozen){
EditorThaw(); /* Emit Signal */
}
- if (ARDOUR::Profile->get_mixbus()) {
- //IFF we were working on selected regions, try to reinstate the other region selections that existed before the freeze/thaw.
- _ignore_follow_edits = true; //a split will change the region selection in mysterious ways; its not practical or wanted to follow this edit
- if( working_on_selection ) {
+ if (working_on_selection) {
+ // IFF we were working on selected regions, try to reinstate the other region selections that existed before the freeze/thaw.
+
+ _ignore_follow_edits = true; // a split will change the region selection in mysterious ways; it's not practical or wanted to follow this edit
+ RegionSelectionAfterSplit rsas = Config->get_region_selection_after_split();
+ /* There are three classes of regions that we might want selected after
+ splitting selected regions:
+ - regions selected before the split operation, and unaffected by it
+ - newly-created regions before the split
+ - newly-created regions after the split
+ */
+
+ if (rsas & Existing) {
+ // region selections that existed before the split.
selection->add ( pre_selected_regions );
+ }
+
+ for (RegionSelection::iterator ri = latest_regionviews.begin(); ri != latest_regionviews.end(); ri++) {
+ if ((*ri)->region()->position() < where) {
+ // new regions created before the split
+ if (rsas & NewlyCreatedLeft) {
+ selection->add (*ri);
+ }
+ } else {
+ // new regions created after the split
+ if (rsas & NewlyCreatedRight) {
+ selection->add (*ri);
+ }
+ }
+ }
+ _ignore_follow_edits = false;
+ } else {
+ _ignore_follow_edits = true;
+ if( working_on_selection ) {
selection->add (latest_regionviews); //these are the new regions created after the split
}
_ignore_follow_edits = false;
}
+
+ commit_reversible_command ();
}
/** Move one extreme of the current range selection. If more than one range is selected,
framepos_t end = 0;
set<TimeAxisView*> tracks;
- RegionSelection rs = get_regions_from_selection_and_entered ();
-
- if (rs.empty()) {
- return;
- }
-
- for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
-
- if ((*i)->region()->position() < start) {
- start = (*i)->region()->position();
- }
-
- if ((*i)->region()->last_frame() + 1 > end) {
- end = (*i)->region()->last_frame() + 1;
- }
-
- tracks.insert (&((*i)->get_time_axis_view()));
- }
-
- if ((start == 0 && end == 0) || end < start) {
+ if ( !get_selection_extents(start, end) )
return;
- }
-
+
calc_extra_zoom_edges (start, end);
/* if we're zooming on both axes we need to save track heights etc.
redo_visual_stack.push_back (current_visual_state (both_axes));
}
-void
-Editor::zoom_to_region (bool both_axes)
+
+bool
+Editor::get_selection_extents ( framepos_t &start, framepos_t &end )
{
- temporal_zoom_region (both_axes);
+ start = max_framepos;
+ end = 0;
+ bool ret = true;
+
+ //ToDo: if notes are selected, set extents to that selection
+
+ //ToDo: if control points are selected, set extents to that selection
+
+ if ( !selection->regions.empty() ) {
+ RegionSelection rs = get_regions_from_selection_and_entered ();
+
+ for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
+
+ if ((*i)->region()->position() < start) {
+ start = (*i)->region()->position();
+ }
+
+ if ((*i)->region()->last_frame() + 1 > end) {
+ end = (*i)->region()->last_frame() + 1;
+ }
+ }
+
+ } else if (!selection->time.empty()) {
+ start = selection->time.start();
+ end = selection->time.end_frame();
+ } else
+ ret = false; //no selection found
+
+ //range check
+ if ((start == 0 && end == 0) || end < start) {
+ ret = false;
+ }
+
+ return ret;
}
+
void
Editor::temporal_zoom_selection (bool both_axes)
{
if (!selection) return;
- //if a range is selected, zoom to that
- if (!selection->time.empty()) {
+ //ToDo: if notes are selected, zoom to that
- framepos_t start = selection->time.start();
- framepos_t end = selection->time.end_frame();
+ //ToDo: if control points are selected, zoom to that
- calc_extra_zoom_edges(start, end);
+ //if region(s) are selected, zoom to that
+ if ( !selection->regions.empty() )
+ temporal_zoom_region (both_axes);
- temporal_zoom_by_frame (start, end);
+ //if a range is selected, zoom to that
+ if (!selection->time.empty()) {
+ framepos_t start, end;
+ if (get_selection_extents (start, end)) {
+ calc_extra_zoom_edges(start, end);
+ temporal_zoom_by_frame (start, end);
+ }
+
if (both_axes)
- fit_selected_tracks();
-
- } else {
- temporal_zoom_region (both_axes);
+ fit_selection();
}
-
}
void
bool
Editor::choose_new_marker_name(string &name) {
- if (!Config->get_name_new_markers()) {
+ if (!ARDOUR_UI::config()->get_name_new_markers()) {
/* don't prompt user for a new name */
return true;
}
_session->locations()->next_available_name(rangename,"selection");
Location *location = new Location (*_session, start, end, rangename, Location::IsRangeMarker);
- _session->begin_reversible_command (_("add marker"));
+ begin_reversible_command (_("add marker"));
+
XMLNode &before = _session->locations()->get_state();
_session->locations()->add (location, true);
XMLNode &after = _session->locations()->get_state();
_session->add_command(new MementoCommand<Locations>(*(_session->locations()), &before, &after));
- _session->commit_reversible_command ();
+
+ commit_reversible_command ();
}
void
return;
}
Location *location = new Location (*_session, where, where, markername, Location::IsMark);
- _session->begin_reversible_command (_("add marker"));
+ begin_reversible_command (_("add marker"));
+
XMLNode &before = _session->locations()->get_state();
_session->locations()->add (location, true);
XMLNode &after = _session->locations()->get_state();
_session->add_command(new MementoCommand<Locations>(*(_session->locations()), &before, &after));
- _session->commit_reversible_command ();
+
+ commit_reversible_command ();
}
void
if (_session) {
//set up for undo
- _session->begin_reversible_command (_("remove marker"));
+ begin_reversible_command (_("remove marker"));
+
XMLNode &before = _session->locations()->get_state();
bool removed = false;
if (removed) {
XMLNode &after = _session->locations()->get_state();
_session->add_command(new MementoCommand<Locations>(*(_session->locations()), &before, &after));
- _session->commit_reversible_command ();
+
+ commit_reversible_command ();
}
}
}
return;
}
- _session->begin_reversible_command (selection->regions.size () > 1 ? _("add markers") : _("add marker"));
+ begin_reversible_command (selection->regions.size () > 1 ? _("add markers") : _("add marker"));
+
XMLNode &before = _session->locations()->get_state();
for (RegionSelection::iterator i = rs.begin (); i != rs.end (); ++i) {
XMLNode &after = _session->locations()->get_state();
_session->add_command (new MementoCommand<Locations>(*(_session->locations()), &before, &after));
- _session->commit_reversible_command ();
+
+ commit_reversible_command ();
}
/** Add a single range marker around all selected regions */
return;
}
- _session->begin_reversible_command (_("add marker"));
+ begin_reversible_command (_("add marker"));
+
XMLNode &before = _session->locations()->get_state();
string markername;
XMLNode &after = _session->locations()->get_state();
_session->add_command (new MementoCommand<Locations>(*(_session->locations()), &before, &after));
- _session->commit_reversible_command ();
+
+ commit_reversible_command ();
}
/* MARKS */
Editor::clear_markers ()
{
if (_session) {
- _session->begin_reversible_command (_("clear markers"));
+ begin_reversible_command (_("clear markers"));
+
XMLNode &before = _session->locations()->get_state();
_session->locations()->clear_markers ();
XMLNode &after = _session->locations()->get_state();
_session->add_command(new MementoCommand<Locations>(*(_session->locations()), &before, &after));
- _session->commit_reversible_command ();
+
+ commit_reversible_command ();
}
}
Editor::clear_ranges ()
{
if (_session) {
- _session->begin_reversible_command (_("clear ranges"));
+ begin_reversible_command (_("clear ranges"));
+
XMLNode &before = _session->locations()->get_state();
_session->locations()->clear_ranges ();
XMLNode &after = _session->locations()->get_state();
_session->add_command(new MementoCommand<Locations>(*(_session->locations()), &before, &after));
- _session->commit_reversible_command ();
+
+ commit_reversible_command ();
}
}
void
Editor::clear_locations ()
{
- _session->begin_reversible_command (_("clear locations"));
+ begin_reversible_command (_("clear locations"));
+
XMLNode &before = _session->locations()->get_state();
_session->locations()->clear ();
XMLNode &after = _session->locations()->get_state();
_session->add_command(new MementoCommand<Locations>(*(_session->locations()), &before, &after));
- _session->commit_reversible_command ();
- _session->locations()->clear ();
+
+ commit_reversible_command ();
}
void
void
Editor::play_selection ()
{
- if (selection->time.empty()) {
+ framepos_t start, end;
+ if (!get_selection_extents ( start, end))
return;
- }
- _session->request_play_range (&selection->time, true);
+ AudioRange ar (start, end, 0);
+ list<AudioRange> lar;
+ lar.push_back (ar);
+
+ _session->request_play_range (&lar, true);
}
framepos_t
void
Editor::maybe_locate_with_edit_preroll ( framepos_t location )
{
- if ( _session->transport_rolling() || !Config->get_follow_edits() || _ignore_follow_edits )
+ if ( _session->transport_rolling() || !ARDOUR_UI::config()->get_follow_edits() || _ignore_follow_edits )
return;
location -= get_preroll();
void
Editor::play_with_preroll ()
{
- if (selection->time.empty()) {
- return;
- } else {
+ {
framepos_t preroll = get_preroll();
- framepos_t start = 0;
- if (selection->time[clicked_selection].start > preroll)
- start = selection->time[clicked_selection].start - preroll;
+ framepos_t start, end;
+ if (!get_selection_extents ( start, end))
+ return;
+
+ if (start > preroll)
+ start = start - preroll;
- framepos_t end = selection->time[clicked_selection].end + preroll;
+ end = end + preroll; //"post-roll"
AudioRange ar (start, end, 0);
list<AudioRange> lar;
return;
}
- framepos_t start = selection->time[clicked_selection].start;
- framepos_t end = selection->time[clicked_selection].end;
+ framepos_t start, end;
+ if (clicked_selection) {
+ start = selection->time[clicked_selection].start;
+ end = selection->time[clicked_selection].end;
+ } else {
+ start = selection->time.start();
+ end = selection->time.end_frame();
+ }
TrackViewList ts = selection->tracks.filter_to_unique_playlists ();
sort_track_selection (ts);
add_if_covered (RegionView* rv, const AudioRange* ar, RegionSelection* rs)
{
switch (rv->region()->coverage (ar->start, ar->end - 1)) {
+ // n.b. -1 because AudioRange::end is one past the end, but coverage expects inclusive ranges
case Evoral::OverlapNone:
break;
default:
pthread_create_and_store (X_("freezer"), &itt.thread, _freeze_thread, this);
- set_canvas_cursor (_cursors->wait);
+ CursorContext::Handle cursor_ctx = CursorContext::create(*this, _cursors->wait);
while (!itt.done && !itt.cancel) {
gtk_main_iteration ();
}
current_interthread_info = 0;
- set_canvas_cursor (current_canvas_cursor);
}
void
return;
}
- if (internal_editing()) {
-
- switch (effective_mouse_mode()) {
- case MouseObject:
- case MouseRange:
- begin_reversible_command (opname + ' ' + X_("MIDI"));
- cut_copy_midi (op);
- commit_reversible_command ();
- break;
- default:
- break;
- }
-
+ switch (mouse_mode) {
+ case MouseDraw:
+ case MouseContent:
+ begin_reversible_command (opname + ' ' + X_("MIDI"));
+ cut_copy_midi (op);
+ commit_reversible_command ();
return;
+ default:
+ break;
}
bool did_edit = false;
* @param op Operation (Cut, Copy or Clear)
*/
void
-Editor::cut_copy_points (CutCopyOp op)
+Editor::cut_copy_points (Editing::CutCopyOp op, Evoral::Beats earliest, bool midi)
{
if (selection->points.empty ()) {
return;
/* This operation will involve putting things in the cut buffer, so create an empty
ControlList for each of our source lists to put the cut buffer data in.
*/
- framepos_t start = std::numeric_limits<framepos_t>::max();
for (Lists::iterator i = lists.begin(); i != lists.end(); ++i) {
- i->second.copy = i->first->create (i->first->parameter ());
-
- /* Calculate earliest start position of any point in selection. */
- start = std::min(start, i->second.line->session_position(i->first->begin()));
+ i->second.copy = i->first->create (i->first->parameter (), i->first->descriptor());
}
/* Add all selected points to the relevant copy ControlLists */
+ framepos_t start = std::numeric_limits<framepos_t>::max();
for (PointSelection::iterator i = selection->points.begin(); i != selection->points.end(); ++i) {
boost::shared_ptr<AutomationList> al = (*i)->line().the_list();
- AutomationList::const_iterator j = (*i)->model ();
+ AutomationList::const_iterator j = (*i)->model();
+
lists[al].copy->fast_simple_add ((*j)->when, (*j)->value);
+ if (midi) {
+ /* Update earliest MIDI start time in beats */
+ earliest = std::min(earliest, Evoral::Beats((*j)->when));
+ } else {
+ /* Update earliest session start time in frames */
+ start = std::min(start, (*i)->line().session_position(j));
+ }
}
/* Snap start time backwards, so copy/paste is snap aligned. */
- snap_to(start, RoundDownMaybe);
+ if (midi) {
+ if (earliest == Evoral::Beats::max()) {
+ earliest = Evoral::Beats(); // Weird... don't offset
+ }
+ earliest.round_down_to_beat();
+ } else {
+ if (start == std::numeric_limits<double>::max()) {
+ start = 0; // Weird... don't offset
+ }
+ snap_to(start, RoundDownMaybe);
+ }
+ const double line_offset = midi ? earliest.to_double() : start;
for (Lists::iterator i = lists.begin(); i != lists.end(); ++i) {
/* Correct this copy list so that it is relative to the earliest
start time, so relative ordering between points is preserved
- when copying from several lists. */
- const AutomationLine* line = i->second.line;
- const double line_offset = line->time_converter().from(start);
-
+ when copying from several lists and the paste starts at the
+ earliest copied piece of data. */
for (AutomationList::iterator j = i->second.copy->begin(); j != i->second.copy->end(); ++j) {
(*j)->when -= line_offset;
}
void
Editor::cut_copy_midi (CutCopyOp op)
{
+ Evoral::Beats earliest = Evoral::Beats::max();
for (MidiRegionSelection::iterator i = selection->midi_regions.begin(); i != selection->midi_regions.end(); ++i) {
MidiRegionView* mrv = dynamic_cast<MidiRegionView*>(*i);
if (mrv) {
+ if (!mrv->selection().empty()) {
+ earliest = std::min(earliest, (*mrv->selection().begin())->note()->time());
+ }
mrv->cut_copy_clear (op);
/* XXX: not ideal, as there may be more than one track involved in the selection */
}
if (!selection->points.empty()) {
- cut_copy_points (op);
+ cut_copy_points (op, earliest, true);
if (op == Cut || op == Delete) {
selection->clear_points ();
}
return;
}
+ begin_reversible_command (_("remove region"));
+
boost::shared_ptr<Playlist> playlist = clicked_routeview->playlist();
playlist->clear_changes ();
R1.A1, R1.A2, R2, R2.A1, ... */
}
- if (internal_editing ()) {
-
- /* undo/redo is handled by individual tracks/regions */
+ begin_reversible_command (Operations::paste);
- RegionSelection rs;
- get_regions_at (rs, position, ts);
+ if (ts.size() == 1 && cut_buffer->lines.size() == 1 &&
+ dynamic_cast<AutomationTimeAxisView*>(ts.front())) {
+ /* Only one line copied, and one automation track selected. Do a
+ "greedy" paste from one automation type to another. */
- ItemCounts counts;
- for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ++r) {
- MidiRegionView* mrv = dynamic_cast<MidiRegionView*> (*r);
- if (mrv) {
- mrv->paste (position, paste_count, times, *cut_buffer, counts);
- }
- }
+ PasteContext ctx(paste_count, times, ItemCounts(), true);
+ ts.front()->paste (position, *cut_buffer, ctx);
} else {
- /* we do redo (do you do voodoo?) */
-
- begin_reversible_command (Operations::paste);
+ /* Paste into tracks */
- ItemCounts counts;
+ PasteContext ctx(paste_count, times, ItemCounts(), false);
for (TrackViewList::iterator i = ts.begin(); i != ts.end(); ++i) {
- (*i)->paste (position, paste_count, times, *cut_buffer, counts);
+ (*i)->paste (position, *cut_buffer, ctx);
}
-
- commit_reversible_command ();
}
+
+ commit_reversible_command ();
}
void
foo.insert (foo.end(), latest_regionviews.begin(), latest_regionviews.end());
}
- commit_reversible_command ();
-
if (!foo.empty()) {
selection->set (foo);
}
+
+ commit_reversible_command ();
}
void
continue;
}
playlist->clear_changes ();
- playlist->duplicate (*ri, selection->time[clicked_selection].end, times);
+ framepos_t end;
+ if (clicked_selection) {
+ end = selection->time[clicked_selection].end;
+ } else {
+ end = selection->time.end_frame();
+ }
+ playlist->duplicate (*ri, end, times);
_session->add_command (new StatefulDiffCommand (playlist));
++ri;
return;
}
- set_canvas_cursor (_cursors->wait);
+ CursorContext::Handle cursor_ctx = CursorContext::create(*this, _cursors->wait);
gdk_flush ();
/* XXX: should really only count audio regions here */
if (a == -1) {
/* the user cancelled the operation */
- set_canvas_cursor (current_canvas_cursor);
return;
}
}
commit_reversible_command ();
- set_canvas_cursor (current_canvas_cursor);
}
Command*
Editor::apply_midi_note_edit_op_to_region (MidiOperator& op, MidiRegionView& mrv)
{
- Evoral::Sequence<Evoral::MusicalTime>::Notes selected;
+ Evoral::Sequence<Evoral::Beats>::Notes selected;
mrv.selection_as_notelist (selected, true);
- vector<Evoral::Sequence<Evoral::MusicalTime>::Notes> v;
+ vector<Evoral::Sequence<Evoral::Beats>::Notes> v;
v.push_back (selected);
- framepos_t pos_frames = mrv.midi_region()->position() - mrv.midi_region()->start();
- Evoral::MusicalTime pos_beats = _session->tempo_map().framewalk_to_beats(0, pos_frames);
+ framepos_t pos_frames = mrv.midi_region()->position() - mrv.midi_region()->start();
+ Evoral::Beats pos_beats = _session->tempo_map().framewalk_to_beats(0, pos_frames);
return op (mrv.midi_region()->model(), pos_beats, v);
}
void
-Editor::apply_midi_note_edit_op (MidiOperator& op)
+Editor::apply_midi_note_edit_op (MidiOperator& op, const RegionSelection& rs)
{
- Command* cmd;
-
- RegionSelection rs = get_regions_from_selection_and_entered ();
-
if (rs.empty()) {
return;
}
begin_reversible_command (op.name ());
- for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ) {
- RegionSelection::iterator tmp = r;
+ for (RegionSelection::const_iterator r = rs.begin(); r != rs.end(); ) {
+ RegionSelection::const_iterator tmp = r;
++tmp;
MidiRegionView* const mrv = dynamic_cast<MidiRegionView*> (*r);
if (mrv) {
- cmd = apply_midi_note_edit_op_to_region (op, *mrv);
+ Command* cmd = apply_midi_note_edit_op_to_region (op, *mrv);
if (cmd) {
(*cmd)();
_session->add_command (cmd);
begin_reversible_command (_("Fork Region(s)"));
- set_canvas_cursor (_cursors->wait);
+ CursorContext::Handle cursor_ctx = CursorContext::create(*this, _cursors->wait);
gdk_flush ();
for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ) {
}
commit_reversible_command ();
-
- set_canvas_cursor (current_canvas_cursor);
}
void
Editor::quantize_region ()
{
- int selected_midi_region_cnt = 0;
+ if (_session) {
+ quantize_regions(get_regions_from_selection_and_entered ());
+ }
+}
- if (!_session) {
+void
+Editor::quantize_regions (const RegionSelection& rs)
+{
+ if (rs.n_midi_regions() == 0) {
return;
}
- RegionSelection rs = get_regions_from_selection_and_entered ();
+ QuantizeDialog* qd = new QuantizeDialog (*this);
- if (rs.empty()) {
+ qd->present ();
+ const int r = qd->run ();
+ qd->hide ();
+
+ if (r == Gtk::RESPONSE_OK) {
+ Quantize quant (qd->snap_start(), qd->snap_end(),
+ qd->start_grid_size(), qd->end_grid_size(),
+ qd->strength(), qd->swing(), qd->threshold());
+
+ apply_midi_note_edit_op (quant, rs);
+ }
+}
+
+void
+Editor::legatize_region (bool shrink_only)
+{
+ if (_session) {
+ legatize_regions(get_regions_from_selection_and_entered (), shrink_only);
+ }
+}
+
+void
+Editor::legatize_regions (const RegionSelection& rs, bool shrink_only)
+{
+ if (rs.n_midi_regions() == 0) {
return;
}
- for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ++r) {
- MidiRegionView* const mrv = dynamic_cast<MidiRegionView*> (*r);
- if (mrv) {
- selected_midi_region_cnt++;
- }
+ Legatize legatize(shrink_only);
+ apply_midi_note_edit_op (legatize, rs);
+}
+
+void
+Editor::transform_region ()
+{
+ if (_session) {
+ transform_regions(get_regions_from_selection_and_entered ());
}
+}
- if (selected_midi_region_cnt == 0) {
+void
+Editor::transform_regions (const RegionSelection& rs)
+{
+ if (rs.n_midi_regions() == 0) {
return;
}
- QuantizeDialog* qd = new QuantizeDialog (*this);
+ TransformDialog* td = new TransformDialog();
- qd->present ();
- const int r = qd->run ();
- qd->hide ();
+ td->present();
+ const int r = td->run();
+ td->hide();
if (r == Gtk::RESPONSE_OK) {
- Quantize quant (*_session, qd->snap_start(), qd->snap_end(),
- qd->start_grid_size(), qd->end_grid_size(),
- qd->strength(), qd->swing(), qd->threshold());
-
- apply_midi_note_edit_op (quant);
+ Transform transform(td->get());
+ apply_midi_note_edit_op(transform, rs);
}
}
*/
MidiRegionView* first = dynamic_cast<MidiRegionView*> (rs.front ());
- Evoral::PatchChange<Evoral::MusicalTime> empty (Evoral::MusicalTime(), 0, 0, 0);
+ Evoral::PatchChange<Evoral::Beats> empty (Evoral::Beats(), 0, 0, 0);
PatchChangeDialog d (0, _session, empty, first->instrument_info(), Gtk::Stock::ADD);
if (d.run() == RESPONSE_CANCEL) {
begin_reversible_command (command);
- set_canvas_cursor (_cursors->wait);
+ CursorContext::Handle cursor_ctx = CursorContext::create(*this, _cursors->wait);
gdk_flush ();
int n = 0;
_session->add_command(new StatefulDiffCommand (playlist));
} else {
- goto out;
+ return;
}
if (progress) {
}
commit_reversible_command ();
-
- out:
- set_canvas_cursor (current_canvas_cursor);
}
void
return;
}
- _session->begin_reversible_command (_("reset region gain"));
-
+ begin_reversible_command (_("reset region gain"));
+
for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
if (arv) {
_session->add_command (new MementoCommand<AutomationList>(*arv->audio_region()->envelope().get(), &before, &alist->get_state()));
}
}
-
- _session->commit_reversible_command ();
+
+ commit_reversible_command ();
}
void
return;
}
- _session->begin_reversible_command (_("region gain envelope active"));
-
+ begin_reversible_command (_("region gain envelope active"));
+
for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
if (arv) {
_session->add_command (new StatefulDiffCommand (arv->region()));
}
}
-
- _session->commit_reversible_command ();
+
+ commit_reversible_command ();
}
void
return;
}
- _session->begin_reversible_command (_("toggle region lock"));
-
+ begin_reversible_command (_("toggle region lock"));
+
for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
(*i)->region()->clear_changes ();
(*i)->region()->set_locked (!(*i)->region()->locked());
_session->add_command (new StatefulDiffCommand ((*i)->region()));
}
-
- _session->commit_reversible_command ();
+
+ commit_reversible_command ();
}
void
return;
}
- _session->begin_reversible_command (_("Toggle Video Lock"));
-
+ begin_reversible_command (_("Toggle Video Lock"));
+
for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
(*i)->region()->clear_changes ();
(*i)->region()->set_video_locked (!(*i)->region()->video_locked());
_session->add_command (new StatefulDiffCommand ((*i)->region()));
}
-
- _session->commit_reversible_command ();
+
+ commit_reversible_command ();
}
void
return;
}
- _session->begin_reversible_command (_("region lock style"));
-
+ begin_reversible_command (_("region lock style"));
+
for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
(*i)->region()->clear_changes ();
PositionLockStyle const ns = (*i)->region()->position_lock_style() == AudioTime ? MusicTime : AudioTime;
(*i)->region()->set_position_lock_style (ns);
_session->add_command (new StatefulDiffCommand ((*i)->region()));
}
-
- _session->commit_reversible_command ();
+
+ commit_reversible_command ();
}
void
return;
}
- _session->begin_reversible_command (_("change region opacity"));
-
+ begin_reversible_command (_("change region opacity"));
+
for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
(*i)->region()->clear_changes ();
(*i)->region()->set_opaque (!(*i)->region()->opaque());
_session->add_command (new StatefulDiffCommand ((*i)->region()));
}
-
- _session->commit_reversible_command ();
+
+ commit_reversible_command ();
}
void
}
}
- if ( Config->get_follow_edits() )
+ if (ARDOUR_UI::config()->get_follow_edits()) {
cancel_time_selection();
+ }
}
void
Editor::split_region ()
{
+ //if a range is selected, separate it
if ( !selection->time.empty()) {
separate_regions_between (selection->time);
return;
}
- RegionSelection rs = get_regions_from_selection_and_edit_point ();
+ //if no range was selected, try to find some regions to split
+ if (current_mouse_mode() == MouseObject) { //don't try this for Internal Edit, Stretch, Draw, etc.
+
+ RegionSelection rs = get_regions_from_selection_and_edit_point ();
- framepos_t where = get_preferred_edit_position ();
+ framepos_t where = get_preferred_edit_position ();
- if (rs.empty()) {
- return;
- }
+ if (rs.empty()) {
+ return;
+ }
- split_regions_at (where, rs);
+ split_regions_at (where, rs);
+ }
}
struct EditorOrderRouteSorter {
void
Editor::set_loop_from_selection (bool play)
-{
- if (_session == 0 || selection->time.empty()) {
- return;
- }
-
- framepos_t start = selection->time[clicked_selection].start;
- framepos_t end = selection->time[clicked_selection].end;
-
- set_loop_range (start, end, _("set loop range from selection"));
-
- if (play) {
- _session->request_locate (start, true);
- _session->request_play_loop (true);
- }
-}
-
-void
-Editor::set_loop_from_edit_range (bool play)
{
if (_session == 0) {
return;
}
- framepos_t start;
- framepos_t end;
-
- if (!get_edit_op_range (start, end)) {
+ framepos_t start, end;
+ if (!get_selection_extents ( start, end))
return;
- }
- set_loop_range (start, end, _("set loop range from edit range"));
+ set_loop_range (start, end, _("set loop range from selection"));
if (play) {
- _session->request_locate (start, true);
- _session->request_play_loop (true);
+ _session->request_play_loop (true, true);
}
}
void
Editor::set_loop_from_region (bool play)
{
- framepos_t start = max_framepos;
- framepos_t end = 0;
-
- RegionSelection rs = get_regions_from_selection_and_entered ();
-
- if (rs.empty()) {
+ framepos_t start, end;
+ if (!get_selection_extents ( start, end))
return;
- }
-
- for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
- if ((*i)->region()->position() < start) {
- start = (*i)->region()->position();
- }
- if ((*i)->region()->last_frame() + 1 > end) {
- end = (*i)->region()->last_frame() + 1;
- }
- }
set_loop_range (start, end, _("set loop range from region"));
void
Editor::set_punch_from_selection ()
{
- if (_session == 0 || selection->time.empty()) {
+ if (_session == 0) {
return;
}
- framepos_t start = selection->time[clicked_selection].start;
- framepos_t end = selection->time[clicked_selection].end;
+ framepos_t start, end;
+ if (!get_selection_extents ( start, end))
+ return;
set_punch_range (start, end, _("set punch range from selection"));
}
void
-Editor::set_punch_from_edit_range ()
+Editor::set_session_extents_from_selection ()
{
if (_session == 0) {
return;
}
+
+ framepos_t start, end;
+ if (!get_selection_extents ( start, end))
+ return;
- framepos_t start;
- framepos_t end;
+ begin_reversible_command (_("set session start/stop from selection"));
- if (!get_edit_op_range (start, end)) {
- return;
- }
+ Location* loc;
+ if ((loc = _session->locations()->session_range_location()) == 0) {
+ _session->set_session_extents ( start, end ); // this will create a new session range; no need for UNDO
+ } else {
+ XMLNode &before = loc->get_state();
- set_punch_range (start, end, _("set punch range from edit range"));
+ _session->set_session_extents ( start, end );
+
+ XMLNode &after = loc->get_state();
+
+ _session->add_command (new MementoCommand<Location>(*loc, &before, &after));
+
+ commit_reversible_command ();
+ }
}
void
Editor::set_punch_from_region ()
{
- framepos_t start = max_framepos;
- framepos_t end = 0;
-
- RegionSelection rs = get_regions_from_selection_and_entered ();
-
- if (rs.empty()) {
+ framepos_t start, end;
+ if (!get_selection_extents ( start, end))
return;
- }
-
- for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
- if ((*i)->region()->position() < start) {
- start = (*i)->region()->position();
- }
- if ((*i)->region()->last_frame() + 1 > end) {
- end = (*i)->region()->last_frame() + 1;
- }
- }
set_punch_range (start, end, _("set punch range from region"));
}
return;
}
- _session->begin_reversible_command (_("split regions"));
-
+ begin_reversible_command (_("split regions"));
+
for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ) {
RegionSelection::iterator tmp;
i = tmp;
}
-
- _session->commit_reversible_command ();
+
+ commit_reversible_command ();
}
framepos_t where = get_preferred_edit_position();
- _session->begin_reversible_command (_("place transient"));
-
+ begin_reversible_command (_("place transient"));
+
for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ++r) {
framepos_t position = (*r)->region()->position();
(*r)->region()->add_transient(where - position);
}
-
- _session->commit_reversible_command ();
+
+ commit_reversible_command ();
}
void
return;
}
- _session->begin_reversible_command (_("snap regions to grid"));
-
+ begin_reversible_command (_("snap regions to grid"));
+
for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ++r) {
boost::shared_ptr<Playlist> pl = (*r)->region()->playlist();
(*i)->thaw();
used_playlists.pop_front();
}
-
- _session->commit_reversible_command ();
+
+ commit_reversible_command ();
}
void
/* Iterate over the region list and make adjacent regions overlap by crossfade_len_ms */
- _session->begin_reversible_command (_("close region gaps"));
-
+ begin_reversible_command (_("close region gaps"));
+
int idx = 0;
boost::shared_ptr<Region> last_region;
(*i)->thaw();
used_playlists.pop_front();
}
-
- _session->commit_reversible_command ();
+
+ commit_reversible_command ();
}
void
}
void
-Editor::fit_selected_tracks ()
+Editor::fit_selection ()
{
if (!selection->tracks.empty()) {
fit_tracks (selection->tracks);
(*i)->region()->playlist()->clear_changes ();
(*i)->region()->set_muted (!(*i)->region()->muted ());
- _session->add_command (new StatefulDiffCommand ((*i)->region()->playlist()));
+ _session->add_command (new StatefulDiffCommand ((*i)->region()));
}
projects / ardour.git / blobdiff