#include <gtkmm2ext/utils.h>
#include <gtkmm2ext/choice.h>
#include <gtkmm2ext/window_title.h>
+#include <gtkmm2ext/popup.h>
+
#include <ardour/audioengine.h>
#include <ardour/session.h>
#include "audio_time_axis.h"
#include "automation_time_axis.h"
#include "streamview.h"
+#include "audio_streamview.h"
#include "audio_region_view.h"
#include "rgb_macros.h"
#include "selection_templates.h"
}
void
-Editor::split_region_at (nframes_t where)
+Editor::split_region_at (nframes64_t where)
{
RegionSelection rs;
}
void
-Editor::split_regions_at (nframes_t where, RegionSelection& regions)
+Editor::split_regions_at (nframes64_t where, RegionSelection& regions)
{
if (regions.empty()) {
return;
} else {
snap_to (where);
}
-
+
+ cerr << "Split " << regions.size() << " at " << where << endl;
for (RegionSelection::iterator a = regions.begin(); a != regions.end(); ) {
}
void
-Editor::destroy_clicked_region ()
+Editor::remove_region ()
{
- uint32_t selected = selection->regions.size();
-
- if (!session || !selected) {
- return;
- }
- vector<string> choices;
- string prompt;
+ RegionSelection rs;
+ get_regions_for_action (rs);
- prompt = string_compose (_(" This is destructive, will possibly delete audio files\n\
-It cannot be undone\n\
-Do you really want to destroy %1 ?"),
- (selected > 1 ?
- _("these regions") : _("this region")));
-
- choices.push_back (_("No, do nothing."));
-
- if (selected > 1) {
- choices.push_back (_("Yes, destroy them."));
- } else {
- choices.push_back (_("Yes, destroy it."));
+ if (!session) {
+ return;
}
- Gtkmm2ext::Choice prompter (prompt, choices);
-
- if (prompter.run() == 0) { /* first choice */
+ if (rs.empty()) {
return;
}
- if (selected) {
- list<boost::shared_ptr<Region> > r;
+ begin_reversible_command (_("remove region"));
- for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
- r.push_back ((*i)->region());
- }
+ list<boost::shared_ptr<Region> > regions_to_remove;
- session->destroy_regions (r);
- }
+ for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
+ // we can't just remove the region(s) in this loop because
+ // this removes them from the RegionSelection, and they thus
+ // disappear from underneath the iterator, and the ++i above
+ // SEGVs in a puzzling fashion.
+
+ // so, first iterate over the regions to be removed from rs and
+ // add them to the regions_to_remove list, and then
+ // iterate over the list to actually remove them.
+
+ regions_to_remove.push_back ((*i)->region());
+ }
+
+ for (list<boost::shared_ptr<Region> >::iterator rl = regions_to_remove.begin(); rl != regions_to_remove.end(); ++rl) {
+ boost::shared_ptr<Playlist> playlist = (*rl)->playlist();
+ if (!playlist) {
+ // is this check necessary?
+ continue;
+ }
+
+ XMLNode &before = playlist->get_state();
+ playlist->remove_region (*rl);
+ XMLNode &after = playlist->get_state();
+ session->add_command(new MementoCommand<Playlist>(*playlist, &before, &after));
+ }
+ commit_reversible_command ();
}
boost::shared_ptr<Region>
{
RegionView* rv;
boost::shared_ptr<Region> region;
- nframes_t start = 0;
+ nframes64_t start = 0;
if (selection->time.start () == selection->time.end_frame ()) {
{
TimeAxisView *tv;
boost::shared_ptr<Region> region;
- nframes_t start;
+ nframes64_t start;
if ((region = select_region_for_operation (next ? 1 : 0, &tv)) == 0) {
return;
{
TimeAxisView *tv;
boost::shared_ptr<Region> region;
- nframes_t end;
+ nframes64_t end;
if ((region = select_region_for_operation (previous ? -1 : 0, &tv)) == 0) {
return;
void
Editor::nudge_forward (bool next, bool force_playhead)
{
- nframes_t distance;
- nframes_t next_distance;
+ nframes64_t distance;
+ nframes64_t next_distance;
RegionSelection rs;
get_regions_for_action (rs);
} else if (!force_playhead && !selection->markers.empty()) {
bool is_start;
- Location* loc = find_location_from_marker (selection->markers.front(), is_start);
-
- if (loc) {
-
- begin_reversible_command (_("nudge location forward"));
-
- XMLNode& before (loc->get_state());
- if (is_start) {
- distance = get_nudge_distance (loc->start(), next_distance);
- if (next) {
- distance = next_distance;
- }
- if (max_frames - distance > loc->start() + loc->length()) {
- loc->set_start (loc->start() + distance);
- } else {
- loc->set_start (max_frames - loc->length());
- }
- } else {
- distance = get_nudge_distance (loc->end(), next_distance);
- if (next) {
- distance = next_distance;
- }
- if (max_frames - distance > loc->end()) {
- loc->set_end (loc->end() + distance);
+ begin_reversible_command (_("nudge location forward"));
+
+ for (MarkerSelection::iterator i = selection->markers.begin(); i != selection->markers.end(); ++i) {
+
+ Location* loc = find_location_from_marker ((*i), is_start);
+
+ if (loc) {
+
+ XMLNode& before (loc->get_state());
+
+ if (is_start) {
+ distance = get_nudge_distance (loc->start(), next_distance);
+ if (next) {
+ distance = next_distance;
+ }
+ if (max_frames - distance > loc->start() + loc->length()) {
+ loc->set_start (loc->start() + distance);
+ } else {
+ loc->set_start (max_frames - loc->length());
+ }
} else {
- loc->set_end (max_frames);
+ distance = get_nudge_distance (loc->end(), next_distance);
+ if (next) {
+ distance = next_distance;
+ }
+ if (max_frames - distance > loc->end()) {
+ loc->set_end (loc->end() + distance);
+ } else {
+ loc->set_end (max_frames);
+ }
}
+ XMLNode& after (loc->get_state());
+ session->add_command (new MementoCommand<Location>(*loc, &before, &after));
}
- XMLNode& after (loc->get_state());
- session->add_command (new MementoCommand<Location>(*loc, &before, &after));
- commit_reversible_command ();
}
+ commit_reversible_command ();
+
} else {
distance = get_nudge_distance (playhead_cursor->current_frame, next_distance);
session->request_locate (playhead_cursor->current_frame + distance);
void
Editor::nudge_backward (bool next, bool force_playhead)
{
- nframes_t distance;
- nframes_t next_distance;
+ nframes64_t distance;
+ nframes64_t next_distance;
RegionSelection rs;
get_regions_for_action (rs);
} else if (!force_playhead && !selection->markers.empty()) {
bool is_start;
- Location* loc = find_location_from_marker (selection->markers.front(), is_start);
- if (loc) {
-
- begin_reversible_command (_("nudge location forward"));
- XMLNode& before (loc->get_state());
-
- if (is_start) {
- distance = get_nudge_distance (loc->start(), next_distance);
- if (next) {
- distance = next_distance;
- }
- if (distance < loc->start()) {
- loc->set_start (loc->start() - distance);
- } else {
- loc->set_start (0);
- }
- } else {
- distance = get_nudge_distance (loc->end(), next_distance);
+ begin_reversible_command (_("nudge location forward"));
- if (next) {
- distance = next_distance;
- }
+ for (MarkerSelection::iterator i = selection->markers.begin(); i != selection->markers.end(); ++i) {
- if (distance < loc->end() - loc->length()) {
- loc->set_end (loc->end() - distance);
+ Location* loc = find_location_from_marker ((*i), is_start);
+
+ if (loc) {
+
+ XMLNode& before (loc->get_state());
+
+ if (is_start) {
+ distance = get_nudge_distance (loc->start(), next_distance);
+ if (next) {
+ distance = next_distance;
+ }
+ if (distance < loc->start()) {
+ loc->set_start (loc->start() - distance);
+ } else {
+ loc->set_start (0);
+ }
} else {
- loc->set_end (loc->length());
+ distance = get_nudge_distance (loc->end(), next_distance);
+
+ if (next) {
+ distance = next_distance;
+ }
+
+ if (distance < loc->end() - loc->length()) {
+ loc->set_end (loc->end() - distance);
+ } else {
+ loc->set_end (loc->length());
+ }
}
+
+ XMLNode& after (loc->get_state());
+ session->add_command (new MementoCommand<Location>(*loc, &before, &after));
}
-
- XMLNode& after (loc->get_state());
- session->add_command (new MementoCommand<Location>(*loc, &before, &after));
}
-
+
+ commit_reversible_command ();
+
} else {
distance = get_nudge_distance (playhead_cursor->current_frame, next_distance);
void
Editor::nudge_forward_capture_offset ()
{
- nframes_t distance;
+ nframes64_t distance;
RegionSelection rs;
get_regions_for_action (rs);
void
Editor::nudge_backward_capture_offset ()
{
- nframes_t distance;
+ nframes64_t distance;
RegionSelection rs;
get_regions_for_action (rs);
void
Editor::build_region_boundary_cache ()
{
- nframes_t pos = 0;
+ nframes64_t pos = 0;
vector<RegionPoint> interesting_points;
boost::shared_ptr<Region> r;
TrackViewList tracks;
while (pos < session->current_end_frame() && !at_end) {
- nframes_t rpos;
- nframes_t lpos = max_frames;
+ nframes64_t rpos;
+ nframes64_t lpos = max_frames;
for (vector<RegionPoint>::iterator p = interesting_points.begin(); p != interesting_points.end(); ++p) {
to sort later.
*/
- vector<nframes_t>::iterator ri;
+ vector<nframes64_t>::iterator ri;
for (ri = region_boundary_cache.begin(); ri != region_boundary_cache.end(); ++ri) {
if (*ri == rpos) {
}
boost::shared_ptr<Region>
-Editor::find_next_region (nframes_t frame, RegionPoint point, int32_t dir, TrackViewList& tracks, TimeAxisView **ontrack)
+Editor::find_next_region (nframes64_t frame, RegionPoint point, int32_t dir, TrackViewList& tracks, TimeAxisView **ontrack)
{
TrackViewList::iterator i;
- nframes_t closest = max_frames;
+ nframes64_t closest = max_frames;
boost::shared_ptr<Region> ret;
- nframes_t rpos = 0;
+ nframes64_t rpos = 0;
float track_speed;
- nframes_t track_frame;
+ nframes64_t track_frame;
AudioTimeAxisView *atav;
for (i = tracks.begin(); i != tracks.end(); ++i) {
- nframes_t distance;
+ nframes64_t distance;
boost::shared_ptr<Region> r;
track_speed = 1.0f;
Editor::cursor_to_region_point (Cursor* cursor, RegionPoint point, int32_t dir)
{
boost::shared_ptr<Region> r;
- nframes_t pos = cursor->current_frame;
+ nframes64_t pos = cursor->current_frame;
if (!session) {
return;
void
Editor::cursor_to_selection_start (Cursor *cursor)
{
- nframes_t pos = 0;
+ nframes64_t pos = 0;
RegionSelection rs;
get_regions_for_action (rs);
void
Editor::cursor_to_selection_end (Cursor *cursor)
{
- nframes_t pos = 0;
+ nframes64_t pos = 0;
RegionSelection rs;
get_regions_for_action (rs);
Editor::selected_marker_to_region_point (RegionPoint point, int32_t dir)
{
boost::shared_ptr<Region> r;
- nframes_t pos;
+ nframes64_t pos;
Location* loc;
bool ignored;
void
Editor::selected_marker_to_selection_start ()
{
- nframes_t pos = 0;
+ nframes64_t pos = 0;
Location* loc;
bool ignored;
void
Editor::selected_marker_to_selection_end ()
{
- nframes_t pos = 0;
+ nframes64_t pos = 0;
Location* loc;
bool ignored;
void
Editor::scroll_playhead (bool forward)
{
- nframes_t pos = playhead_cursor->current_frame;
- nframes_t delta = (nframes_t) floor (current_page_frames() / 0.8);
+ nframes64_t pos = playhead_cursor->current_frame;
+ nframes64_t delta = (nframes64_t) floor (current_page_frames() / 0.8);
if (forward) {
if (pos == max_frames) {
void
Editor::playhead_backward ()
{
- nframes_t pos;
- nframes_t cnt;
+ nframes64_t pos;
+ nframes64_t cnt;
float prefix;
bool was_floating;
cnt = 1;
} else {
if (was_floating) {
- cnt = (nframes_t) floor (prefix * session->frame_rate ());
+ cnt = (nframes64_t) floor (prefix * session->frame_rate ());
} else {
- cnt = (nframes_t) prefix;
+ cnt = (nframes64_t) prefix;
}
}
pos = playhead_cursor->current_frame;
- if ((nframes_t) pos < cnt) {
+ if ((nframes64_t) pos < cnt) {
pos = 0;
} else {
pos -= cnt;
void
Editor::playhead_forward ()
{
- nframes_t pos;
- nframes_t cnt;
+ nframes64_t pos;
+ nframes64_t cnt;
bool was_floating;
float prefix;
cnt = 1;
} else {
if (was_floating) {
- cnt = (nframes_t) floor (prefix * session->frame_rate ());
+ cnt = (nframes64_t) floor (prefix * session->frame_rate ());
} else {
- cnt = (nframes_t) floor (prefix);
+ cnt = (nframes64_t) floor (prefix);
}
}
cnt = 1;
} else {
if (was_floating) {
- cnt = (nframes_t) floor (prefix * session->frame_rate ());
+ cnt = (nframes64_t) floor (prefix * session->frame_rate ());
} else {
- cnt = (nframes_t) prefix;
+ cnt = (nframes64_t) prefix;
}
}
void
Editor::edit_cursor_forward ()
{
- //nframes_t pos;
- nframes_t cnt;
+ //nframes64_t pos;
+ nframes64_t cnt;
bool was_floating;
float prefix;
cnt = 1;
} else {
if (was_floating) {
- cnt = (nframes_t) floor (prefix * session->frame_rate ());
+ cnt = (nframes64_t) floor (prefix * session->frame_rate ());
} else {
- cnt = (nframes_t) floor (prefix);
+ cnt = (nframes64_t) floor (prefix);
}
}
{
float prefix;
bool was_floating;
- nframes_t frame;
+ nframes64_t frame;
if (get_prefix (prefix, was_floating)) {
return;
}
if (was_floating) {
- frame = (nframes_t) floor (prefix * session->frame_rate());
+ frame = (nframes64_t) floor (prefix * session->frame_rate());
} else {
- frame = (nframes_t) floor (prefix);
+ frame = (nframes64_t) floor (prefix);
}
session->request_locate (frame);
void
Editor::scroll_backward (float pages)
{
- nframes_t frame;
- nframes_t one_page = (nframes_t) rint (canvas_width * frames_per_unit);
+ nframes64_t frame;
+ nframes64_t one_page = (nframes64_t) rint (canvas_width * frames_per_unit);
bool was_floating;
float prefix;
- nframes_t cnt;
+ nframes64_t cnt;
if (get_prefix (prefix, was_floating)) {
- cnt = (nframes_t) floor (pages * one_page);
+ cnt = (nframes64_t) floor (pages * one_page);
} else {
if (was_floating) {
- cnt = (nframes_t) floor (prefix * session->frame_rate());
+ cnt = (nframes64_t) floor (prefix * session->frame_rate());
} else {
- cnt = (nframes_t) floor (prefix * one_page);
+ cnt = (nframes64_t) floor (prefix * one_page);
}
}
void
Editor::scroll_forward (float pages)
{
- nframes_t frame;
- nframes_t one_page = (nframes_t) rint (canvas_width * frames_per_unit);
+ nframes64_t frame;
+ nframes64_t one_page = (nframes64_t) rint (canvas_width * frames_per_unit);
bool was_floating;
float prefix;
- nframes_t cnt;
+ nframes64_t cnt;
if (get_prefix (prefix, was_floating)) {
- cnt = (nframes_t) floor (pages * one_page);
+ cnt = (nframes64_t) floor (pages * one_page);
} else {
if (was_floating) {
- cnt = (nframes_t) floor (prefix * session->frame_rate());
+ cnt = (nframes64_t) floor (prefix * session->frame_rate());
} else {
- cnt = (nframes_t) floor (prefix * one_page);
+ cnt = (nframes64_t) floor (prefix * one_page);
}
}
{
Gtk::Adjustment* adj = edit_vscrollbar.get_adjustment();
- double vert_value = adj->get_value() + 20;
+ double vert_value = adj->get_value() + 60;
if (vert_value>adj->get_upper() - canvas_height) {
vert_value = adj->get_upper() - canvas_height;
Editor::scroll_tracks_up_line ()
{
Gtk::Adjustment* adj = edit_vscrollbar.get_adjustment();
- adj->set_value (adj->get_value() - 20);
+ adj->set_value (adj->get_value() - 60);
}
/* ZOOM */
nfpu = fpu;
- new_page_size = (nframes_t) floor (canvas_width * nfpu);
+ new_page_size = (nframes64_t) floor (canvas_width * nfpu);
half_page_size = new_page_size / 2;
switch (zoom_focus) {
nframes64_t end = 0;
RegionSelection rs;
set<TimeAxisView*> tracks;
- double top_y_position = DBL_MAX;
get_regions_for_action (rs);
}
tracks.insert (&((*i)->get_time_axis_view()));
-
- if ((*i)->get_time_axis_view().y_position < top_y_position) {
- top_y_position = (*i)->get_time_axis_view().y_position;
- }
}
/* now comes an "interesting" hack ... make sure we leave a little space
gint mmwidth = gdk_screen_get_width_mm (screen);
double pix_per_mm = (double) pixwidth/ (double) mmwidth;
double one_centimeter_in_pixels = pix_per_mm * 10.0;
- nframes_t extra_samples = unit_to_frame (one_centimeter_in_pixels);
-
+
+ if ((start == 0 && end == 0) || end < start) {
+ return;
+ }
+
+ nframes64_t range = end - start;
+ double new_fpu = (double)range / (double)canvas_width;
+ nframes64_t extra_samples = (nframes64_t) floor (one_centimeter_in_pixels * new_fpu);
+
if (start > extra_samples) {
start -= extra_samples;
} else {
end = max_frames;
}
+ if (both_axes) {
+ /* save visual state with track states included, and prevent
+ set_frames_per_unit() from doing it again.
+ */
+ undo_visual_stack.push_back (current_visual_state(true));
+ no_save_visual = true;
+ }
+
temporal_zoom_by_frame (start, end, "zoom to region");
if (both_axes) {
- double per_track_height = (canvas_height - 10.0) / tracks.size();
+ uint32_t per_track_height = (uint32_t) floor ((canvas_height - canvas_timebars_vsize - 10.0) / tracks.size());
/* set visible track heights appropriately */
for (set<TimeAxisView*>::iterator t = tracks.begin(); t != tracks.end(); ++t) {
- (*t)->set_height_scaling_factor (per_track_height/(*t)->height);
+ (*t)->set_height (per_track_height);
}
/* hide irrelevant tracks */
no_route_list_redisplay = false;
redisplay_route_list ();
- vertical_adjustment.set_value (std::max (top_y_position - 5.0, 0.0));
+ vertical_adjustment.set_value (0);
+ no_save_visual = false;
}
zoomed_to_region = true;
+ redo_visual_stack.push_back (current_visual_state());
}
void
return;
}
- nframes_t start = selection->time[clicked_selection].start;
- nframes_t end = selection->time[clicked_selection].end;
+ nframes64_t start = selection->time[clicked_selection].start;
+ nframes64_t end = selection->time[clicked_selection].end;
temporal_zoom_by_frame (start, end, "zoom to selection");
}
}
void
-Editor::temporal_zoom_by_frame (nframes_t start, nframes_t end, const string & op)
+Editor::temporal_zoom_by_frame (nframes64_t start, nframes64_t end, const string & op)
{
if (!session) return;
return;
}
- nframes_t range = end - start;
+ nframes64_t range = end - start;
double new_fpu = (double)range / (double)canvas_width;
-// double p2 = 1.0;
-
-// while (p2 < new_fpu) {
-// p2 *= 2.0;
-// }
-// new_fpu = p2;
- nframes_t new_page = (nframes_t) floor (canvas_width * new_fpu);
- nframes_t middle = (nframes_t) floor( (double)start + ((double)range / 2.0f ));
- nframes_t new_leftmost = (nframes_t) floor( (double)middle - ((double)new_page/2.0f));
-
- if (new_leftmost > middle) new_leftmost = 0;
+ nframes64_t new_page = (nframes64_t) floor (canvas_width * new_fpu);
+ nframes64_t middle = (nframes64_t) floor( (double)start + ((double)range / 2.0f ));
+ nframes64_t new_leftmost = (nframes64_t) floor( (double)middle - ((double)new_page/2.0f));
-// begin_reversible_command (op);
-// session->add_undo (bind (mem_fun(*this, &Editor::reposition_and_zoom), leftmost_frame, frames_per_unit));
-// session->add_redo (bind (mem_fun(*this, &Editor::reposition_and_zoom), new_leftmost, new_fpu));
-// commit_reversible_command ();
+ if (new_leftmost > middle) {
+ new_leftmost = 0;
+ }
reposition_and_zoom (new_leftmost, new_fpu);
}
void
-Editor::temporal_zoom_to_frame (bool coarser, nframes_t frame)
+Editor::temporal_zoom_to_frame (bool coarser, nframes64_t frame)
{
- if (!session) return;
-
+ if (!session) {
+ return;
+ }
double range_before = frame - leftmost_frame;
double new_fpu;
range_before /= 1.61803399;
}
- if (new_fpu == frames_per_unit) return;
-
- nframes_t new_leftmost = frame - (nframes_t)range_before;
+ if (new_fpu == frames_per_unit) {
+ return;
+ }
- if (new_leftmost > frame) new_leftmost = 0;
+ nframes64_t new_leftmost = frame - (nframes64_t)range_before;
+ if (new_leftmost > frame) {
+ new_leftmost = 0;
+ }
// begin_reversible_command (_("zoom to frame"));
// session->add_undo (bind (mem_fun(*this, &Editor::reposition_and_zoom), leftmost_frame, frames_per_unit));
// session->add_redo (bind (mem_fun(*this, &Editor::reposition_and_zoom), new_leftmost, new_fpu));
return;
}
- nframes_t start = selection->time[clicked_selection].start;
- nframes_t end = selection->time[clicked_selection].end;
+ nframes64_t start = selection->time[clicked_selection].start;
+ nframes64_t end = selection->time[clicked_selection].end;
session->locations()->next_available_name(rangename,"selection");
Location *location = new Location (start, end, rangename, Location::IsRangeMarker);
void
Editor::set_mark ()
{
- nframes_t pos;
+ nframes64_t pos;
float prefix;
bool was_floating;
string markername;
pos = session->audible_frame ();
} else {
if (was_floating) {
- pos = (nframes_t) floor (prefix * session->frame_rate ());
+ pos = (nframes64_t) floor (prefix * session->frame_rate ());
} else {
- pos = (nframes_t) floor (prefix);
+ pos = (nframes64_t) floor (prefix);
}
}
double wx, wy;
double cx, cy;
TimeAxisView *tv;
- nframes_t where;
+ nframes64_t where;
AudioTimeAxisView *atv = 0;
boost::shared_ptr<Playlist> playlist;
track_canvas->window_to_world (x, y, wx, wy);
- wx += horizontal_adjustment.get_value();
- wy += vertical_adjustment.get_value();
+ //wx += horizontal_adjustment.get_value();
+ //wy += vertical_adjustment.get_value();
GdkEvent event;
event.type = GDK_BUTTON_RELEASE;
interthread_progress_bar.set_orientation (Gtk::PROGRESS_LEFT_TO_RIGHT);
+ interthread_progress_window->set_border_width (12);
+ interthread_progress_window->get_vbox()->set_spacing (6);
+
+ interthread_progress_label.set_alignment (0.5, 0.5);
+
interthread_progress_window->get_vbox()->pack_start (interthread_progress_label, false, false);
interthread_progress_window->get_vbox()->pack_start (interthread_progress_bar,false, false);
return;
}
- nframes_t start = selection->time[clicked_selection].start;
- nframes_t end = selection->time[clicked_selection].end;
+ nframes64_t start = selection->time[clicked_selection].start;
+ nframes64_t end = selection->time[clicked_selection].end;
- nframes_t selection_cnt = end - start + 1;
+ nframes64_t selection_cnt = end - start + 1;
for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
boost::shared_ptr<AudioRegion> current;
boost::shared_ptr<Region> current_r;
boost::shared_ptr<Playlist> pl;
- nframes_t internal_start;
+ nframes64_t internal_start;
string new_name;
if ((pl = (*i)->playlist()) == 0) {
return;
}
- nframes_t start = selection->time[clicked_selection].start;
- nframes_t end = selection->time[clicked_selection].end;
+ nframes64_t start = selection->time[clicked_selection].start;
+ nframes64_t end = selection->time[clicked_selection].end;
sort_track_selection ();
boost::shared_ptr<AudioRegion> current;
boost::shared_ptr<Region> current_r;
boost::shared_ptr<Playlist> playlist;
- nframes_t internal_start;
+ nframes64_t internal_start;
string new_name;
if ((playlist = (*i)->playlist()) == 0) {
sigc::connection c = atv->view()->RegionViewAdded.connect (mem_fun(*this, &Editor::collect_new_region_view));
latest_regionviews.clear ();
- playlist->partition ((nframes_t)((*t).start * speed), (nframes_t)((*t).end * speed), true);
+ playlist->partition ((nframes64_t)((*t).start * speed), (nframes64_t)((*t).end * speed), true);
c.disconnect ();
}
void
-Editor::crop_region_to (nframes_t start, nframes_t end)
+Editor::crop_region_to (nframes64_t start, nframes64_t end)
{
vector<boost::shared_ptr<Playlist> > playlists;
boost::shared_ptr<Playlist> playlist;
return;
}
- nframes_t the_start;
- nframes_t the_end;
- nframes_t cnt;
+ nframes64_t the_start;
+ nframes64_t the_end;
+ nframes64_t cnt;
begin_reversible_command (_("trim to selection"));
if the selection extends beyond the region
*/
- the_start = max (the_start, region->position());
+ the_start = max (the_start, (nframes64_t) region->position());
if (max_frames - the_start < region->length()) {
the_end = the_start + region->length() - 1;
} else {
void
Editor::region_fill_track ()
{
- nframes_t end;
+ nframes64_t end;
RegionSelection rs;
get_regions_for_action (rs);
TreeModel::iterator i = region_list_display.get_selection()->get_selected();
boost::shared_ptr<Region> region = (*i)[region_list_columns.region];
- nframes_t start = selection->time[clicked_selection].start;
- nframes_t end = selection->time[clicked_selection].end;
+ nframes64_t start = selection->time[clicked_selection].start;
+ nframes64_t end = selection->time[clicked_selection].end;
boost::shared_ptr<Playlist> playlist;
return;
}
- nframes_t selection_length = end - start;
+ nframes64_t selection_length = end - start;
float times = (float)selection_length / region->length();
begin_reversible_command (_("fill selection"));
void
Editor::remove_region_sync ()
{
- if (clicked_regionview) {
- boost::shared_ptr<Region> region (clicked_regionview->region());
- begin_reversible_command (_("remove sync"));
- XMLNode &before = region->playlist()->get_state();
- region->clear_sync_position ();
- XMLNode &after = region->playlist()->get_state();
- session->add_command(new MementoCommand<Playlist>(*(region->playlist()), &before, &after));
- commit_reversible_command ();
+ RegionSelection rs;
+
+ get_regions_for_action (rs);
+
+ if (rs.empty()) {
+ return;
+ }
+
+ begin_reversible_command (_("remove sync"));
+ for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
+
+ XMLNode &before = (*i)->region()->playlist()->get_state();
+ (*i)->region()->clear_sync_position ();
+ XMLNode &after = (*i)->region()->playlist()->get_state();
+ session->add_command(new MementoCommand<Playlist>(*((*i)->region()->playlist()), &before, &after));
}
+ commit_reversible_command ();
}
void
};
void
-Editor::align_selection_relative (RegionPoint point, nframes_t position, const RegionSelection& rs)
+Editor::align_selection_relative (RegionPoint point, nframes64_t position, const RegionSelection& rs)
{
if (rs.empty()) {
return;
}
- nframes_t distance;
- nframes_t pos = 0;
- int dir;
+ nframes64_t distance = 0;
+ nframes64_t pos = 0;
+ int dir = 1;
list<RegionView*> sorted;
rs.by_position (sorted);
+
boost::shared_ptr<Region> r ((*sorted.begin())->region());
switch (point) {
pos = position;
if (position > r->position()) {
distance = position - r->position();
- dir = 1;
} else {
distance = r->position() - position;
dir = -1;
if (position > r->last_frame()) {
distance = position - r->last_frame();
pos = r->position() + distance;
- dir = 1;
} else {
distance = r->last_frame() - position;
pos = r->position() - distance;
pos = r->adjust_to_sync (position);
if (pos > r->position()) {
distance = pos - r->position();
- dir = 1;
} else {
distance = r->position() - pos;
dir = -1;
}
void
-Editor::align_selection (RegionPoint point, nframes_t position, const RegionSelection& rs)
+Editor::align_selection (RegionPoint point, nframes64_t position, const RegionSelection& rs)
{
if (rs.empty()) {
return;
}
void
-Editor::align_region (boost::shared_ptr<Region> region, RegionPoint point, nframes_t position)
+Editor::align_region (boost::shared_ptr<Region> region, RegionPoint point, nframes64_t position)
{
begin_reversible_command (_("align region"));
align_region_internal (region, point, position);
}
void
-Editor::align_region_internal (boost::shared_ptr<Region> region, RegionPoint point, nframes_t position)
+Editor::align_region_internal (boost::shared_ptr<Region> region, RegionPoint point, nframes64_t position)
{
XMLNode &before = region->playlist()->get_state();
}
float speed = 1.0;
- nframes_t start;
- nframes_t end;
+ nframes64_t start;
+ nframes64_t end;
if (atav->get_diskstream() != 0) {
speed = atav->get_diskstream()->speed();
}
void
-Editor::bounce_range_selection ()
+Editor::bounce_range_selection (bool replace)
{
if (selection->time.empty()) {
return;
TrackSelection views = selection->tracks;
- nframes_t start = selection->time[clicked_selection].start;
- nframes_t end = selection->time[clicked_selection].end;
- nframes_t cnt = end - start + 1;
+ nframes64_t start = selection->time[clicked_selection].start;
+ nframes64_t end = selection->time[clicked_selection].end;
+ nframes64_t cnt = end - start + 1;
begin_reversible_command (_("bounce range"));
itt.progress = false;
XMLNode &before = playlist->get_state();
- atv->audio_track()->bounce_range (start, cnt, itt);
+ boost::shared_ptr<Region> r = atv->audio_track()->bounce_range (start, start+cnt, itt);
+
+ if (replace) {
+ list<AudioRange> ranges;
+ ranges.push_back (AudioRange (start, start+cnt, 0));
+ playlist->cut (ranges); // discard result
+ playlist->add_region (r, start);
+ }
+
XMLNode &after = playlist->get_state();
session->add_command (new MementoCommand<Playlist> (*playlist, &before, &after));
}
opname = _("clear");
break;
}
+
+ /* if we're deleting something, and the mouse is still pressed,
+ the thing we started a drag for will be gone when we release
+ the mouse button(s). avoid this. see part 2 at the end of
+ this function.
+ */
+
+ if (op == Cut || op == Clear) {
+ if (drag_info.item) {
+ drag_info.item->ungrab (0);
+ drag_info.item = 0;
+ }
+ }
cut_buffer->clear ();
Glib::signal_idle().connect (bind (mem_fun(*this, &Editor::really_remove_marker), loc));
}
+ break_drag ();
+
return;
}
default:
break;
}
+
+
+ if (op == Cut || op == Clear) {
+ break_drag ();
+ }
}
void
vector<PlaylistMapping> pmap;
- nframes_t first_position = max_frames;
+ nframes64_t first_position = max_frames;
set<PlaylistState, lt_playlist> freezelist;
pair<set<PlaylistState, lt_playlist>::iterator,bool> insert_result;
for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
- first_position = min ((*x)->region()->position(), first_position);
+ first_position = min ((nframes64_t) (*x)->region()->position(), first_position);
if (op == Cut || op == Clear) {
boost::shared_ptr<AudioPlaylist> pl = boost::dynamic_pointer_cast<AudioPlaylist>((*x)->region()->playlist());
}
void
-Editor::paste_internal (nframes_t position, float times)
+Editor::paste_internal (nframes64_t position, float times)
{
bool commit = false;
Editor::nudge_track (bool use_edit, bool forwards)
{
boost::shared_ptr<Playlist> playlist;
- nframes_t distance;
- nframes_t next_distance;
- nframes_t start;
+ nframes64_t distance;
+ nframes64_t next_distance;
+ nframes64_t start;
if (use_edit) {
start = get_preferred_edit_position();
void
Editor::external_edit_region ()
{
+ // XXX shouldn't this use get_regions_for_action(rs) too?
if (!clicked_regionview) {
return;
}
}
void
-Editor::brush (nframes_t pos)
+Editor::brush (nframes64_t pos)
{
RegionSelection sel;
RegionSelection rs;
}
}
+void
+Editor::toggle_record_enable ()
+{
+ bool new_state;
+ bool first = true;
+ for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
+ RouteTimeAxisView *rtav = dynamic_cast<RouteTimeAxisView *>(*i);
+ if (!rtav)
+ continue;
+ if (!rtav->is_track())
+ continue;
+
+ if (first) {
+ new_state = !rtav->track()->record_enabled();
+ first = false;
+ }
+
+ rtav->track()->set_record_enable(new_state, this);
+ }
+}
+
+
void
Editor::set_fade_length (bool in)
{
}
nframes64_t pos = get_preferred_edit_position();
- nframes_t len;
+ nframes64_t len;
char* cmd;
if (pos > rv->region()->last_frame() || pos < rv->region()->first_frame()) {
const char* cmd = (in ? _("toggle fade in active") : _("toggle fade out active"));
bool have_switch = false;
- bool yn;
+ bool yn = false;
begin_reversible_command (cmd);
commit_reversible_command ();
}
+void
+Editor::toggle_selected_region_fades (int dir)
+{
+ RegionSelection rs;
+ RegionSelection::iterator i;
+ boost::shared_ptr<AudioRegion> ar;
+ bool yn;
+
+ get_regions_for_action (rs);
+
+ if (rs.empty()) {
+ return;
+ }
+
+ for (i = rs.begin(); i != rs.end(); ++i) {
+ if ((ar = boost::dynamic_pointer_cast<AudioRegion>((*i)->region())) != 0) {
+ if (dir == -1) {
+ yn = ar->fade_out_active ();
+ } else {
+ yn = ar->fade_in_active ();
+ }
+ break;
+ }
+ }
+
+ if (i == rs.end()) {
+ return;
+ }
+
+ /* XXX should this undo-able? */
+
+ for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
+ if ((ar = boost::dynamic_pointer_cast<AudioRegion>((*i)->region())) == 0) {
+ continue;
+ }
+ if (dir == 1 || dir == 0) {
+ ar->set_fade_in_active (!yn);
+ }
+
+ if (dir == -1 || dir == 0) {
+ ar->set_fade_out_active (!yn);
+ }
+ }
+}
+
+
+/** Update region fade visibility after its configuration has been changed */
+void
+Editor::update_region_fade_visibility ()
+{
+ bool _fade_visibility = Config->get_show_region_fades ();
+
+ for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
+ AudioTimeAxisView* v = dynamic_cast<AudioTimeAxisView*>(*i);
+ if (v) {
+ if (_fade_visibility) {
+ v->audio_view()->show_all_fades ();
+ } else {
+ v->audio_view()->hide_all_fades ();
+ }
+ }
+ }
+}
/** Update crossfade visibility after its configuration has been changed */
void
TimeAxisView* current = selection->tracks.front();
- for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
- if (*i == current) {
- ++i;
- if (i != track_views.end()) {
- selection->set (*i);
- } else {
- selection->set (*(track_views.begin()));
+ RouteUI *rui;
+ do {
+ for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
+ if (*i == current) {
+ ++i;
+ if (i != track_views.end()) {
+ current = (*i);
+ } else {
+ current = (*(track_views.begin()));
+ //selection->set (*(track_views.begin()));
+ }
+ break;
}
- break;
}
- }
+ rui = dynamic_cast<RouteUI *>(current);
+ } while ( current->hidden() || (rui != NULL && !rui->route()->active()));
+
+ selection->set(current);
+
+ ensure_track_visible(current);
}
void
TimeAxisView* current = selection->tracks.front();
- for (TrackViewList::reverse_iterator i = track_views.rbegin(); i != track_views.rend(); ++i) {
- if (*i == current) {
- ++i;
- if (i != track_views.rend()) {
- selection->set (*i);
- } else {
- selection->set (*(track_views.rbegin()));
+ 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()) {
+ current = (*i);
+ } else {
+ current = *(track_views.rbegin());
+ }
+ break;
}
- break;
}
+ rui = dynamic_cast<RouteUI *>(current);
+ } while ( current->hidden() || (rui != NULL && !rui->route()->active()));
+
+ selection->set (current);
+
+ ensure_track_visible(current);
+}
+
+void
+Editor::ensure_track_visible(TimeAxisView *track)
+{
+ if (track->hidden())
+ return;
+
+ double current_view_min_y = vertical_adjustment.get_value();
+ double current_view_max_y = vertical_adjustment.get_value() + vertical_adjustment.get_page_size() - canvas_timebars_vsize;
+
+ double track_min_y = track->y_position;
+ double track_max_y = track->y_position + (double)track->effective_height;
+
+ if (track_min_y >= current_view_min_y &&
+ track_max_y <= current_view_max_y) {
+ return;
+ }
+
+ double new_value;
+
+ if (track_min_y < current_view_min_y) {
+ // Track is above the current view
+ new_value = track_min_y;
+ } else {
+ // Track is below the current view
+ new_value = track->y_position + (double)track->effective_height + canvas_timebars_vsize - vertical_adjustment.get_page_size();
}
+
+ vertical_adjustment.set_value(new_value);
}
void
return;
}
- nframes_t start = selection->time[clicked_selection].start;
- nframes_t end = selection->time[clicked_selection].end;
+ nframes64_t start = selection->time[clicked_selection].start;
+ nframes64_t end = selection->time[clicked_selection].end;
set_loop_range (start, end, _("set loop range from selection"));
return;
}
- nframes_t start = selection->time[clicked_selection].start;
- nframes_t end = selection->time[clicked_selection].end;
+ nframes64_t start = selection->time[clicked_selection].start;
+ nframes64_t end = selection->time[clicked_selection].end;
set_punch_range (start, end, _("set punch range from selection"));
}
{
if (!session) return;
nframes64_t pos = playhead_cursor->current_frame;
- if (pos < max_frames) {
- pos++;
+ if (pos < max_frames - 1) {
+ pos += 2;
snap_to_internal (pos, 1, false);
session->request_locate (pos);
}
{
if (!session) return;
nframes64_t pos = playhead_cursor->current_frame;
- if (pos > 1) {
- pos--;
+ if (pos > 2) {
+ pos -= 2;
snap_to_internal (pos, -1, false);
session->request_locate (pos);
}
RadioButton move_button (group, _("Move"));
RadioButton split_button (group, _("Split & Later Section Moves"));
Label intersect_option_label (_("Intersected regions should:"));
- ToggleButton glue_button (_("Move Glued Regions"));
+ CheckButton glue_button (_("Move Glued Regions"));
+ CheckButton marker_button (_("Move Markers"));
AudioClock clock ("insertTimeClock", true, X_("InsertTimeClock"), true, true, true);
HBox clock_box;
option_box.pack_start (intersect_option_label, false, false);
option_box.pack_start (button_box, false, false);
option_box.pack_start (glue_button, false, false);
+ option_box.pack_start (marker_button, false, false);
button_box.pack_start (leave_button, false, false);
button_box.pack_start (move_button, false, false);
glue_button.show ();
clock.show_all();
clock_box.show ();
+ marker_button.show ();
d.add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
d.add_button (Gtk::Stock::OK, Gtk::RESPONSE_OK);
return;
}
- nframes_t distance = clock.current_duration (pos);
+ nframes64_t distance = clock.current_duration (pos);
if (distance == 0) {
return;
opt = SplitIntersected;
}
- insert_time (pos, distance, opt, glue_button.get_active());
+ insert_time (pos, distance, opt, glue_button.get_active(), marker_button.get_active());
}
-
+
void
-Editor::insert_time (nframes64_t pos, nframes64_t frames, InsertTimeOption opt, bool ignore_music_glue)
+Editor::insert_time (nframes64_t pos, nframes64_t frames, InsertTimeOption opt,
+ bool ignore_music_glue, bool markers_too)
{
bool commit = false;
commit = true;
}
+ if (markers_too) {
+ bool moved = false;
+ XMLNode& before (session->locations()->get_state());
+ Locations::LocationList copy (session->locations()->list());
+
+ for (Locations::LocationList::iterator i = copy.begin(); i != copy.end(); ++i) {
+
+ Locations::LocationList::const_iterator tmp;
+
+ if ((*i)->start() >= pos) {
+ (*i)->set_start ((*i)->start() + frames);
+ if (!(*i)->is_mark()) {
+ (*i)->set_end ((*i)->end() + frames);
+ }
+ moved = true;
+ }
+ }
+
+ if (moved) {
+ XMLNode& after (session->locations()->get_state());
+ session->add_command (new MementoCommand<Locations>(*session->locations(), &before, &after));
+ }
+ }
+
if (commit) {
commit_reversible_command ();
}
}
+
+void
+Editor::fit_tracks ()
+{
+ if (selection->tracks.empty()) {
+ return;
+ }
+
+ uint32_t child_heights = 0;
+
+ for (TrackSelection::iterator t = selection->tracks.begin(); t != selection->tracks.end(); ++t) {
+
+ if (!(*t)->marked_for_display()) {
+ continue;
+ }
+
+ child_heights += ((*t)->effective_height - (*t)->current_height());
+ }
+
+ uint32_t h = (uint32_t) floor ((canvas_height - child_heights - canvas_timebars_vsize)/selection->tracks.size());
+ double first_y_pos = DBL_MAX;
+
+ if (h < TimeAxisView::hSmall) {
+ MessageDialog msg (*this, _("There are too many selected tracks to fit in the current window"));
+ /* too small to be displayed */
+ return;
+ }
+
+ undo_visual_stack.push_back (current_visual_state());
+
+ /* operate on all tracks, hide unselected ones that are in the middle of selected ones */
+
+ bool prev_was_selected = false;
+ bool is_selected = selection->selected (track_views.front());
+ bool next_is_selected;
+
+ for (TrackViewList::iterator t = track_views.begin(); t != track_views.end(); ++t) {
+
+ TrackViewList::iterator next;
+
+ next = t;
+ ++next;
+
+ if (next != track_views.end()) {
+ next_is_selected = selection->selected (*next);
+ } else {
+ next_is_selected = false;
+ }
+
+ if (is_selected) {
+ (*t)->set_height (h);
+ first_y_pos = std::min ((*t)->y_position, first_y_pos);
+ } else {
+ if (prev_was_selected && next_is_selected) {
+ hide_track_in_display (**t);
+ }
+ }
+
+ prev_was_selected = is_selected;
+ is_selected = next_is_selected;
+ }
+
+ /*
+ set the controls_layout height now, because waiting for its size
+ request signal handler will cause the vertical adjustment setting to fail
+ */
+
+ controls_layout.property_height () = full_canvas_height - canvas_timebars_vsize;
+ vertical_adjustment.set_value (first_y_pos);
+
+ redo_visual_stack.push_back (current_visual_state());
+}
+
+void
+Editor::save_visual_state (uint32_t n)
+{
+ while (visual_states.size() <= n) {
+ visual_states.push_back (0);
+ }
+
+ if (visual_states[n] != 0) {
+ delete visual_states[n];
+ }
+
+ visual_states[n] = current_visual_state (true);
+ gdk_beep ();
+}
+
+void
+Editor::goto_visual_state (uint32_t n)
+{
+ if (visual_states.size() <= n) {
+ return;
+ }
+
+ if (visual_states[n] == 0) {
+ return;
+ }
+
+ use_visual_state (*visual_states[n]);
+}
+
+void
+Editor::start_visual_state_op (uint32_t n)
+{
+ cerr << "Start\n";
+ if (visual_state_op_connection.empty()) {
+ cerr << "\tqueue\n";
+ visual_state_op_connection = Glib::signal_timeout().connect (bind (mem_fun (*this, &Editor::end_visual_state_op), n), 1000);
+ }
+}
+
+void
+Editor::cancel_visual_state_op (uint32_t n)
+{
+ cerr << "Cancel\n";
+ if (!visual_state_op_connection.empty()) {
+ cerr << "\tgoto\n";
+ visual_state_op_connection.disconnect();
+ goto_visual_state (n);
+ }
+}
+
+bool
+Editor::end_visual_state_op (uint32_t n)
+{
+ visual_state_op_connection.disconnect();
+ save_visual_state (n);
+
+ PopUp* pup = new PopUp (WIN_POS_MOUSE, 1000, true);
+ char buf[32];
+ snprintf (buf, sizeof (buf), _("Saved view %u"), n+1);
+ pup->set_text (buf);
+ pup->touch();
+
+ return false; // do not call again
+}
+
projects / ardour.git / blobdiff