#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
};
bbt_beat_subdivision = 4;
canvas_width = 0;
canvas_height = 0;
+ autoscroll_active = false;
autoscroll_timeout_tag = -1;
interthread_progress_window = 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 ();
-
}
Editor::~Editor()
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()) {
}
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));
}
}
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;
Editor::canvas_horizontally_scrolled ()
{
- Glib::signal_idle().connect (mem_fun(*this, &Editor::lazy_canvas_horizontally_scrolled));
-
-}
-
-bool
-Editor::lazy_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 ();
tempo_map_changed (Change (0));
- return false;
}
void
-Editor::reposition_and_zoom (jack_nframes_t frame, double nfpu)
+Editor::reposition_and_zoom (nframes_t frame, double nfpu)
{
if (!repos_zoom_queued) {
repos_zoom_queued = true;
}
gint
-Editor::deferred_reposition_and_zoom (jack_nframes_t frame, double nfpu)
+Editor::deferred_reposition_and_zoom (nframes_t frame, double nfpu)
{
set_frames_per_unit (nfpu);
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 ()
{
}
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;
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);
}
/* register for undo history */
+
session->register_with_memento_command_factory(_id, this);
}
}
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) {
}
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();
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();
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();
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) {
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);
/* 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);
} 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 */
mode = Slide;
}
- session->set_edit_mode (mode);
+ Config->set_edit_mode (mode);
}
void
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)) {
{
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