#include "ardour/audio_track.h"
#include "ardour/audioregion.h"
+#include "ardour/boost_debug.h"
#include "ardour/dB.h"
#include "ardour/location.h"
#include "ardour/midi_region.h"
#include "transform_dialog.h"
#include "ui_config.h"
-#include "i18n.h"
+#include "pbd/i18n.h"
using namespace std;
using namespace ARDOUR;
}
void
-Editor::split_regions_at (framepos_t where, RegionSelection& regions)
+Editor::split_regions_at (framepos_t where, RegionSelection& regions, const int32_t sub_num)
{
bool frozen = false;
if (pl) {
pl->clear_changes ();
- pl->split_region ((*a)->region(), where);
+ pl->split_region ((*a)->region(), where, sub_num);
_session->add_command (new StatefulDiffCommand (pl));
}
} else {
loc->set_end (max_framepos);
}
+ if (loc->is_session_range()) {
+ _session->set_end_is_free (false);
+ }
}
if (!in_command) {
begin_reversible_command (_("nudge location forward"));
} else {
loc->set_end (loc->length());
}
+ if (loc->is_session_range()) {
+ _session->set_end_is_free (false);
+ }
}
if (!in_command) {
begin_reversible_command (_("nudge location forward"));
return false;
}
+void
+Editor::scroll_left_step ()
+{
+ framepos_t xdelta = (current_page_samples() / 8);
+
+ if (leftmost_frame > xdelta) {
+ reset_x_origin (leftmost_frame - xdelta);
+ } else {
+ reset_x_origin (0);
+ }
+}
+
+
+void
+Editor::scroll_right_step ()
+{
+ framepos_t xdelta = (current_page_samples() / 8);
+
+ if (max_framepos - xdelta > leftmost_frame) {
+ reset_x_origin (leftmost_frame + xdelta);
+ } else {
+ reset_x_origin (max_framepos - current_page_samples());
+ }
+}
+
+void
+Editor::scroll_left_half_page ()
+{
+ framepos_t xdelta = (current_page_samples() / 2);
+ if (leftmost_frame > xdelta) {
+ reset_x_origin (leftmost_frame - xdelta);
+ } else {
+ reset_x_origin (0);
+ }
+}
+
+void
+Editor::scroll_right_half_page ()
+{
+ framepos_t xdelta = (current_page_samples() / 2);
+ if (max_framepos - xdelta > leftmost_frame) {
+ reset_x_origin (leftmost_frame + xdelta);
+ } else {
+ reset_x_origin (max_framepos - current_page_samples());
+ }
+}
+
/* ZOOM */
void
}
}
+void
+Editor::temporal_zoom_step_mouse_focus (bool coarser)
+{
+ Editing::ZoomFocus temp_focus = zoom_focus;
+ zoom_focus = Editing::ZoomFocusMouse;
+ temporal_zoom_step (coarser);
+ zoom_focus = temp_focus;
+}
void
Editor::temporal_zoom_step (bool coarser)
bool
-Editor::get_selection_extents ( framepos_t &start, framepos_t &end )
+Editor::get_selection_extents (framepos_t &start, framepos_t &end) const
{
start = max_framepos;
end = 0;
commit_reversible_command ();
}
+
+ _session->set_end_is_free (false);
}
void
void
Editor::play_selection ()
{
- framepos_t start, end;
+ framepos_t start, end;
if (!get_selection_extents ( start, end))
return;
return;
}
- ArdourDialog d (*this, _("Rename Region"), true, false);
+ ArdourDialog d (_("Rename Region"), true, false);
Entry entry;
Label label (_("New name:"));
HBox hbox;
for (TrackSelection::iterator i = tmptracks.begin(); i != tmptracks.end(); ++i) {
- RouteTimeAxisView* rtv;
-
- if ((rtv = dynamic_cast<RouteTimeAxisView*> ((*i))) != 0) {
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> ((*i));
- if (rtv->is_track()) {
+ if (!rtv) {
+ continue;
+ }
- /* no edits to destructive tracks */
+ if (!rtv->is_track()) {
+ continue;
+ }
- if (rtv->track()->destructive()) {
- continue;
- }
+ /* no edits to destructive tracks */
- if ((playlist = rtv->playlist()) != 0) {
+ if (rtv->track()->destructive()) {
+ continue;
+ }
- playlist->clear_changes ();
+ if ((playlist = rtv->playlist()) != 0) {
- /* XXX need to consider musical time selections here at some point */
+ playlist->clear_changes ();
- double speed = rtv->track()->speed();
+ /* XXX need to consider musical time selections here at some point */
+ double speed = rtv->track()->speed();
- for (list<AudioRange>::const_iterator t = ts.begin(); t != ts.end(); ++t) {
+ for (list<AudioRange>::const_iterator t = ts.begin(); t != ts.end(); ++t) {
- sigc::connection c = rtv->view()->RegionViewAdded.connect (
- sigc::mem_fun(*this, &Editor::collect_new_region_view));
+ sigc::connection c = rtv->view()->RegionViewAdded.connect (
+ sigc::mem_fun(*this, &Editor::collect_new_region_view));
- latest_regionviews.clear ();
+ latest_regionviews.clear ();
- playlist->partition ((framepos_t)((*t).start * speed),
- (framepos_t)((*t).end * speed), false);
+ playlist->partition ((framepos_t)((*t).start * speed),
+ (framepos_t)((*t).end * speed), false);
- c.disconnect ();
+ c.disconnect ();
- if (!latest_regionviews.empty()) {
+ if (!latest_regionviews.empty()) {
- rtv->view()->foreach_regionview (sigc::bind (
- sigc::ptr_fun (add_if_covered),
- &(*t), &new_selection));
+ rtv->view()->foreach_regionview (sigc::bind (
+ sigc::ptr_fun (add_if_covered),
+ &(*t), &new_selection));
- if (!in_command) {
- begin_reversible_command (_("separate"));
- in_command = true;
- }
+ if (!in_command) {
+ begin_reversible_command (_("separate"));
+ in_command = true;
+ }
- /* pick up changes to existing regions */
+ /* pick up changes to existing regions */
- vector<Command*> cmds;
- playlist->rdiff (cmds);
- _session->add_commands (cmds);
+ vector<Command*> cmds;
+ playlist->rdiff (cmds);
+ _session->add_commands (cmds);
- /* pick up changes to the playlist itself (adds/removes)
- */
+ /* pick up changes to the playlist itself (adds/removes)
+ */
- _session->add_command(new StatefulDiffCommand (playlist));
- }
- }
+ _session->add_command(new StatefulDiffCommand (playlist));
}
}
}
if (!playlist) {
// is this check necessary?
- continue;
+ continue;
}
vector<PlaylistState>::iterator i;
for (TrackSelection::iterator i = ts.begin(); i != ts.end(); ++i) {
- RouteTimeAxisView* rtv;
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> ((*i));
- if ((rtv = dynamic_cast<RouteTimeAxisView*> ((*i))) != 0) {
+ if (!rtv) {
+ continue;
+ }
- boost::shared_ptr<Track> t = rtv->track();
+ boost::shared_ptr<Track> t = rtv->track();
- if (t != 0 && ! t->destructive()) {
+ if (t != 0 && ! t->destructive()) {
- if ((playlist = rtv->playlist()) != 0) {
- playlists.push_back (playlist);
- }
+ if ((playlist = rtv->playlist()) != 0) {
+ playlists.push_back (playlist);
}
}
}
return;
}
- framepos_t the_start;
- framepos_t the_end;
- framepos_t cnt;
+ framepos_t pos;
+ framepos_t new_start;
+ framepos_t new_end;
+ framecnt_t new_length;
bool in_command = false;
for (vector<boost::shared_ptr<Playlist> >::iterator i = playlists.begin(); i != playlists.end(); ++i) {
boost::shared_ptr<Region> region_at_start = (*i)->top_region_at(start);
boost::shared_ptr<Region> region_at_end = (*i)->top_region_at(end);
- vector<boost::shared_ptr<Region>> regions;
+ vector<boost::shared_ptr<Region> > regions;
if (region_at_start != 0) {
regions.push_back (region_at_start);
}
/* now adjust lengths */
- for (vector<boost::shared_ptr<Region>>::iterator i = regions.begin(); i != regions.end(); ++i) {
+ for (vector<boost::shared_ptr<Region> >::iterator i = regions.begin(); i != regions.end(); ++i) {
- the_start = max (start, (framepos_t) (*i)->position());
- if (max_framepos - the_start < (*i)->length()) {
- the_end = the_start + (*i)->length() - 1;
+ pos = (*i)->position();
+ new_start = max (start, pos);
+ if (max_framepos - pos > (*i)->length()) {
+ new_end = pos + (*i)->length() - 1;
} else {
- the_end = max_framepos;
+ new_end = max_framepos;
}
- the_end = min (end, the_end);
- cnt = the_end - the_start + 1;
+ new_end = min (end, new_end);
+ new_length = new_end - new_start + 1;
if(!in_command) {
begin_reversible_command (_("trim to selection"));
in_command = true;
}
(*i)->clear_changes ();
- (*i)->trim_to (the_start, cnt);
+ (*i)->trim_to (new_start, new_length);
_session->add_command (new StatefulDiffCommand (*i));
}
}
sigc::connection c = rtv->view()->RegionViewAdded.connect (sigc::mem_fun(*this, &Editor::collect_new_region_view));
framepos_t const position = end_frame + (r->first_frame() - start_frame + 1);
- playlist = (*i)->region()->playlist();
+ playlist = (*i)->region()->playlist();
playlist->clear_changes ();
playlist->duplicate_until (r, position, gap, end);
_session->add_command(new StatefulDiffCommand (playlist));
commit_reversible_command ();
}
-void
-Editor::region_fill_selection ()
-{
- if (clicked_routeview == 0 || !clicked_routeview->is_audio_track()) {
- return;
- }
-
- if (selection->time.empty()) {
- return;
- }
-
- boost::shared_ptr<Region> region = _regions->get_single_selection ();
- if (region == 0) {
- return;
- }
-
- framepos_t start = selection->time[clicked_selection].start;
- framepos_t end = selection->time[clicked_selection].end;
-
- boost::shared_ptr<Playlist> playlist;
-
- if (selection->tracks.empty()) {
- return;
- }
-
- framepos_t selection_length = end - start;
- float times = (float)selection_length / region->length();
- bool in_command = false;
-
- TrackViewList ts = selection->tracks.filter_to_unique_playlists ();
- RegionSelection foo;
-
- for (TrackViewList::iterator i = ts.begin(); i != ts.end(); ++i) {
-
- if ((playlist = (*i)->playlist()) == 0) {
- continue;
- }
-
- if (!in_command) {
- begin_reversible_command (Operations::fill_selection);
- in_command = true;
- }
- RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*i);
- latest_regionviews.clear ();
- sigc::connection c = rtv->view()->RegionViewAdded.connect (sigc::mem_fun(*this, &Editor::collect_new_region_view));
-
- playlist->clear_changes ();
- playlist->add_region (RegionFactory::create (region, true), start, times);
- _session->add_command (new StatefulDiffCommand (playlist));
- c.disconnect ();
- foo.insert (foo.end(), latest_regionviews.begin(), latest_regionviews.end());
- }
-
- if (in_command) {
- if (!foo.empty()) {
- selection->set (foo);
- }
- commit_reversible_command ();
- }
-}
-
void
Editor::set_region_sync_position ()
{
gtk_main_iteration ();
}
+ pthread_join (itt.thread, 0);
current_interthread_info = 0;
}
for (TrackViewList::iterator i = views.begin(); i != views.end(); ++i) {
- RouteTimeAxisView* rtv;
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*i);
- if ((rtv = dynamic_cast<RouteTimeAxisView*> (*i)) == 0) {
+ if (!rtv) {
continue;
}
Location* loc = find_location_from_marker (entered_marker, ignored);
if (_session && loc) {
+ entered_marker = NULL;
Glib::signal_idle().connect (sigc::bind (sigc::mem_fun(*this, &Editor::really_remove_marker), loc));
}
if (!playlist) {
// is this check necessary?
- continue;
+ continue;
}
/* get_regions_from_selection_and_entered() guarantees that
list<boost::shared_ptr<Playlist> > foo;
- /* the pmap is in the same order as the tracks in which selected regions occured */
+ /* the pmap is in the same order as the tracks in which selected regions occurred */
for (vector<PlaylistMapping>::iterator i = pmap.begin(); i != pmap.end(); ++i) {
if ((*i).pl) {
{
DEBUG_TRACE (DEBUG::CutNPaste, "paste to preferred edit pos\n");
- paste_internal (get_preferred_edit_position (EDIT_IGNORE_NONE, from_context), times);
+ paste_internal (get_preferred_edit_position (EDIT_IGNORE_NONE, from_context), times, get_grid_music_divisions (0));
}
void
}
snap_to (where);
- paste_internal (where, 1);
+ paste_internal (where, 1, get_grid_music_divisions (0));
}
void
-Editor::paste_internal (framepos_t position, float times)
+Editor::paste_internal (framepos_t position, float times, const int32_t sub_num)
{
DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("apparent paste position is %1\n", position));
"greedy" paste from one automation type to another. */
PasteContext ctx(paste_count, times, ItemCounts(), true);
- ts.front()->paste (position, *cut_buffer, ctx);
+ ts.front()->paste (position, *cut_buffer, ctx, sub_num);
} else {
PasteContext ctx(paste_count, times, ItemCounts(), false);
for (TrackViewList::iterator i = ts.begin(); i != ts.end(); ++i) {
- (*i)->paste (position, *cut_buffer, ctx);
+ (*i)->paste (position, *cut_buffer, ctx, sub_num);
}
}
sigc::connection c = rtv->view()->RegionViewAdded.connect (sigc::mem_fun(*this, &Editor::collect_new_region_view));
framepos_t const position = end_frame + (r->first_frame() - start_frame + 1);
- playlist = (*i)->region()->playlist();
+ playlist = (*i)->region()->playlist();
playlist->clear_changes ();
playlist->duplicate (r, position, gap, times);
_session->add_command(new StatefulDiffCommand (playlist));
}
boost::shared_ptr<Playlist> playlist;
- vector<boost::shared_ptr<Region> > new_regions;
- vector<boost::shared_ptr<Region> >::iterator ri;
-
- create_region_from_selection (new_regions);
-
- if (new_regions.empty()) {
- return;
- }
-
- ri = new_regions.begin();
TrackViewList ts = selection->tracks.filter_to_unique_playlists ();
+
bool in_command = false;
for (TrackViewList::iterator i = ts.begin(); i != ts.end(); ++i) {
continue;
}
playlist->clear_changes ();
- framepos_t end;
+
if (clicked_selection) {
- end = selection->time[clicked_selection].end;
+ playlist->duplicate_range (selection->time[clicked_selection], times);
} else {
- end = selection->time.end_frame();
+ playlist->duplicate_ranges (selection->time, times);
}
- playlist->duplicate (*ri, end + 1, times);
if (!in_command) {
- begin_reversible_command (_("duplicate selection"));
+ begin_reversible_command (_("duplicate range selection"));
in_command = true;
}
_session->add_command (new StatefulDiffCommand (playlist));
- ++ri;
- if (ri == new_regions.end()) {
- --ri;
- }
}
if (in_command) {
+ // now "move" range selection to after the current range selection
+ framecnt_t distance = 0;
+
+ if (clicked_selection) {
+ distance = selection->time[clicked_selection].end -
+ selection->time[clicked_selection].start;
+ } else {
+ distance = selection->time.end_frame() - selection->time.start();
+ }
+
+ selection->move_time (distance);
+
commit_reversible_command ();
}
}
StripSilenceDialog d (_session, audio_only);
int const r = d.run ();
- d.drop_rects ();
+ d.drop_rects ();
- if (r == Gtk::RESPONSE_OK) {
- ARDOUR::AudioIntervalMap silences;
- d.silences (silences);
+ if (r == Gtk::RESPONSE_OK) {
+ ARDOUR::AudioIntervalMap silences;
+ d.silences (silences);
StripSilence s (*_session, silences, d.fade_length());
+
apply_filter (s, _("strip silence"), &d);
}
}
playlist->clear_changes ();
playlist->clear_owned_changes ();
+ if (!in_command) {
+ begin_reversible_command (command);
+ in_command = true;
+ }
+
if (filter.results.empty ()) {
/* no regions returned; remove the old one */
}
}
+
/* We might have removed regions, which alters other regions' layering_index,
so we need to do a recursive diff here.
*/
-
- if (!in_command) {
- begin_reversible_command (command);
- in_command = true;
- }
vector<Command*> cmds;
playlist->rdiff (cmds);
_session->add_commands (cmds);
continue;
if (first) {
- new_state = !rtav->track()->record_enabled();
+ new_state = !rtav->track()->rec_enable_control()->get_value();
first = false;
}
- rtav->track()->set_record_enabled (new_state, this);
+ rtav->track()->rec_enable_control()->set_value (new_state, Controllable::UseGroup);
}
}
{
bool new_state = false;
bool first = true;
- boost::shared_ptr<RouteList> rl (new RouteList);
+ boost::shared_ptr<ControlList> cl (new ControlList);
for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
RouteTimeAxisView *rtav = dynamic_cast<RouteTimeAxisView *>(*i);
first = false;
}
- rl->push_back (rtav->route());
+ cl->push_back (rtav->route()->solo_control());
}
- _session->set_solo (rl, new_state, Session::rt_cleanup, true);
+ _session->set_controls (cl, new_state ? 1.0 : 0.0, Controllable::UseGroup);
}
void
rl->push_back (rtav->route());
}
- _session->set_mute (rl, new_state, Session::rt_cleanup, true);
+ _session->set_controls (route_list_to_control_list (rl, &Stripable::mute_control), new_state, Controllable::UseGroup);
}
void
return;
}
- split_regions_at (where, rs);
+ if (snap_musical()) {
+ split_regions_at (where, rs, get_grid_music_divisions (0));
+ } else {
+ split_regions_at (where, rs, 0);
+ }
}
}
-struct EditorOrderRouteSorter {
- bool operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b) {
- return a->order_key () < b->order_key ();
- }
-};
-
void
Editor::select_next_route()
{
RouteUI *rui;
do {
for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
+
if (*i == current) {
++i;
if (i != track_views.end()) {
break;
}
}
+
rui = dynamic_cast<RouteUI *>(current);
- } while ( current->hidden() || (rui != NULL && !rui->route()->active()));
- selection->set(current);
+ } while (current->hidden() || (rui == NULL) || !rui->route()->active());
+
+ selection->set (current);
ensure_time_axis_view_is_visible (*current, false);
}
RouteUI *rui;
do {
for (TrackViewList::reverse_iterator i = track_views.rbegin(); i != track_views.rend(); ++i) {
+
if (*i == current) {
++i;
if (i != track_views.rend()) {
}
}
rui = dynamic_cast<RouteUI *>(current);
- } while ( current->hidden() || (rui != NULL && !rui->route()->active()));
+
+ } while (current->hidden() || (rui == NULL) || !rui->route()->active());
selection->set (current);
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
+ _session->set_session_extents (start, end); // this will create a new session range; no need for UNDO
} else {
XMLNode &before = loc->get_state();
- _session->set_session_extents ( start, end );
+ _session->set_session_extents (start, end);
XMLNode &after = loc->get_state();
commit_reversible_command ();
}
+
+ _session->set_end_is_free (false);
}
void
{
framepos_t length = end - start;
- const Meter& m (_session->tempo_map().meter_at (start));
+ const Meter& m (_session->tempo_map().meter_at_frame (start));
/* length = 1 bar */
- /* now we want frames per beat.
+ /* We're going to deliver a constant tempo here,
+ so we can use frames per beat to determine length.
+ now we want frames per beat.
we have frames per bar, and beats per bar, so ...
*/
*/
- const TempoSection& t (_session->tempo_map().tempo_section_at (start));
+ const TempoSection& t (_session->tempo_map().tempo_section_at_frame (start));
bool do_global = false;
} else if (t.frame() == start) {
_session->tempo_map().change_existing_tempo_at (start, beats_per_minute, t.note_type());
} else {
- Timecode::BBT_Time bbt;
- _session->tempo_map().bbt_time (start, bbt);
- _session->tempo_map().add_tempo (Tempo (beats_per_minute, t.note_type()), bbt);
+ const Tempo tempo (beats_per_minute, t.note_type());
+ _session->tempo_map().add_tempo (tempo, 0.0, start, TempoSection::Constant, AudioTime);
}
XMLNode& after (_session->tempo_map().get_state());
boost::shared_ptr<AudioRegion> ar = boost::dynamic_pointer_cast<AudioRegion> ((*i)->region());
- if (ar && (ar->get_transients (positions) == 0)) {
+ if (ar) {
+ ar->transients (positions);
split_region_at_points ((*i)->region(), positions, true);
positions.clear ();
}
return;
}
-
if (positions.size() > 20 && can_ferret) {
std::string msgstr = string_compose (_("You are about to split\n%1\ninto %2 pieces.\nThis could take a long time."), r->name(), positions.size() + 1);
MessageDialog msg (msgstr,
framepos_t pos = 0;
+ framepos_t rstart = r->first_frame ();
+ framepos_t rend = r->last_frame ();
+
while (x != positions.end()) {
/* deal with positons that are out of scope of present region bounds */
- if (*x <= 0 || *x > r->length()) {
+ if (*x <= rstart || *x > rend) {
++x;
continue;
}
- /* file start = original start + how far we from the initial position ?
- */
+ /* file start = original start + how far we from the initial position ? */
framepos_t file_start = r->start() + pos;
- /* length = next position - current position
- */
+ /* length = next position - current position */
- framepos_t len = (*x) - pos;
+ framepos_t len = (*x) - pos - rstart;
/* XXX we do we really want to allow even single-sample regions?
- shouldn't we have some kind of lower limit on region size?
- */
+ * shouldn't we have some kind of lower limit on region size?
+ */
if (len <= 0) {
break;
plist.add (ARDOUR::Properties::length, len);
plist.add (ARDOUR::Properties::name, new_name);
plist.add (ARDOUR::Properties::layer, 0);
+ // TODO set transients_offset
boost::shared_ptr<Region> nr = RegionFactory::create (r->sources(), plist, false);
/* because we set annouce to false, manually add the new region to the
- RegionFactory map
- */
+ * RegionFactory map
+ */
RegionFactory::map_add (nr);
- pl->add_region (nr, r->position() + pos);
+ pl->add_region (nr, rstart + pos);
if (select_new) {
new_regions.push_front(nr);
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);
+ (*r)->region()->add_transient(where);
}
commit_reversible_command ();
bool
Editor::idle_remove_tracks ()
{
+ Session::StateProtector sp (_session);
_remove_tracks ();
return false; /* do not call again */
}
}
{
- Session::StateProtector sp (_session);
DisplaySuspender ds;
+ boost::shared_ptr<RouteList> rl (new RouteList);
for (vector<boost::shared_ptr<Route> >::iterator x = routes.begin(); x != routes.end(); ++x) {
- _session->remove_route (*x);
+ rl->push_back (*x);
}
+ _session->remove_routes (rl);
}
+ /* TrackSelection and RouteList leave scope,
+ * destructors are called,
+ * diskstream drops references, save_state is called (again for every track)
+ */
}
void
return;
}
- InsertTimeOption opt = d.intersected_region_action ();
-
insert_time (
- get_preferred_edit_position(),
+ get_preferred_edit_position (EDIT_IGNORE_MOUSE),
d.distance(),
- opt,
+ d.intersected_region_action (),
d.all_playlists(),
d.move_glued(),
d.move_markers(),
(*i)->clear_owned_changes ();
if (opt == SplitIntersected) {
- (*i)->split (pos);
+ /* non musical split */
+ (*i)->split (pos, 0);
}
(*i)->shift (pos, frames, (opt == MoveIntersected), ignore_music_glue);
pl->shift (pos, -frames, true, ignore_music_glue);
if (!in_command) {
- begin_reversible_command (_("cut time"));
+ begin_reversible_command (_("remove time"));
in_command = true;
}
XMLNode &after = pl->get_state();
RouteTimeAxisView* rtav = dynamic_cast<RouteTimeAxisView*> (*x);
if (rtav) {
if (!in_command) {
- begin_reversible_command (_("cut time"));
+ begin_reversible_command (_("remove time"));
in_command = true;
}
rtav->route ()->shift (pos, -frames);
if (moved) {
if (!in_command) {
- begin_reversible_command (_("cut time"));
+ begin_reversible_command (_("remove time"));
in_command = true;
}
XMLNode& after (_session->locations()->get_state());
double first_y_pos = DBL_MAX;
if (h < TimeAxisView::preset_height (HeightSmall)) {
- MessageDialog msg (*this, _("There are too many tracks to fit in the current window"));
+ MessageDialog msg (_("There are too many tracks to fit in the current window"));
/* too small to be displayed */
return;
}
{
Timers::TimerSuspender t;
label->set_text (string_compose ("Copying %1, %2 of %3", name, n, total));
- Gtkmm2ext::UI::instance()->flush_pending ();
+ Gtkmm2ext::UI::instance()->flush_pending (1);
}
void
*/
Timers::TimerSuspender t;
- Gtkmm2ext::UI::instance()->flush_pending ();
+ Gtkmm2ext::UI::instance()->flush_pending (3);
cerr << " Do it\n";