#include <pbd/convert.h>
#include <pbd/error.h>
+#include <pbd/memento_command.h>
#include <gtkmm/image.h>
#include <gdkmm/color.h>
#include "editor_xpms"
-static const int32_t slide_index = 0;
-static const int32_t splice_index = 1;
-
-static const gchar *edit_mode_strings[] = {
- N_("Slide Edit"),
- N_("Splice Edit"),
- 0
-};
-
static const gchar *snap_type_strings[] = {
N_("None"),
N_("CD Frames"),
N_("Focus Left"),
N_("Focus Right"),
N_("Focus Center"),
- N_("Focus Play"),
- N_("Focus Edit"),
+ N_("Focus Playhead"),
+ N_("Focus Edit Cursor"),
0
};
latest_regionview = 0;
last_update_frame = 0;
drag_info.item = 0;
- last_audition_region = 0;
current_mixer_strip = 0;
current_bbt_points = 0;
bbt_beat_subdivision = 4;
canvas_width = 0;
canvas_height = 0;
+ autoscroll_active = false;
autoscroll_timeout_tag = -1;
interthread_progress_window = 0;
first_action_message = 0;
export_dialog = 0;
show_gain_after_trim = false;
- no_zoom_repos_update = false;
ignore_route_list_reorder = false;
no_route_list_redisplay = false;
verbose_cursor_on = true;
_xfade_visibility = true;
editor_ruler_menu = 0;
no_ruler_shown_update = false;
- edit_hscroll_dragging = false;
edit_group_list_menu = 0;
route_list_menu = 0;
region_list_menu = 0;
edit_pane.pack1 (edit_packer, true, true);
edit_pane.pack2 (the_notebook, false, true);
- edit_pane.signal_size_allocate().connect
_notify (bind (mem_fun(*this, &Editor::pane_allocation_handler), static_cast<Paned*> (&edit_pane)));
+ edit_pane.signal_size_allocate().connect (bind (mem_fun(*this, &Editor::pane_allocation_handler), static_cast<Paned*> (&edit_pane)));
top_hbox.pack_start (toolbar_frame, true, true);
ControlProtocol::ZoomIn.connect (bind (mem_fun (*this, &Editor::temporal_zoom_step), false));
ControlProtocol::ZoomOut.connect (bind (mem_fun (*this, &Editor::temporal_zoom_step), true));
ControlProtocol::ScrollTimeline.connect (mem_fun (*this, &Editor::control_scroll));
+
+ Config->ParameterChanged.connect (mem_fun (*this, &Editor::parameter_changed));
+
constructed = true;
instant_save ();
}
void
Editor::set_frames_per_unit (double fpu)
{
- jack_nframes_t frames;
+ nframes_t frames;
if (fpu == frames_per_unit) {
return;
}
- if (fpu < 1.0) {
- fpu = 1.0;
+ if (fpu < 2.0) {
+ fpu = 2.0;
}
// convert fpu to frame count
- frames = (jack_nframes_t) floor (fpu * canvas_width);
+ frames = (nframes_t) floor (fpu * canvas_width);
/* don't allow zooms that fit more than the maximum number
of frames into an 800 pixel wide space.
return;
}
+ if (fpu == frames_per_unit) {
+ return;
+ }
+
frames_per_unit = fpu;
if (frames != zoom_range_clock.current_duration()) {
zoom_range_clock.set (frames);
}
- /* only update these if we not about to call reposition_x_origin,
- which will do the same updates.
- */
-
- if (!no_zoom_repos_update) {
- horizontal_adjustment.set_value (leftmost_frame/frames_per_unit);
- update_fixed_rulers ();
- tempo_map_changed (Change (0));
- }
-
if (mouse_mode == MouseRange && selection->time.start () != selection->time.end_frame ()) {
if (!selection->tracks.empty()) {
for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
}
void
-Editor::reposition_x_origin (jack_nframes_t frame)
+Editor::reposition_x_origin (nframes_t frame)
{
if (frame != leftmost_frame) {
leftmost_frame = frame;
- jack_nframes_t rightmost_frame = leftmost_frame + current_page_frames ();
+ nframes_t rightmost_frame = leftmost_frame + current_page_frames ();
if (rightmost_frame > last_canvas_frame) {
last_canvas_frame = rightmost_frame;
}
horizontal_adjustment.set_value (frame/frames_per_unit);
+ } else {
+ update_fixed_rulers();
+ tempo_map_changed (Change (0));
}
}
void
Editor::zoom_adjustment_changed ()
{
- if (session == 0 || no_zoom_repos_update) {
+ if (session == 0) {
return;
}
if (fpu < 1.0) {
fpu = 1.0;
- zoom_range_clock.set ((jack_nframes_t) floor (fpu * canvas_width));
+ zoom_range_clock.set ((nframes_t) floor (fpu * canvas_width));
} else if (fpu > session->current_end_frame() / canvas_width) {
fpu = session->current_end_frame() / canvas_width;
- zoom_range_clock.set ((jack_nframes_t) floor (fpu * canvas_width));
+ zoom_range_clock.set ((nframes_t) floor (fpu * canvas_width));
}
temporal_zoom (fpu);
}
double step = fraction * current_page_frames();
- jack_nframes_t target;
+ nframes_t target;
- if ((fraction < 0.0f) && (session->transport_frame() < (jack_nframes_t) fabs(step))) {
+ if ((fraction < 0.0f) && (session->transport_frame() < (nframes_t) fabs(step))) {
target = 0;
} else if ((fraction > 0.0f) && (max_frames - session->transport_frame() < step)) {
target = (max_frames - (current_page_frames()*2)); // allow room for slop in where the PH is on the screen
} else {
- target = (session->transport_frame() + (jack_nframes_t) floor ((fraction * current_page_frames())));
+ target = (session->transport_frame() + (nframes_t) floor ((fraction * current_page_frames())));
}
/* move visuals, we'll catch up with it later */
}
bool
-Editor::deferred_control_scroll (jack_nframes_t target)
+Editor::deferred_control_scroll (nframes_t target)
{
session->request_locate (target);
return false;
void
Editor::canvas_horizontally_scrolled ()
{
- leftmost_frame = (jack_nframes_t) floor (horizontal_adjustment.get_value() * frames_per_unit);
+ leftmost_frame = (nframes_t) floor (horizontal_adjustment.get_value() * frames_per_unit);
update_fixed_rulers ();
-
- if (!edit_hscroll_dragging) {
- tempo_map_changed (Change (0));
- } else {
- update_tempo_based_rulers();
- }
+ tempo_map_changed (Change (0));
+
}
void
-Editor::reposition_and_zoom (jack_nframes_t frame, double nfpu)
+Editor::reposition_and_zoom (nframes_t frame, double nfpu)
{
if (!repos_zoom_queued) {
- Glib::signal_idle().connect (bind (mem_fun(*this, &Editor::deferred_reposition_and_zoom), frame, nfpu));
repos_zoom_queued = true;
+ Glib::signal_idle().connect (bind (mem_fun(*this, &Editor::deferred_reposition_and_zoom), frame, nfpu));
}
}
gint
-Editor::deferred_reposition_and_zoom (jack_nframes_t frame, double nfpu)
+Editor::deferred_reposition_and_zoom (nframes_t frame, double nfpu)
{
- /* if we need to force an update to the hscroller stuff,
- don't set no_zoom_repos_update.
- */
- no_zoom_repos_update = (frame != leftmost_frame);
-
set_frames_per_unit (nfpu);
- if (no_zoom_repos_update) {
- reposition_x_origin (frame);
- }
- no_zoom_repos_update = false;
+ reposition_x_origin (frame);
repos_zoom_queued = false;
return FALSE;
Realized ();
}
-void
-Editor::queue_session_control_changed (Session::ControlType t)
-{
- Gtkmm2ext::UI::instance()->call_slot (bind (mem_fun(*this, &Editor::session_control_changed), t));
-}
-
-void
-Editor::session_control_changed (Session::ControlType t)
-{
- // right now we're only tracking some state here
-
- switch (t) {
- case Session::AutoLoop:
- update_loop_range_view (true);
- break;
- case Session::PunchIn:
- case Session::PunchOut:
- update_punch_range_view (true);
- break;
-
- case Session::LayeringModel:
- update_layering_model ();
- break;
-
- default:
- break;
- }
-}
-
void
Editor::start_scrolling ()
{
Editor::stop_scrolling ()
{
scroll_connection.disconnect ();
- slower_update_connection.disconnect ();
}
void
-Editor::map_position_change (jack_nframes_t frame)
+Editor::map_position_change (nframes_t frame)
{
ENSURE_GUI_THREAD (bind (mem_fun(*this, &Editor::map_position_change), frame));
}
void
-Editor::center_screen (jack_nframes_t frame)
+Editor::center_screen (nframes_t frame)
{
double page = canvas_width * frames_per_unit;
}
void
-Editor::center_screen_internal (jack_nframes_t frame, float page)
+Editor::center_screen_internal (nframes_t frame, float page)
{
page /= 2;
if (frame > page) {
- frame -= (jack_nframes_t) page;
+ frame -= (nframes_t) page;
} else {
frame = 0;
}
{
ENSURE_GUI_THREAD (mem_fun (*this, &Editor::handle_new_duration));
- jack_nframes_t new_end = session->get_maximum_extent() + (jack_nframes_t) floorf (current_page_frames() * 0.10f);
+ nframes_t new_end = session->get_maximum_extent() + (nframes_t) floorf (current_page_frames() * 0.10f);
if (new_end > last_canvas_frame) {
last_canvas_frame = new_end;
update_title ();
- session->going_away.connect (mem_fun(*this, &Editor::session_going_away));
+ session->GoingAway.connect (mem_fun(*this, &Editor::session_going_away));
/* These signals can all be emitted by a non-GUI thread. Therefore the
handlers for them must not attempt to directly interact with the GUI,
session_connections.push_back (session->RegionHiddenChange.connect (mem_fun(*this, &Editor::region_hidden)));
session_connections.push_back (session->SMPTEOffsetChanged.connect (mem_fun(*this, &Editor::update_just_smpte)));
- session_connections.push_back (session->SMPTETypeChanged.connect (mem_fun(*this, &Editor::update_just_smpte)));
session_connections.push_back (session->tempo_map().StateChanged.connect (mem_fun(*this, &Editor::tempo_map_changed)));
analysis_window->set_session (session);
#endif
- switch (session->get_edit_mode()) {
- case Splice:
- edit_mode_selector.set_active_text (edit_mode_strings[splice_index]);
- break;
-
- case Slide:
- edit_mode_selector.set_active_text (edit_mode_strings[slide_index]);
- break;
- }
-
Location* loc = session->locations()->auto_loop_location();
if (loc == 0) {
loc = new Location (0, session->current_end_frame(), _("Loop"),(Location::Flags) (Location::IsAutoLoop | Location::IsHidden));
loc->set_name (_("Punch"));
}
- update_loop_range_view (true);
- update_punch_range_view (true);
+ Config->map_parameters (mem_fun (*this, &Editor::parameter_changed));
- session->ControlChanged.connect (mem_fun(*this, &Editor::queue_session_control_changed));
session->StateSaved.connect (mem_fun(*this, &Editor::session_state_saved));
refresh_location_display ();
session->locations()->StateChanged.connect (mem_fun(*this, &Editor::refresh_location_display_s));
session->locations()->end_location()->changed.connect (mem_fun(*this, &Editor::end_location_changed));
- bool yn;
- RefPtr<Action> act;
-
- act = ActionManager::get_action (X_("Editor"), X_("toggle-xfades-active"));
- if (act) {
- RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
- /* do it twice to force the change */
- yn = session->get_crossfades_active();
- tact->set_active (!yn);
- tact->set_active (yn);
- }
-
- act = ActionManager::get_action (X_("Editor"), X_("toggle-auto-xfades"));
- if (act) {
- RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
- /* do it twice to force the change */
- yn = Config->get_auto_xfade ();
- tact->set_active (!yn);
- tact->set_active (yn);
- }
-
- /* xfade visibility state set from editor::set_state() */
-
- update_crossfade_model ();
- update_layering_model ();
-
handle_new_duration ();
redisplay_regions ();
horizontal_adjustment.set_value (0);
restore_ruler_visibility ();
- tempo_map_changed (Change (0));
+ //tempo_map_changed (Change (0));
+ session->tempo_map().apply_with_metrics (*this, &Editor::draw_metric_marks);
edit_cursor->set_position (0);
playhead_cursor->set_position (0);
no_route_list_redisplay = false;
redisplay_route_list ();
}
+
+ /* register for undo history */
+
+ session->register_with_memento_command_factory(_id, this);
}
void
}
MenuList& items (fade_context_menu.items());
+ AudioRegion& ar (*arv->audio_region().get()); // FIXME
items.clear ();
switch (item_type) {
case FadeInItem:
case FadeInHandleItem:
- if (arv->audio_region().fade_in_active()) {
+ if (arv->audio_region()->fade_in_active()) {
items.push_back (MenuElem (_("Deactivate"), bind (mem_fun (*arv, &AudioRegionView::set_fade_in_active), false)));
} else {
items.push_back (MenuElem (_("Activate"), bind (mem_fun (*arv, &AudioRegionView::set_fade_in_active), true)));
items.push_back (SeparatorElem());
- items.push_back (MenuElem (_("Linear"), bind (mem_fun (arv->audio_region(), &AudioRegion::set_fade_in_shape), AudioRegion::Linear)));
- items.push_back (MenuElem (_("Slowest"), bind (mem_fun (arv->audio_region(), &AudioRegion::set_fade_in_shape), AudioRegion::LogB)));
- items.push_back (MenuElem (_("Slow"), bind (mem_fun (arv->audio_region(), &AudioRegion::set_fade_in_shape), AudioRegion::Fast)));
- items.push_back (MenuElem (_("Fast"), bind (mem_fun (arv->audio_region(), &AudioRegion::set_fade_in_shape), AudioRegion::LogA)));
- items.push_back (MenuElem (_("Fastest"), bind (mem_fun (arv->audio_region(), &AudioRegion::set_fade_in_shape), AudioRegion::Slow)));
+ items.push_back (MenuElem (_("Linear"), bind (mem_fun (ar, &AudioRegion::set_fade_in_shape), AudioRegion::Linear)));
+ items.push_back (MenuElem (_("Slowest"), bind (mem_fun (ar, &AudioRegion::set_fade_in_shape), AudioRegion::LogB)));
+ items.push_back (MenuElem (_("Slow"), bind (mem_fun (ar, &AudioRegion::set_fade_in_shape), AudioRegion::Fast)));
+ items.push_back (MenuElem (_("Fast"), bind (mem_fun (ar, &AudioRegion::set_fade_in_shape), AudioRegion::LogA)));
+ items.push_back (MenuElem (_("Fastest"), bind (mem_fun (ar, &AudioRegion::set_fade_in_shape), AudioRegion::Slow)));
break;
case FadeOutItem:
case FadeOutHandleItem:
- if (arv->audio_region().fade_out_active()) {
+ if (arv->audio_region()->fade_out_active()) {
items.push_back (MenuElem (_("Deactivate"), bind (mem_fun (*arv, &AudioRegionView::set_fade_out_active), false)));
} else {
items.push_back (MenuElem (_("Activate"), bind (mem_fun (*arv, &AudioRegionView::set_fade_out_active), true)));
items.push_back (SeparatorElem());
- items.push_back (MenuElem (_("Linear"), bind (mem_fun (arv->audio_region(), &AudioRegion::set_fade_out_shape), AudioRegion::Linear)));
- items.push_back (MenuElem (_("Slowest"), bind (mem_fun (arv->audio_region(), &AudioRegion::set_fade_out_shape), AudioRegion::Fast)));
- items.push_back (MenuElem (_("Slow"), bind (mem_fun (arv->audio_region(), &AudioRegion::set_fade_out_shape), AudioRegion::LogB)));
- items.push_back (MenuElem (_("Fast"), bind (mem_fun (arv->audio_region(), &AudioRegion::set_fade_out_shape), AudioRegion::LogA)));
- items.push_back (MenuElem (_("Fastest"), bind (mem_fun (arv->audio_region(), &AudioRegion::set_fade_out_shape), AudioRegion::Slow)));
+ items.push_back (MenuElem (_("Linear"), bind (mem_fun (ar, &AudioRegion::set_fade_out_shape), AudioRegion::Linear)));
+ items.push_back (MenuElem (_("Slowest"), bind (mem_fun (ar, &AudioRegion::set_fade_out_shape), AudioRegion::Fast)));
+ items.push_back (MenuElem (_("Slow"), bind (mem_fun (ar, &AudioRegion::set_fade_out_shape), AudioRegion::LogB)));
+ items.push_back (MenuElem (_("Fast"), bind (mem_fun (ar, &AudioRegion::set_fade_out_shape), AudioRegion::LogA)));
+ items.push_back (MenuElem (_("Fastest"), bind (mem_fun (ar, &AudioRegion::set_fade_out_shape), AudioRegion::Slow)));
break;
default:
}
void
-Editor::popup_track_context_menu (int button, int32_t time, ItemType item_type, bool with_selection, jack_nframes_t frame)
+Editor::popup_track_context_menu (int button, int32_t time, ItemType item_type, bool with_selection, nframes_t frame)
{
using namespace Menu_Helpers;
- Menu* (Editor::*build_menu_function)(jack_nframes_t);
+ Menu* (Editor::*build_menu_function)(nframes_t);
Menu *menu;
switch (item_type) {
case RegionViewNameHighlight:
if (!with_selection) {
if (region_edit_menu_split_item) {
- if (clicked_regionview && clicked_regionview->region().covers (edit_cursor->current_frame)) {
+ if (clicked_regionview && clicked_regionview->region()->covers (edit_cursor->current_frame)) {
ActionManager::set_sensitive (ActionManager::edit_cursor_in_region_sensitive_actions, true);
} else {
ActionManager::set_sensitive (ActionManager::edit_cursor_in_region_sensitive_actions, false);
}
Menu*
-Editor::build_track_context_menu (jack_nframes_t ignored)
+Editor::build_track_context_menu (nframes_t ignored)
{
using namespace Menu_Helpers;
}
Menu*
-Editor::build_track_bus_context_menu (jack_nframes_t ignored)
+Editor::build_track_bus_context_menu (nframes_t ignored)
{
using namespace Menu_Helpers;
}
Menu*
-Editor::build_track_region_context_menu (jack_nframes_t frame)
+Editor::build_track_region_context_menu (nframes_t frame)
{
using namespace Menu_Helpers;
MenuList& edit_items = track_region_context_menu.items();
AudioTimeAxisView* atv = dynamic_cast<AudioTimeAxisView*> (clicked_trackview);
if (atv) {
- Diskstream* ds;
+ boost::shared_ptr<Diskstream> ds;
Playlist* pl;
if ((ds = atv->get_diskstream()) && ((pl = ds->playlist()))) {
- Playlist::RegionList* regions = pl->regions_at ((jack_nframes_t) floor ( (double)frame * ds->speed()));
+ Playlist::RegionList* regions = pl->regions_at ((nframes_t) floor ( (double)frame * ds->speed()));
for (Playlist::RegionList::iterator i = regions->begin(); i != regions->end(); ++i) {
add_region_context_items (atv->audio_view(), (*i), edit_items);
}
}
Menu*
-Editor::build_track_crossfade_context_menu (jack_nframes_t frame)
+Editor::build_track_crossfade_context_menu (nframes_t frame)
{
using namespace Menu_Helpers;
MenuList& edit_items = track_crossfade_context_menu.items();
AudioTimeAxisView* atv = dynamic_cast<AudioTimeAxisView*> (clicked_trackview);
if (atv) {
- Diskstream* ds;
+ boost::shared_ptr<Diskstream> ds;
Playlist* pl;
AudioPlaylist* apl;
Menu*
-Editor::build_track_selection_context_menu (jack_nframes_t ignored)
+Editor::build_track_selection_context_menu (nframes_t ignored)
{
using namespace Menu_Helpers;
MenuList& edit_items = track_selection_context_menu.items();
}
if (many) {
- str = xfade->out().name();
+ str = xfade->out()->name();
str += "->";
- str += xfade->in().name();
+ str += xfade->in()->name();
} else {
str = _("Crossfade");
}
}
void
-Editor::add_region_context_items (AudioStreamView* sv, Region* region, Menu_Helpers::MenuList& edit_items)
+Editor::add_region_context_items (AudioStreamView* sv, boost::shared_ptr<Region> region, Menu_Helpers::MenuList& edit_items)
{
using namespace Menu_Helpers;
Menu *region_menu = manage (new Menu);
MenuList& items = region_menu->items();
region_menu->set_name ("ArdourContextMenu");
- AudioRegion* ar = 0;
+ boost::shared_ptr<AudioRegion> ar;
if (region) {
- ar = dynamic_cast<AudioRegion*> (region);
+ ar = boost::dynamic_pointer_cast<AudioRegion> (region);
}
/* when this particular menu pops up, make the relevant region
int x, y, xoff, yoff;
Gdk::Geometry g;
+ if ((prop = node.property ("id")) != 0) {
+ _id = prop->value ();
+ }
if ((geometry = find_named_node (node, "geometry")) == 0) {
}
}
+
return 0;
}
XMLNode* node = new XMLNode ("Editor");
char buf[32];
+ _id.print (buf, sizeof (buf));
+ node->add_property ("id", buf);
+
if (is_realized()) {
Glib::RefPtr<Gdk::Window> win = get_window();
win->get_size(width, height);
XMLNode* geometry = new XMLNode ("geometry");
- char buf[32];
+
snprintf(buf, sizeof(buf), "%d", width);
geometry->add_property("x_size", string(buf));
snprintf(buf, sizeof(buf), "%d", height);
}
void
-Editor::snap_to (jack_nframes_t& start, int32_t direction, bool for_mark)
+Editor::snap_to (nframes_t& start, int32_t direction, bool for_mark)
{
Location* before = 0;
Location* after = 0;
return;
}
- const jack_nframes_t one_second = session->frame_rate();
- const jack_nframes_t one_minute = session->frame_rate() * 60;
+ const nframes_t one_second = session->frame_rate();
+ const nframes_t one_minute = session->frame_rate() * 60;
- jack_nframes_t presnap = start;
+ nframes_t presnap = start;
switch (snap_type) {
case SnapToFrame:
case SnapToCDFrame:
if (direction) {
- start = (jack_nframes_t) ceil ((double) start / (one_second / 75)) * (one_second / 75);
+ start = (nframes_t) ceil ((double) start / (one_second / 75)) * (one_second / 75);
} else {
- start = (jack_nframes_t) floor ((double) start / (one_second / 75)) * (one_second / 75);
+ start = (nframes_t) floor ((double) start / (one_second / 75)) * (one_second / 75);
}
break;
case SnapToSMPTEFrame:
if (direction) {
- start = (jack_nframes_t) (ceil ((double) start / session->frames_per_smpte_frame()) * session->frames_per_smpte_frame());
+ start = (nframes_t) (ceil ((double) start / session->frames_per_smpte_frame()) * session->frames_per_smpte_frame());
} else {
- start = (jack_nframes_t) (floor ((double) start / session->frames_per_smpte_frame()) * session->frames_per_smpte_frame());
+ start = (nframes_t) (floor ((double) start / session->frames_per_smpte_frame()) * session->frames_per_smpte_frame());
}
break;
start -= session->smpte_offset ();
}
if (direction > 0) {
- start = (jack_nframes_t) ceil ((double) start / one_second) * one_second;
+ start = (nframes_t) ceil ((double) start / one_second) * one_second;
} else {
- start = (jack_nframes_t) floor ((double) start / one_second) * one_second;
+ start = (nframes_t) floor ((double) start / one_second) * one_second;
}
if (session->smpte_offset_negative())
start -= session->smpte_offset ();
}
if (direction) {
- start = (jack_nframes_t) ceil ((double) start / one_minute) * one_minute;
+ start = (nframes_t) ceil ((double) start / one_minute) * one_minute;
} else {
- start = (jack_nframes_t) floor ((double) start / one_minute) * one_minute;
+ start = (nframes_t) floor ((double) start / one_minute) * one_minute;
}
if (session->smpte_offset_negative())
{
case SnapToSeconds:
if (direction) {
- start = (jack_nframes_t) ceil ((double) start / one_second) * one_second;
+ start = (nframes_t) ceil ((double) start / one_second) * one_second;
} else {
- start = (jack_nframes_t) floor ((double) start / one_second) * one_second;
+ start = (nframes_t) floor ((double) start / one_second) * one_second;
}
break;
case SnapToMinutes:
if (direction) {
- start = (jack_nframes_t) ceil ((double) start / one_minute) * one_minute;
+ start = (nframes_t) ceil ((double) start / one_minute) * one_minute;
} else {
- start = (jack_nframes_t) floor ((double) start / one_minute) * one_minute;
+ start = (nframes_t) floor ((double) start / one_minute) * one_minute;
}
break;
case SnapToRegionSync:
case SnapToRegionBoundary:
if (!region_boundary_cache.empty()) {
- vector<jack_nframes_t>::iterator i;
+ vector<nframes_t>::iterator i;
if (direction > 0) {
i = std::upper_bound (region_boundary_cache.begin(), region_boundary_cache.end(), start);
mouse_mode_button_box.pack_start(mouse_audition_button, true, true);
mouse_mode_button_box.set_homogeneous(true);
+ vector<string> edit_mode_strings;
+ edit_mode_strings.push_back (edit_mode_to_string (Splice));
+ edit_mode_strings.push_back (edit_mode_to_string (Slide));
+
edit_mode_selector.set_name ("EditModeSelector");
- Gtkmm2ext::set_size_request_to_display_given_text (edit_mode_selector, "Splice Edit", 2+FUDGE, 10);
- set_popdown_strings (edit_mode_selector, internationalize (edit_mode_strings));
+ Gtkmm2ext::set_size_request_to_display_given_text (edit_mode_selector, longest (edit_mode_strings).c_str(), 2+FUDGE, 10);
+ set_popdown_strings (edit_mode_selector, edit_mode_strings);
edit_mode_selector.signal_changed().connect (mem_fun(*this, &Editor::edit_mode_selection_done));
mode_box->pack_start(edit_mode_selector);
Editor::begin_reversible_command (string name)
{
if (session) {
- UndoAction ua = get_memento();
- session->begin_reversible_command (name, &ua);
+ before = &get_state();
+ session->begin_reversible_command (name);
}
}
Editor::commit_reversible_command ()
{
if (session) {
- UndoAction ua = get_memento();
- session->commit_reversible_command (&ua);
+ session->commit_reversible_command (new MementoCommand<Editor>(*this, before, &get_state()));
}
}
/* select this point and any others that it represents */
double y1, y2;
- jack_nframes_t x1, x2;
+ nframes_t x1, x2;
x1 = pixel_to_frame (clicked_control_point->get_x() - 10);
x2 = pixel_to_frame (clicked_control_point->get_x() + 10);
void
Editor::mapped_set_selected_regionview_from_click (RouteTimeAxisView& tv, uint32_t ignored,
- RegionView* basis, vector<RegionView*>* all_equivs)
+ RegionView* basis, vector<RegionView*>* all_equivs)
{
Playlist* pl;
- vector<Region*> results;
+ vector<boost::shared_ptr<Region> > results;
RegionView* marv;
- Diskstream* ds;
+ boost::shared_ptr<Diskstream> ds;
if ((ds = tv.get_diskstream()) == 0) {
/* bus */
pl->get_equivalent_regions (basis->region(), results);
}
- for (vector<Region*>::iterator ir = results.begin(); ir != results.end(); ++ir) {
- if ((marv = tv.view()->find_view (**ir)) != 0) {
+ for (vector<boost::shared_ptr<Region> >::iterator ir = results.begin(); ir != results.end(); ++ir) {
+ if ((marv = tv.view()->find_view (*ir)) != 0) {
all_equivs->push_back (marv);
}
}
} else if (op == Selection::Extend) {
list<Selectable*> results;
- jack_nframes_t last_frame;
- jack_nframes_t first_frame;
+ nframes_t last_frame;
+ nframes_t first_frame;
/* 1. find the last selected regionview in the track that was clicked in */
for (RegionSelection::iterator x = selection->regions.begin(); x != selection->regions.end(); ++x) {
if (&(*x)->get_time_axis_view() == &clicked_regionview->get_time_axis_view()) {
- if ((*x)->region().last_frame() > last_frame) {
- last_frame = (*x)->region().last_frame();
+ if ((*x)->region()->last_frame() > last_frame) {
+ last_frame = (*x)->region()->last_frame();
}
- if ((*x)->region().first_frame() < first_frame) {
- first_frame = (*x)->region().first_frame();
+ if ((*x)->region()->first_frame() < first_frame) {
+ first_frame = (*x)->region()->first_frame();
}
}
}
/* 2. figure out the boundaries for our search for new objects */
- switch (clicked_regionview->region().coverage (first_frame, last_frame)) {
+ switch (clicked_regionview->region()->coverage (first_frame, last_frame)) {
case OverlapNone:
cerr << "no overlap, first = " << first_frame << " last = " << last_frame << " region = "
- << clicked_regionview->region().first_frame() << " .. " << clicked_regionview->region().last_frame() << endl;
+ << clicked_regionview->region()->first_frame() << " .. " << clicked_regionview->region()->last_frame() << endl;
- if (last_frame < clicked_regionview->region().first_frame()) {
+ if (last_frame < clicked_regionview->region()->first_frame()) {
first_frame = last_frame;
- last_frame = clicked_regionview->region().last_frame();
+ last_frame = clicked_regionview->region()->last_frame();
} else {
last_frame = first_frame;
- first_frame = clicked_regionview->region().first_frame();
+ first_frame = clicked_regionview->region()->first_frame();
}
break;
case OverlapExternal:
cerr << "external overlap, first = " << first_frame << " last = " << last_frame << " region = "
- << clicked_regionview->region().first_frame() << " .. " << clicked_regionview->region().last_frame() << endl;
+ << clicked_regionview->region()->first_frame() << " .. " << clicked_regionview->region()->last_frame() << endl;
- if (last_frame < clicked_regionview->region().first_frame()) {
+ if (last_frame < clicked_regionview->region()->first_frame()) {
first_frame = last_frame;
- last_frame = clicked_regionview->region().last_frame();
+ last_frame = clicked_regionview->region()->last_frame();
} else {
last_frame = first_frame;
- first_frame = clicked_regionview->region().first_frame();
+ first_frame = clicked_regionview->region()->first_frame();
}
break;
case OverlapInternal:
cerr << "internal overlap, first = " << first_frame << " last = " << last_frame << " region = "
- << clicked_regionview->region().first_frame() << " .. " << clicked_regionview->region().last_frame() << endl;
+ << clicked_regionview->region()->first_frame() << " .. " << clicked_regionview->region()->last_frame() << endl;
- if (last_frame < clicked_regionview->region().first_frame()) {
+ if (last_frame < clicked_regionview->region()->first_frame()) {
first_frame = last_frame;
- last_frame = clicked_regionview->region().last_frame();
+ last_frame = clicked_regionview->region()->last_frame();
} else {
last_frame = first_frame;
- first_frame = clicked_regionview->region().first_frame();
+ first_frame = clicked_regionview->region()->first_frame();
}
break;
}
void
-Editor::set_selected_regionview_from_region_list (Region& region, Selection::Operation op)
+Editor::set_selected_regionview_from_region_list (boost::shared_ptr<Region> region, Selection::Operation op)
{
vector<RegionView*> all_equivalent_regions;
if ((tatv = dynamic_cast<RouteTimeAxisView*> (*i)) != 0) {
Playlist* pl;
- vector<Region*> results;
+ vector<boost::shared_ptr<Region> > results;
RegionView* marv;
- Diskstream* ds;
+ boost::shared_ptr<Diskstream> ds;
if ((ds = tatv->get_diskstream()) == 0) {
/* bus */
pl->get_region_list_equivalent_regions (region, results);
}
- for (vector<Region*>::iterator ir = results.begin(); ir != results.end(); ++ir) {
- if ((marv = tatv->view()->find_view (**ir)) != 0) {
+ for (vector<boost::shared_ptr<Region> >::iterator ir = results.begin(); ir != results.end(); ++ir) {
+ if ((marv = tatv->view()->find_view (*ir)) != 0) {
all_equivalent_regions.push_back (marv);
}
}
}
bool
-Editor::set_selected_regionview_from_map_event (GdkEventAny* ev, StreamView* sv, Region* r)
+Editor::set_selected_regionview_from_map_event (GdkEventAny* ev, StreamView* sv, boost::shared_ptr<Region> r)
{
RegionView* rv;
- Region* ar;
+ boost::shared_ptr<AudioRegion> ar;
- if ((ar = dynamic_cast<Region*> (r)) == 0) {
- return TRUE;
+ if ((ar = boost::dynamic_pointer_cast<AudioRegion> (r)) == 0) {
+ return true;
}
- if ((rv = sv->find_view (*ar)) == 0) {
- return TRUE;
+ if ((rv = sv->find_view (ar)) == 0) {
+ return true;
}
/* don't reset the selection if its something other than
*/
if (selection->regions.size() > 1) {
- return TRUE;
+ return true;
}
begin_reversible_command (_("set selected regions"));
commit_reversible_command () ;
- return TRUE;
+ return true;
}
void
mode = Slide;
}
- session->set_edit_mode (mode);
+ Config->set_edit_mode (mode);
}
void
void
Editor::set_zoom_focus (ZoomFocus f)
{
+ vector<string> txt = internationalize (zoom_focus_strings);
+ zoom_focus_selector.set_active_text (txt[(int)f]);
+
if (zoom_focus != f) {
zoom_focus = f;
- vector<string> txt = internationalize (zoom_focus_strings);
- zoom_focus_selector.set_active_text (txt[(int)f]);
+
ZoomFocusChanged (); /* EMIT_SIGNAL */
instant_save ();
return *_playlist_selector;
}
-jack_nframes_t
-Editor::get_nudge_distance (jack_nframes_t pos, jack_nframes_t& next)
+nframes_t
+Editor::get_nudge_distance (nframes_t pos, nframes_t& next)
{
- jack_nframes_t ret;
+ nframes_t ret;
ret = nudge_clock.current_duration (pos);
next = ret + 1; /* XXXX fix me */
}
bool
-Editor::audio_region_selection_covers (jack_nframes_t where)
+Editor::audio_region_selection_covers (nframes_t where)
{
for (RegionSelection::iterator a = selection->regions.begin(); a != selection->regions.end(); ++a) {
- if ((*a)->region().covers (where)) {
+ if ((*a)->region()->covers (where)) {
return true;
}
}
{
mouse_mode_tearoff->set_visible (true);
tools_tearoff->set_visible (true);
+
edit_pane.set_position (pre_maximal_pane_position);
unfullscreen();
return key_press_focus_accelerator_handler (*this, ev);
}
-void
-Editor::update_layering_model ()
-{
- RefPtr<Action> act;
-
- switch (session->get_layer_model()) {
- case Session::LaterHigher:
- act = ActionManager::get_action (X_("Editor"), X_("LayerLaterHigher"));
- break;
- case Session::MoveAddHigher:
- act = ActionManager::get_action (X_("Editor"), X_("LayerMoveAddHigher"));
- break;
- case Session::AddHigher:
- act = ActionManager::get_action (X_("Editor"), X_("LayerAddHigher"));
- break;
- }
-
- if (act) {
- RefPtr<RadioAction> ract = RefPtr<RadioAction>::cast_dynamic(act);
- if (ract && !ract->get_active()) {
- ract->set_active (true);
- }
- }
-}
-
-
-void
-Editor::update_crossfade_model ()
-{
- RefPtr<Action> act;
-
- switch (session->get_xfade_model()) {
- case FullCrossfade:
- act = ActionManager::get_action (X_("Editor"), X_("CrossfadesFull"));
- break;
- case ShortCrossfade:
- act = ActionManager::get_action (X_("Editor"), X_("CrossfadesShort"));
- break;
- }
-
- if (act) {
- RefPtr<RadioAction> ract = RefPtr<RadioAction>::cast_dynamic(act);
- if (ract && !ract->get_active()) {
- ract->set_active (true);
- }
- }
-}
-
projects / ardour.git / blobdiff