#include <pbd/convert.h>
#include <pbd/error.h>
+#include <pbd/memento_command.h>
#include <gtkmm/image.h>
#include <gdkmm/color.h>
#include "keyboard.h"
#include "marker.h"
#include "playlist_selector.h"
-#include "regionview.h"
+#include "audio_region_view.h"
#include "rgb_macros.h"
#include "selection.h"
-#include "streamview.h"
+#include "audio_streamview.h"
#include "time_axis_view.h"
#include "utils.h"
#include "crossfade_view.h"
using namespace std;
using namespace sigc;
using namespace ARDOUR;
+using namespace PBD;
using namespace Gtk;
using namespace Glib;
using namespace Gtkmm2ext;
#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"),
- N_("Splice"),
- 0
-};
-
static const gchar *snap_type_strings[] = {
N_("None"),
N_("CD Frames"),
};
static const gchar *snap_mode_strings[] = {
- N_("Normal"),
- N_("Magnetic"),
+ N_("Normal Snap"),
+ N_("Magnetic Snap"),
0
};
static const gchar *zoom_focus_strings[] = {
- N_("Left"),
- N_("Right"),
- N_("Center"),
- N_("Playhead"),
- N_("Edit Cursor"),
+ N_("Focus Left"),
+ N_("Focus Right"),
+ N_("Focus Center"),
+ N_("Focus Playhead"),
+ N_("Focus Edit Cursor"),
0
};
/* tool bar related */
- selection_start_clock (X_("SelectionStartClock"), true),
- selection_end_clock (X_("SelectionEndClock"), true),
edit_cursor_clock (X_("EditCursorClock"), true),
zoom_range_clock (X_("ZoomRangeClock"), true, true),
toolbar_selection_clock_table (2,3),
- mouse_mode_button_table (2, 3),
-
- mouse_select_button (_("range")),
- mouse_move_button (_("object")),
- mouse_gain_button (_("gain")),
- mouse_zoom_button (_("zoom")),
- mouse_timefx_button (_("timefx")),
- mouse_audition_button (_("listen")),
-
automation_mode_button (_("mode")),
global_automation_button (_("automation")),
- edit_mode_label (_("Edit Mode")),
- snap_type_label (_("Snap To")),
- snap_mode_label(_("Snap Mode")),
- zoom_focus_label (_("Zoom Focus")),
-
/* <CMT Additions> */
image_socket_listener(0),
/* </CMT Additions> */
/* nudge */
- nudge_label (_("Nudge")),
nudge_clock (X_("NudgeClock"), true, true)
{
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;
reset_hscrollbar_stepping ();
zoom_focus = ZoomFocusLeft;
+ set_zoom_focus (ZoomFocusLeft);
zoom_range_clock.ValueChanged.connect (mem_fun(*this, &Editor::zoom_adjustment_changed));
initialize_rulers ();
edit_packer.attach (edit_hscrollbar, 2, 3, 2, 3, FILL|EXPAND, FILL, 0, 0);
- zoom_in_button.set_name ("EditorTimeButton");
- zoom_out_button.set_name ("EditorTimeButton");
- ARDOUR_UI::instance()->tooltips().set_tip (zoom_in_button, _("Zoom in"));
- ARDOUR_UI::instance()->tooltips().set_tip (zoom_out_button, _("Zoom out"));
-
- zoom_out_full_button.set_name ("EditorTimeButton");
- ARDOUR_UI::instance()->tooltips().set_tip (zoom_out_full_button, _("Zoom to session"));
-
- zoom_in_button.add (*(manage (new Image (Stock::ZOOM_IN, ICON_SIZE_BUTTON))));
- zoom_out_button.add (*(manage (new Image (Stock::ZOOM_OUT, ICON_SIZE_BUTTON))));
- zoom_out_full_button.add (*(manage (new Image (Stock::ZOOM_FIT, ICON_SIZE_BUTTON))));
-
- zoom_in_button.signal_clicked().connect (bind (mem_fun(*this, &Editor::temporal_zoom_step), false));
- zoom_out_button.signal_clicked().connect (bind (mem_fun(*this, &Editor::temporal_zoom_step), true));
- zoom_out_full_button.signal_clicked().connect (mem_fun(*this, &Editor::temporal_zoom_session));
-
- zoom_indicator_box.pack_start (zoom_out_button, false, false);
- zoom_indicator_box.pack_start (zoom_in_button, false, false);
- zoom_indicator_box.pack_start (zoom_range_clock, false, false);
- zoom_indicator_box.pack_start (zoom_out_full_button, false, false);
-
- zoom_indicator_label.set_text (_("Zoom Span"));
- zoom_indicator_label.set_name ("ToolBarLabel");
-
- zoom_indicator_vbox.set_spacing (3);
- zoom_indicator_vbox.set_border_width (3);
- zoom_indicator_vbox.pack_start (zoom_indicator_label, false, false);
- zoom_indicator_vbox.pack_start (zoom_indicator_box, false, false);
-
- bottom_hbox.set_border_width (3);
+ bottom_hbox.set_border_width (2);
bottom_hbox.set_spacing (3);
route_display_model = ListStore::create(route_display_columns);
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);
_playlist_selector = new PlaylistSelector();
_playlist_selector->signal_delete_event().connect (bind (sigc::ptr_fun (just_hide_it), static_cast<Window *> (_playlist_selector)));
- AudioRegionView::AudioRegionViewGoingAway.connect (mem_fun(*this, &Editor::catch_vanishing_audio_regionview));
+ RegionView::RegionViewGoingAway.connect (mem_fun(*this, &Editor::catch_vanishing_regionview));
/* nudge stuff */
nudge_forward_button.add (*(manage (new Image (get_xpm("right_arrow.xpm")))));
nudge_backward_button.add (*(manage (new Image (get_xpm("left_arrow.xpm")))));
- ARDOUR_UI::instance()->tooltips().set_tip (nudge_forward_button, _("Nudge region/selection forwards"));
- ARDOUR_UI::instance()->tooltips().set_tip (nudge_backward_button, _("Nudge region/selection backwards"));
+ ARDOUR_UI::instance()->tooltips().set_tip (nudge_forward_button, _("Nudge Region/Selection Forwards"));
+ ARDOUR_UI::instance()->tooltips().set_tip (nudge_backward_button, _("Nudge Region/Selection Backwards"));
nudge_forward_button.set_name ("TransportButton");
nudge_backward_button.set_name ("TransportButton");
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::catch_vanishing_audio_regionview (AudioRegionView *rv)
+Editor::catch_vanishing_regionview (RegionView *rv)
{
/* note: the selection will take care of the vanishing
audioregionview by itself.
}
void
-Editor::set_entered_regionview (AudioRegionView* rv)
+Editor::set_entered_regionview (RegionView* rv)
{
if (rv == entered_regionview) {
return;
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::instant_save ()
{
- if (!constructed || !ARDOUR_UI::instance()->session_loaded) {
+ if (!constructed || !ARDOUR_UI::instance()->session_loaded) {
return;
}
}
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->TransportStateChange.connect (mem_fun(*this, &Editor::map_transport_state)));
session_connections.push_back (session->PositionChanged.connect (mem_fun(*this, &Editor::map_position_change)));
- session_connections.push_back (session->RouteAdded.connect (mem_fun(*this, &Editor::handle_new_route_p)));
+ session_connections.push_back (session->RouteAdded.connect (mem_fun(*this, &Editor::handle_new_route)));
session_connections.push_back (session->AudioRegionAdded.connect (mem_fun(*this, &Editor::handle_new_audio_region)));
session_connections.push_back (session->AudioRegionRemoved.connect (mem_fun(*this, &Editor::handle_audio_region_removed)));
session_connections.push_back (session->DurationChanged.connect (mem_fun(*this, &Editor::handle_new_duration)));
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)));
edit_groups_changed ();
edit_cursor_clock.set_session (session);
- selection_start_clock.set_session (session);
- selection_end_clock.set_session (session);
zoom_range_clock.set_session (session);
_playlist_selector->set_session (session);
nudge_clock.set_session (session);
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);
AudioTimeAxisView *atv;
if ((atv = dynamic_cast<AudioTimeAxisView*>(tv)) != 0) {
- if (atv->route().master()) {
+ if (atv->route()->master()) {
route_list_display.get_selection()->unselect (i);
}
}
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->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->region, &AudioRegion::set_fade_in_shape), AudioRegion::Linear)));
- items.push_back (MenuElem (_("Slowest"), bind (mem_fun (arv->region, &AudioRegion::set_fade_in_shape), AudioRegion::LogB)));
- items.push_back (MenuElem (_("Slow"), bind (mem_fun (arv->region, &AudioRegion::set_fade_in_shape), AudioRegion::Fast)));
- items.push_back (MenuElem (_("Fast"), bind (mem_fun (arv->region, &AudioRegion::set_fade_in_shape), AudioRegion::LogA)));
- items.push_back (MenuElem (_("Fastest"), bind (mem_fun (arv->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->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->region, &AudioRegion::set_fade_out_shape), AudioRegion::Linear)));
- items.push_back (MenuElem (_("Slowest"), bind (mem_fun (arv->region, &AudioRegion::set_fade_out_shape), AudioRegion::Fast)));
- items.push_back (MenuElem (_("Slow"), bind (mem_fun (arv->region, &AudioRegion::set_fade_out_shape), AudioRegion::LogB)));
- items.push_back (MenuElem (_("Fast"), bind (mem_fun (arv->region, &AudioRegion::set_fade_out_shape), AudioRegion::LogA)));
- items.push_back (MenuElem (_("Fastest"), bind (mem_fun (arv->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 RegionItem:
- case AudioRegionViewName:
- case AudioRegionViewNameHighlight:
+ case RegionViewName:
+ case RegionViewNameHighlight:
if (with_selection) {
build_menu_function = &Editor::build_track_selection_context_menu;
} else {
switch (item_type) {
case RegionItem:
- case AudioRegionViewName:
- case AudioRegionViewNameHighlight:
+ case RegionViewName:
+ 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);
}
}
+ /*
if (region_edit_menu_split_multichannel_item) {
- if (clicked_regionview && clicked_regionview->region.n_channels() > 1) {
+ if (clicked_regionview && clicked_regionview->region().n_channels() > 1) {
// GTK2FIX find the action, change its sensitivity
// region_edit_menu_split_multichannel_item->set_sensitive (true);
} else {
// GTK2FIX see above
// region_edit_menu_split_multichannel_item->set_sensitive (false);
}
- }
+ }*/
}
break;
}
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) {
- AudioDiskstream* 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->view, (*i), edit_items);
+ add_region_context_items (atv->audio_view(), (*i), edit_items);
}
delete regions;
}
}
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) {
- AudioDiskstream* ds;
+ boost::shared_ptr<Diskstream> ds;
Playlist* pl;
AudioPlaylist* apl;
bool many = xfades.size() > 1;
for (AudioPlaylist::Crossfades::iterator i = xfades.begin(); i != xfades.end(); ++i) {
- add_crossfade_context_items (atv->view, (*i), edit_items, many);
+ add_crossfade_context_items (atv->audio_view(), (*i), edit_items, many);
}
for (Playlist::RegionList::iterator i = regions->begin(); i != regions->end(); ++i) {
- add_region_context_items (atv->view, (*i), edit_items);
+ add_region_context_items (atv->audio_view(), (*i), edit_items);
}
delete regions;
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();
}
void
-Editor::add_crossfade_context_items (StreamView* view, Crossfade* xfade, Menu_Helpers::MenuList& edit_items, bool many)
+Editor::add_crossfade_context_items (AudioStreamView* view, Crossfade* xfade, Menu_Helpers::MenuList& edit_items, bool many)
{
using namespace Menu_Helpers;
Menu *xfade_menu = manage (new Menu);
}
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 (StreamView* 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) {
yoff = atoi(geometry->property("y_off")->value());
}
- set_geometry_hints (vpacker, g, Gdk::HINT_BASE_SIZE);
set_default_size (g.base_width, g.base_height);
move (x, y);
}
}
+
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();
+ Glib::RefPtr<Gdk::Window> win = get_window();
int x, y, xoff, yoff, width, height;
win->get_root_origin(x, y);
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);
Editor::setup_toolbar ()
{
string pixmap_path;
+
+ const guint32 FUDGE = 18; // Combo's are stupid - they steal space from the entry for the button
+
+
+ /* Mode Buttons (tool selection) */
+
vector<ToggleButton *> mouse_mode_buttons;
+ mouse_move_button.add (*(manage (new Image (get_xpm("tool_object.xpm")))));
+ mouse_move_button.set_relief(Gtk::RELIEF_NONE);
mouse_mode_buttons.push_back (&mouse_move_button);
+ mouse_select_button.add (*(manage (new Image (get_xpm("tool_range.xpm")))));
+ mouse_select_button.set_relief(Gtk::RELIEF_NONE);
mouse_mode_buttons.push_back (&mouse_select_button);
+ mouse_gain_button.add (*(manage (new Image (get_xpm("tool_gain.xpm")))));
+ mouse_gain_button.set_relief(Gtk::RELIEF_NONE);
mouse_mode_buttons.push_back (&mouse_gain_button);
+ mouse_zoom_button.add (*(manage (new Image (get_xpm("tool_zoom.xpm")))));
+ mouse_zoom_button.set_relief(Gtk::RELIEF_NONE);
mouse_mode_buttons.push_back (&mouse_zoom_button);
+ mouse_timefx_button.add (*(manage (new Image (get_xpm("tool_stretch.xpm")))));
+ mouse_timefx_button.set_relief(Gtk::RELIEF_NONE);
mouse_mode_buttons.push_back (&mouse_timefx_button);
+ mouse_audition_button.add (*(manage (new Image (get_xpm("tool_audition.xpm")))));
+ mouse_audition_button.set_relief(Gtk::RELIEF_NONE);
mouse_mode_buttons.push_back (&mouse_audition_button);
+
mouse_mode_button_set = new GroupedButtons (mouse_mode_buttons);
- mouse_mode_button_table.set_homogeneous (true);
- mouse_mode_button_table.set_col_spacings (2);
- mouse_mode_button_table.set_row_spacings (2);
- mouse_mode_button_table.set_border_width (5);
+ HBox* mode_box = manage(new HBox);
+ mode_box->set_border_width (2);
+ mode_box->set_spacing(4);
+ mouse_mode_button_box.set_spacing(1);
+ mouse_mode_button_box.pack_start(mouse_move_button, true, true);
+ mouse_mode_button_box.pack_start(mouse_select_button, true, true);
+ mouse_mode_button_box.pack_start(mouse_zoom_button, true, true);
+ mouse_mode_button_box.pack_start(mouse_gain_button, true, true);
+ mouse_mode_button_box.pack_start(mouse_timefx_button, true, true);
+ 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));
- mouse_mode_button_table.attach (mouse_move_button, 0, 1, 0, 1);
- mouse_mode_button_table.attach (mouse_select_button, 1, 2, 0, 1);
- mouse_mode_button_table.attach (mouse_zoom_button, 2, 3, 0, 1);
-
- mouse_mode_button_table.attach (mouse_gain_button, 0, 1, 1, 2);
- mouse_mode_button_table.attach (mouse_timefx_button, 1, 2, 1, 2);
- mouse_mode_button_table.attach (mouse_audition_button, 2, 3, 1, 2);
+ edit_mode_selector.set_name ("EditModeSelector");
+ 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));
- mouse_mode_tearoff = manage (new TearOff (mouse_mode_button_table));
+ mode_box->pack_start(edit_mode_selector);
+ mode_box->pack_start(mouse_mode_button_box);
+
+ mouse_mode_tearoff = manage (new TearOff (*mode_box));
mouse_mode_tearoff->set_name ("MouseModeBase");
mouse_mode_tearoff->Detach.connect (bind (mem_fun(*this, &Editor::detach_tearoff), static_cast<Box*>(&toolbar_hbox),
mouse_timefx_button.set_name ("MouseModeButton");
mouse_audition_button.set_name ("MouseModeButton");
- ARDOUR_UI::instance()->tooltips().set_tip (mouse_move_button, _("select/move objects"));
- ARDOUR_UI::instance()->tooltips().set_tip (mouse_select_button, _("select/move ranges"));
- ARDOUR_UI::instance()->tooltips().set_tip (mouse_gain_button, _("draw gain automation"));
- ARDOUR_UI::instance()->tooltips().set_tip (mouse_zoom_button, _("select zoom range"));
- ARDOUR_UI::instance()->tooltips().set_tip (mouse_timefx_button, _("stretch/shrink regions"));
- ARDOUR_UI::instance()->tooltips().set_tip (mouse_audition_button, _("listen to specific regions"));
+ ARDOUR_UI::instance()->tooltips().set_tip (mouse_move_button, _("Select/Move Objects"));
+ ARDOUR_UI::instance()->tooltips().set_tip (mouse_select_button, _("Select/Move Ranges"));
+ ARDOUR_UI::instance()->tooltips().set_tip (mouse_gain_button, _("Draw Gain Automation"));
+ ARDOUR_UI::instance()->tooltips().set_tip (mouse_zoom_button, _("Select Zoom Range"));
+ ARDOUR_UI::instance()->tooltips().set_tip (mouse_timefx_button, _("Stretch/Shrink Regions"));
+ ARDOUR_UI::instance()->tooltips().set_tip (mouse_audition_button, _("Listen to Specific Regions"));
mouse_move_button.unset_flags (CAN_FOCUS);
mouse_select_button.unset_flags (CAN_FOCUS);
mouse_audition_button.signal_toggled().connect (bind (mem_fun(*this, &Editor::mouse_mode_toggled), Editing::MouseAudition));
// mouse_move_button.set_active (true);
+
- /* automation control */
-
- global_automation_button.set_name ("MouseModeButton");
- automation_mode_button.set_name ("MouseModeButton");
-
- automation_box.set_spacing (2);
- automation_box.set_border_width (2);
- automation_box.pack_start (global_automation_button, false, false);
- automation_box.pack_start (automation_mode_button, false, false);
-
- /* Edit mode */
-
- edit_mode_label.set_name ("ToolBarLabel");
-
- edit_mode_selector.set_name ("EditModeSelector");
+ /* Zoom */
+
+ zoom_box.set_spacing (1);
+ zoom_box.set_border_width (2);
- edit_mode_box.set_spacing (3);
- edit_mode_box.set_border_width (3);
+ zoom_in_button.set_name ("EditorTimeButton");
+ zoom_in_button.add (*(manage (new Image (get_xpm("zoom_in.xpm")))));
+ zoom_in_button.signal_clicked().connect (bind (mem_fun(*this, &Editor::temporal_zoom_step), false));
+ ARDOUR_UI::instance()->tooltips().set_tip (zoom_in_button, _("Zoom In"));
+
+ zoom_out_button.set_name ("EditorTimeButton");
+ zoom_out_button.add (*(manage (new Image (get_xpm("zoom_out.xpm")))));
+ zoom_out_button.signal_clicked().connect (bind (mem_fun(*this, &Editor::temporal_zoom_step), true));
+ ARDOUR_UI::instance()->tooltips().set_tip (zoom_out_button, _("Zoom Out"));
- /* XXX another disgusting hack because of the way combo boxes size themselves */
+ zoom_out_full_button.set_name ("EditorTimeButton");
+ zoom_out_full_button.add (*(manage (new Image (get_xpm("zoom_full.xpm")))));
+ zoom_out_full_button.signal_clicked().connect (mem_fun(*this, &Editor::temporal_zoom_session));
+ ARDOUR_UI::instance()->tooltips().set_tip (zoom_out_full_button, _("Zoom to Session"));
+
+ zoom_box.pack_start (zoom_out_button, false, false);
+ zoom_box.pack_start (zoom_in_button, false, false);
+ zoom_box.pack_start (zoom_range_clock, false, false);
+ zoom_box.pack_start (zoom_out_full_button, false, false);
+
+ ARDOUR_UI::instance()->tooltips().set_tip (zoom_range_clock, _("Current Zoom Range\n(Width of visible area)"));
+
+ zoom_focus_selector.set_name ("ZoomFocusSelector");
+ Gtkmm2ext::set_size_request_to_display_given_text (zoom_focus_selector, "Focus Center", 2+FUDGE, 0);
+ set_popdown_strings (zoom_focus_selector, internationalize (zoom_focus_strings));
+ zoom_focus_selector.signal_changed().connect (mem_fun(*this, &Editor::zoom_focus_selection_done));
- const guint32 FUDGE = 20; // Combo's are stupid - they steal space from the entry for the button
- Gtkmm2ext::set_size_request_to_display_given_text (edit_mode_selector, "EdgtMode", 2+FUDGE, 10);
- set_popdown_strings (edit_mode_selector, internationalize (edit_mode_strings));
- edit_mode_box.pack_start (edit_mode_label, false, false);
- edit_mode_box.pack_start (edit_mode_selector, false, false);
+ zoom_box.pack_start (zoom_focus_selector, false, false);
- edit_mode_selector.signal_changed().connect (mem_fun(*this, &Editor::edit_mode_selection_done));
- /* Snap Type */
+ /* Edit Cursor / Snap */
- snap_type_label.set_name ("ToolBarLabel");
+ snap_box.set_spacing (1);
+ snap_box.set_border_width (2);
snap_type_selector.set_name ("SnapTypeSelector");
-
- snap_type_box.set_spacing (3);
- snap_type_box.set_border_width (3);
-
- /* XXX another disgusting hack because of the way combo boxes size themselves */
-
Gtkmm2ext::set_size_request_to_display_given_text (snap_type_selector, "SMPTE Seconds", 2+FUDGE, 10);
set_popdown_strings (snap_type_selector, internationalize (snap_type_strings));
-
- snap_type_box.pack_start (snap_type_label, false, false);
- snap_type_box.pack_start (snap_type_selector, false, false);
-
snap_type_selector.signal_changed().connect (mem_fun(*this, &Editor::snap_type_selection_done));
-
- /* Snap mode, not snap type */
-
- snap_mode_label.set_name ("ToolBarLabel");
+ ARDOUR_UI::instance()->tooltips().set_tip (snap_type_selector, _("Unit to snap cursors and ranges to"));
snap_mode_selector.set_name ("SnapModeSelector");
-
- snap_mode_box.set_spacing (3);
- snap_mode_box.set_border_width (3);
-
- Gtkmm2ext::set_size_request_to_display_given_text (snap_mode_selector, "SngpMode", 2+FUDGE, 10);
+ Gtkmm2ext::set_size_request_to_display_given_text (snap_mode_selector, "Magnetic Snap", 2+FUDGE, 10);
set_popdown_strings (snap_mode_selector, internationalize (snap_mode_strings));
-
- snap_mode_box.pack_start (snap_mode_label, false, false);
- snap_mode_box.pack_start (snap_mode_selector, false, false);
-
snap_mode_selector.signal_changed().connect (mem_fun(*this, &Editor::snap_mode_selection_done));
- /* Zoom focus mode */
-
- zoom_focus_label.set_name ("ToolBarLabel");
-
- zoom_focus_selector.set_name ("ZoomFocusSelector");
-
- zoom_focus_box.set_spacing (3);
- zoom_focus_box.set_border_width (3);
-
- /* XXX another disgusting hack because of the way combo boxes size themselves */
-
- Gtkmm2ext::set_size_request_to_display_given_text (zoom_focus_selector, "Edgt Cursor", 2+FUDGE, 10);
- set_popdown_strings (zoom_focus_selector, internationalize (zoom_focus_strings));
-
- zoom_focus_box.pack_start (zoom_focus_label, false, false);
- zoom_focus_box.pack_start (zoom_focus_selector, false, false);
-
- zoom_focus_selector.signal_changed().connect (mem_fun(*this, &Editor::zoom_focus_selection_done));
-
- /* selection/cursor clocks */
-
- toolbar_selection_cursor_label.set_name ("ToolBarLabel");
- selection_start_clock_label.set_name ("ToolBarLabel");
- selection_end_clock_label.set_name ("ToolBarLabel");
- edit_cursor_clock_label.set_name ("ToolBarLabel");
-
- selection_start_clock_label.set_text (_("Start:"));
- selection_end_clock_label.set_text (_("End:"));
- edit_cursor_clock_label.set_text (_("Edit"));
-
- /* the zoom in/out buttons are generally taller than the clocks, so
- put all the toolbar clocks into a size group with one of the
- buttons to make them all equal height.
-
- this also applies to the various toolbar combos
- */
-
- RefPtr<SizeGroup> toolbar_clock_size_group = SizeGroup::create (SIZE_GROUP_VERTICAL);
- toolbar_clock_size_group->add_widget (zoom_out_button);
- toolbar_clock_size_group->add_widget (edit_cursor_clock);
- toolbar_clock_size_group->add_widget (zoom_range_clock);
- toolbar_clock_size_group->add_widget (nudge_clock);
- toolbar_clock_size_group->add_widget (edit_mode_selector);
- toolbar_clock_size_group->add_widget (snap_type_selector);
- toolbar_clock_size_group->add_widget (snap_mode_selector);
- toolbar_clock_size_group->add_widget (zoom_focus_selector);
-
- HBox* edit_clock_hbox = manage (new HBox());
- VBox* edit_clock_vbox = manage (new VBox());
-
- edit_clock_hbox->pack_start (edit_cursor_clock, false, false);
-
- edit_clock_vbox->set_spacing (3);
- edit_clock_vbox->set_border_width (3);
- edit_clock_vbox->pack_start (edit_cursor_clock_label, false, false);
- edit_clock_vbox->pack_start (*edit_clock_hbox, false, false);
-
- HBox* hbox = new HBox;
+ snap_box.pack_start (edit_cursor_clock, false, false);
+ snap_box.pack_start (snap_mode_selector, false, false);
+ snap_box.pack_start (snap_type_selector, false, false);
- hbox->pack_start (*edit_clock_vbox, false, false);
- hbox->pack_start (zoom_indicator_vbox, false, false);
- hbox->pack_start (zoom_focus_box, false, false);
- hbox->pack_start (snap_type_box, false, false);
- hbox->pack_start (snap_mode_box, false, false);
- hbox->pack_start (edit_mode_box, false, false);
- VBox *vbox = manage (new VBox);
+ /* Nudge */
- vbox->set_spacing (3);
- vbox->set_border_width (3);
+ HBox *nudge_box = manage (new HBox);
+ nudge_box->set_spacing(1);
+ nudge_box->set_border_width (2);
- HBox *nbox = manage (new HBox);
-
nudge_forward_button.signal_clicked().connect (bind (mem_fun(*this, &Editor::nudge_forward), false));
nudge_backward_button.signal_clicked().connect (bind (mem_fun(*this, &Editor::nudge_backward), false));
- nbox->pack_start (nudge_backward_button, false, false);
- nbox->pack_start (nudge_forward_button, false, false);
- nbox->pack_start (nudge_clock, false, false, 5);
-
- nudge_label.set_name ("ToolBarLabel");
+ nudge_box->pack_start (nudge_backward_button, false, false);
+ nudge_box->pack_start (nudge_forward_button, false, false);
+ nudge_box->pack_start (nudge_clock, false, false);
- vbox->pack_start (nudge_label, false, false);
- vbox->pack_start (*nbox, false, false);
- hbox->pack_start (*vbox, false, false);
+ /* Pack everything in... */
- hbox->show_all ();
+ HBox* hbox = new HBox;
+ hbox->set_spacing(10);
tools_tearoff = new TearOff (*hbox);
tools_tearoff->set_name ("MouseModeBase");
tools_tearoff->Visible.connect (bind (mem_fun(*this, &Editor::reattach_tearoff), static_cast<Box*> (&toolbar_hbox),
&tools_tearoff->tearoff_window(), 0));
- toolbar_hbox.set_spacing (8);
- toolbar_hbox.set_border_width (2);
+ toolbar_hbox.set_spacing (10);
+ toolbar_hbox.set_border_width (1);
- toolbar_hbox.pack_start (*tools_tearoff, false, false);
toolbar_hbox.pack_start (*mouse_mode_tearoff, false, false);
+ toolbar_hbox.pack_start (*tools_tearoff, false, false);
+
+
+ hbox->pack_start (snap_box, false, false);
+ hbox->pack_start (zoom_box, false, false);
+ hbox->pack_start (*nudge_box, false, false);
+
+ hbox->show_all ();
toolbar_base.set_name ("ToolBarBase");
toolbar_base.add (toolbar_hbox);
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);
continue;
}
- RouteGroup* group = atv->route().edit_group();
+ RouteGroup* group = atv->route()->edit_group();
if (group && group->is_active()) {
if ((tatv = dynamic_cast<AudioTimeAxisView*> (*i)) != 0) {
- if (tatv->route().edit_group() == group) {
+ if (tatv->route()->edit_group() == group) {
relevant_tracks.insert (tatv);
}
}
}
void
-Editor::mapped_set_selected_regionview_from_click (AudioTimeAxisView& atv, uint32_t ignored,
- AudioRegionView* basis, vector<AudioRegionView*>* all_equivs)
+Editor::mapped_set_selected_regionview_from_click (RouteTimeAxisView& tv, uint32_t ignored,
+ RegionView* basis, vector<RegionView*>* all_equivs)
{
- AudioPlaylist* pl;
- vector<AudioRegion*> results;
- AudioRegionView* marv;
- AudioDiskstream* ds;
+ Playlist* pl;
+ vector<boost::shared_ptr<Region> > results;
+ RegionView* marv;
+ boost::shared_ptr<Diskstream> ds;
- if ((ds = atv.get_diskstream()) == 0) {
+ if ((ds = tv.get_diskstream()) == 0) {
/* bus */
return;
}
- if (&atv == &basis->get_time_axis_view()) {
+ if (&tv == &basis->get_time_axis_view()) {
/* looking in same track as the original */
return;
}
- if ((pl = ds->playlist()) != 0) {
- pl->get_equivalent_regions (basis->region, results);
+ if ((pl = dynamic_cast<Playlist*>(ds->playlist())) != 0) {
+ pl->get_equivalent_regions (basis->region(), results);
}
- for (vector<AudioRegion*>::iterator ir = results.begin(); ir != results.end(); ++ir) {
- if ((marv = atv.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);
}
}
bool
Editor::set_selected_regionview_from_click (bool press, Selection::Operation op, bool no_track_remove)
{
- vector<AudioRegionView*> all_equivalent_regions;
+ vector<RegionView*> all_equivalent_regions;
bool commit = false;
if (!clicked_regionview || !clicked_audio_trackview) {
commit = true;
}
- for (vector<AudioRegionView*>::iterator i = all_equivalent_regions.begin(); i != all_equivalent_regions.end(); ++i) {
+ for (vector<RegionView*>::iterator i = all_equivalent_regions.begin(); i != all_equivalent_regions.end(); ++i) {
selection->add (*i);
}
}
} 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 */
last_frame = 0;
first_frame = max_frames;
- for (AudioRegionSelection::iterator x = selection->audio_regions.begin(); x != selection->audio_regions.end(); ++x) {
+ 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;
/* 3. convert to a vector of audio regions */
- vector<AudioRegionView*> audio_regions;
+ vector<RegionView*> regions;
for (list<Selectable*>::iterator x = results.begin(); x != results.end(); ++x) {
- AudioRegionView* arv;
+ RegionView* arv;
- if ((arv = dynamic_cast<AudioRegionView*>(*x)) != 0) {
- audio_regions.push_back (arv);
+ if ((arv = dynamic_cast<RegionView*>(*x)) != 0) {
+ regions.push_back (arv);
}
}
- if (!audio_regions.empty()) {
- selection->add (audio_regions);
+ if (!regions.empty()) {
+ selection->add (regions);
commit = true;
}
}
}
void
-Editor::set_selected_regionview_from_region_list (Region& r, Selection::Operation op)
+Editor::set_selected_regionview_from_region_list (boost::shared_ptr<Region> region, Selection::Operation op)
{
- vector<AudioRegionView*> all_equivalent_regions;
- AudioRegion* region;
-
- if ((region = dynamic_cast<AudioRegion*>(&r)) == 0) {
- return;
- }
+ vector<RegionView*> all_equivalent_regions;
for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
- AudioTimeAxisView* tatv;
+ RouteTimeAxisView* tatv;
- if ((tatv = dynamic_cast<AudioTimeAxisView*> (*i)) != 0) {
+ if ((tatv = dynamic_cast<RouteTimeAxisView*> (*i)) != 0) {
- AudioPlaylist* pl;
- vector<AudioRegion*> results;
- AudioRegionView* marv;
- AudioDiskstream* ds;
+ Playlist* pl;
+ vector<boost::shared_ptr<Region> > results;
+ RegionView* marv;
+ boost::shared_ptr<Diskstream> ds;
if ((ds = tatv->get_diskstream()) == 0) {
/* bus */
continue;
}
- if ((pl = ds->playlist()) != 0) {
- pl->get_region_list_equivalent_regions (*region, results);
+ if ((pl = dynamic_cast<Playlist*>(ds->playlist())) != 0) {
+ pl->get_region_list_equivalent_regions (region, results);
}
- for (vector<AudioRegion*>::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)
{
- AudioRegionView* rv;
- AudioRegion* ar;
+ RegionView* rv;
+ boost::shared_ptr<AudioRegion> ar;
- if ((ar = dynamic_cast<AudioRegion*> (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
a single other region.
*/
- if (selection->audio_regions.size() > 1) {
- return TRUE;
+ if (selection->regions.size() > 1) {
+ return true;
}
begin_reversible_command (_("set selected regions"));
commit_reversible_command () ;
- return TRUE;
+ return true;
}
void
if (sscanf (text.c_str(), "%f", ×) == 1) {
if (dup_region) {
- AudioRegionSelection regions;
+ RegionSelection regions;
regions.add (clicked_regionview);
duplicate_some_regions (regions, times);
} else {
string choice = edit_mode_selector.get_active_text();
EditMode mode = Slide;
- if (choice == _("Splice")) {
+ if (choice == _("Splice Edit")) {
mode = Splice;
- } else if (choice == _("Slide")) {
+ } else if (choice == _("Slide Edit")) {
mode = Slide;
}
- session->set_edit_mode (mode);
+ Config->set_edit_mode (mode);
}
void
string choice = snap_type_selector.get_active_text();
SnapType snaptype = SnapToFrame;
-
+
if (choice == _("Beats/3")) {
- snaptype = SnapToAThirdBeat;
- } else if (choice == _("Beats/4")) {
- snaptype = SnapToAQuarterBeat;
- } else if (choice == _("Beats/8")) {
- snaptype = SnapToAEighthBeat;
- } else if (choice == _("Beats/16")) {
- snaptype = SnapToASixteenthBeat;
- } else if (choice == _("Beats/32")) {
- snaptype = SnapToAThirtysecondBeat;
- } else if (choice == _("Beats")) {
+ snaptype = SnapToAThirdBeat;
+ } else if (choice == _("Beats/4")) {
+ snaptype = SnapToAQuarterBeat;
+ } else if (choice == _("Beats/8")) {
+ snaptype = SnapToAEighthBeat;
+ } else if (choice == _("Beats/16")) {
+ snaptype = SnapToASixteenthBeat;
+ } else if (choice == _("Beats/32")) {
+ snaptype = SnapToAThirtysecondBeat;
+ } else if (choice == _("Beats")) {
snaptype = SnapToBeat;
} else if (choice == _("Bars")) {
snaptype = SnapToBar;
snaptype = SnapToSeconds;
} else if (choice == _("Minutes")) {
snaptype = SnapToMinutes;
- } else if (choice == _("None")) {
+ } else if (choice == _("None")) {
snaptype = SnapToFrame;
}
-
+
set_snap_to (snaptype);
}
string choice = snap_mode_selector.get_active_text();
SnapMode mode = SnapNormal;
- if (choice == _("Normal")) {
+ if (choice == _("Normal Snap")) {
mode = SnapNormal;
- } else if (choice == _("Magnetic")) {
+ } else if (choice == _("Magnetic Snap")) {
mode = SnapMagnetic;
}
string choice = zoom_focus_selector.get_active_text();
ZoomFocus focus_type = ZoomFocusLeft;
- if (choice == _("Left")) {
+ if (choice == _("Focus Left")) {
focus_type = ZoomFocusLeft;
- } else if (choice == _("Right")) {
+ } else if (choice == _("Focus Right")) {
focus_type = ZoomFocusRight;
- } else if (choice == _("Center")) {
+ } else if (choice == _("Focus Center")) {
focus_type = ZoomFocusCenter;
- } else if (choice == _("Playhead")) {
+ } else if (choice == _("Focus Playhead")) {
focus_type = ZoomFocusPlayhead;
- } else if (choice == _("Edit Cursor")) {
+ } else if (choice == _("Focus Edit Cursor")) {
focus_type = ZoomFocusEdit;
}
Editor::region_selection_changed ()
{
for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
- (*i)->set_selected_regionviews (selection->audio_regions);
+ (*i)->set_selected_regionviews (selection->regions);
}
}
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 (AudioRegionSelection::iterator a = selection->audio_regions.begin(); a != selection->audio_regions.end(); ++a) {
- if ((*a)->region.covers (where)) {
+ for (RegionSelection::iterator a = selection->regions.begin(); a != selection->regions.end(); ++a) {
+ if ((*a)->region()->covers (where)) {
return true;
}
}
void
Editor::prepare_for_cleanup ()
{
- cut_buffer->clear_audio_regions ();
+ cut_buffer->clear_regions ();
cut_buffer->clear_playlists ();
- selection->clear_audio_regions ();
+ selection->clear_regions ();
selection->clear_playlists ();
}
{
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