#include <gtkmm/menuitem.h>
#include "gtkmm2ext/bindings.h"
-#include "gtkmm2ext/grouped_buttons.h"
#include "gtkmm2ext/gtk_ui.h"
-#include "gtkmm2ext/tearoff.h"
+#include "gtkmm2ext/keyboard.h"
#include "gtkmm2ext/utils.h"
#include "gtkmm2ext/window_title.h"
-#include "gtkmm2ext/choice.h"
#include "gtkmm2ext/cell_renderer_pixbuf_toggle.h"
+#include "ardour/analysis_graph.h"
#include "ardour/audio_track.h"
#include "ardour/audioengine.h"
#include "ardour/audioregion.h"
#include "ardour/lmath.h"
#include "ardour/location.h"
#include "ardour/profile.h"
+#include "ardour/route.h"
#include "ardour/route_group.h"
#include "ardour/session_playlists.h"
#include "ardour/tempo.h"
#include "ardour/utils.h"
+#include "ardour/vca_manager.h"
+#include "ardour/vca.h"
#include "canvas/debug.h"
#include "canvas/text.h"
+#include "widgets/ardour_spacer.h"
+#include "widgets/eventboxext.h"
+#include "widgets/tooltips.h"
+
#include "control_protocol/control_protocol.h"
#include "actions.h"
#include "crossfade_edit.h"
#include "debug.h"
#include "editing.h"
+#include "editing_convert.h"
#include "editor.h"
#include "editor_cursors.h"
#include "editor_drag.h"
#include "editor_routes.h"
#include "editor_snapshots.h"
#include "editor_summary.h"
+#include "enums_convert.h"
+#include "export_report.h"
#include "global_port_matrix.h"
#include "gui_object.h"
#include "gui_thread.h"
#include "keyboard.h"
+#include "luainstance.h"
#include "marker.h"
#include "midi_region_view.h"
#include "midi_time_axis.h"
#include "note_base.h"
#include "playlist_selector.h"
#include "public_editor.h"
+#include "quantize_dialog.h"
#include "region_layering_order_editor.h"
#include "rgb_macros.h"
#include "rhythm_ferret.h"
+#include "route_sorter.h"
#include "selection.h"
+#include "simple_progress_dialog.h"
#include "sfdb_ui.h"
#include "tempo_lines.h"
#include "time_axis_view.h"
+#include "time_info_box.h"
#include "timers.h"
+#include "ui_config.h"
#include "utils.h"
+#include "vca_time_axis.h"
#include "verbose_cursor.h"
-#include "i18n.h"
+#include "pbd/i18n.h"
using namespace std;
using namespace ARDOUR;
+using namespace ArdourWidgets;
using namespace ARDOUR_UI_UTILS;
using namespace PBD;
using namespace Gtk;
N_("Right"),
N_("Center"),
N_("Playhead"),
- N_("Mouse"),
- N_("Edit point"),
+ N_("Mouse"),
+ N_("Edit point"),
0
};
#define COMBO_TRIANGLE_WIDTH 25 // ArdourButton _diameter (11) + 2 * arrow-padding (2*2) + 2 * text-padding (2*5)
-static void
-pane_size_watcher (Paned* pane)
-{
- /* if the handle of a pane vanishes into (at least) the tabs of a notebook,
- it is:
-
- X: hard to access
- Quartz: impossible to access
-
- so stop that by preventing it from ever getting too narrow. 35
- pixels is basically a rough guess at the tab width.
-
- ugh.
- */
-
- int max_width_of_lhs = GTK_WIDGET(pane->gobj())->allocation.width - 35;
-
- gint pos = pane->get_position ();
-
- if (pos > max_width_of_lhs) {
- pane->set_position (max_width_of_lhs);
- }
-}
-
Editor::Editor ()
- : _join_object_range_state (JOIN_OBJECT_RANGE_NONE)
-
+ : PublicEditor (global_hpacker)
+ , editor_mixer_strip_width (Wide)
+ , constructed (false)
+ , _playlist_selector (0)
+ , _time_info_box (0)
+ , no_save_visual (false)
+ , leftmost_frame (0)
+ , samples_per_pixel (2048)
+ , zoom_focus (ZoomFocusPlayhead)
+ , mouse_mode (MouseObject)
+ , pre_internal_snap_type (SnapToBeat)
+ , pre_internal_snap_mode (SnapOff)
+ , internal_snap_type (SnapToBeat)
+ , internal_snap_mode (SnapOff)
+ , _join_object_range_state (JOIN_OBJECT_RANGE_NONE)
+ , _notebook_shrunk (false)
+ , location_marker_color (0)
+ , location_range_color (0)
+ , location_loop_color (0)
+ , location_punch_color (0)
+ , location_cd_marker_color (0)
+ , entered_marker (0)
+ , _show_marker_lines (false)
+ , clicked_axisview (0)
+ , clicked_routeview (0)
+ , clicked_regionview (0)
+ , clicked_selection (0)
+ , clicked_control_point (0)
+ , button_release_can_deselect (true)
, _mouse_changed_selection (false)
- /* time display buttons */
+ , region_edit_menu_split_item (0)
+ , region_edit_menu_split_multichannel_item (0)
+ , track_region_edit_playlist_menu (0)
+ , track_edit_playlist_submenu (0)
+ , track_selection_edit_playlist_submenu (0)
+ , _popup_region_menu_item (0)
+ , _track_canvas (0)
+ , _track_canvas_viewport (0)
+ , within_track_canvas (false)
+ , _verbose_cursor (0)
+ , tempo_group (0)
+ , meter_group (0)
+ , marker_group (0)
+ , range_marker_group (0)
+ , transport_marker_group (0)
+ , cd_marker_group (0)
+ , _time_markers_group (0)
+ , hv_scroll_group (0)
+ , h_scroll_group (0)
+ , cursor_scroll_group (0)
+ , no_scroll_group (0)
+ , _trackview_group (0)
+ , _drag_motion_group (0)
+ , _canvas_drop_zone (0)
+ , no_ruler_shown_update (false)
+ , ruler_grabbed_widget (0)
+ , ruler_dialog (0)
+ , minsec_mark_interval (0)
+ , minsec_mark_modulo (0)
+ , minsec_nmarks (0)
+ , timecode_ruler_scale (timecode_show_many_hours)
+ , timecode_mark_modulo (0)
+ , timecode_nmarks (0)
+ , _samples_ruler_interval (0)
+ , bbt_ruler_scale (bbt_show_many)
+ , bbt_bars (0)
+ , bbt_nmarks (0)
+ , bbt_bar_helper_on (0)
+ , bbt_accent_modulo (0)
+ , timecode_ruler (0)
+ , bbt_ruler (0)
+ , samples_ruler (0)
+ , minsec_ruler (0)
+ , visible_timebars (0)
+ , editor_ruler_menu (0)
+ , tempo_bar (0)
+ , meter_bar (0)
+ , marker_bar (0)
+ , range_marker_bar (0)
+ , transport_marker_bar (0)
+ , cd_marker_bar (0)
, minsec_label (_("Mins:Secs"))
, bbt_label (_("Bars:Beats"))
, timecode_label (_("Timecode"))
, transport_mark_label (_("Loop/Punch Ranges"))
, cd_mark_label (_("CD Markers"))
, videotl_label (_("Video Timeline"))
+ , videotl_group (0)
+ , playhead_cursor (0)
, edit_packer (4, 4, true)
-
- /* the values here don't matter: layout widgets
- reset them as needed.
- */
-
, vertical_adjustment (0.0, 0.0, 10.0, 400.0)
, horizontal_adjustment (0.0, 0.0, 1e16)
, unused_adjustment (0.0, 0.0, 10.0, 400.0)
-
, controls_layout (unused_adjustment, vertical_adjustment)
-
- /* tool bar related */
-
- , toolbar_selection_clock_table (2,3)
- , _mouse_mode_tearoff (0)
- , automation_mode_button (_("mode"))
- , _zoom_tearoff (0)
- , _tools_tearoff (0)
-
- , _toolbar_viewport (*manage (new Gtk::Adjustment (0, 0, 1e10)), *manage (new Gtk::Adjustment (0, 0, 1e10)))
+ , _scroll_callbacks (0)
+ , _visible_canvas_width (0)
+ , _visible_canvas_height (0)
+ , _full_canvas_height (0)
+ , edit_controls_left_menu (0)
+ , edit_controls_right_menu (0)
+ , visual_change_queued(false)
+ , _last_update_time (0)
+ , _err_screen_engine (0)
+ , cut_buffer_start (0)
+ , cut_buffer_length (0)
+ , button_bindings (0)
+ , last_paste_pos (-1)
+ , paste_count (0)
+ , sfbrowser (0)
+ , current_interthread_info (0)
+ , analysis_window (0)
+ , select_new_marker (false)
+ , last_scrub_x (0)
+ , scrubbing_direction (0)
+ , scrub_reversals (0)
+ , scrub_reverse_distance (0)
+ , have_pending_keyboard_selection (false)
+ , pending_keyboard_selection_start (0)
+ , _snap_type (SnapToBeat)
+ , _snap_mode (SnapOff)
+ , snap_threshold (5.0)
+ , ignore_gui_changes (false)
+ , _drags (new DragManager (this))
+ , lock_dialog (0)
+ /* , last_event_time { 0, 0 } */ /* this initialization style requires C++11 */
+ , _dragging_playhead (false)
+ , _dragging_edit_point (false)
+ , _show_measures (true)
+ , _follow_playhead (true)
+ , _stationary_playhead (false)
+ , _maximised (false)
+ , tempo_lines (0)
+ , global_rect_group (0)
+ , time_line_group (0)
+ , tempo_marker_menu (0)
+ , meter_marker_menu (0)
+ , marker_menu (0)
+ , range_marker_menu (0)
+ , transport_marker_menu (0)
+ , new_transport_marker_menu (0)
+ , cd_marker_menu (0)
+ , marker_menu_item (0)
+ , bbt_beat_subdivision (4)
+ , _visible_track_count (-1)
+ , toolbar_selection_clock_table (2,3)
+ , automation_mode_button (_("mode"))
+ , selection (new Selection (this, true))
+ , cut_buffer (new Selection (this, false))
+ , _selection_memento (new SelectionMemento())
+ , _all_region_actions_sensitized (false)
+ , _ignore_region_action (false)
+ , _last_region_menu_was_main (false)
+ , _track_selection_change_without_scroll (false)
+ , cd_marker_bar_drag_rect (0)
+ , range_bar_drag_rect (0)
+ , transport_bar_drag_rect (0)
+ , transport_bar_range_rect (0)
+ , transport_bar_preroll_rect (0)
+ , transport_bar_postroll_rect (0)
+ , transport_loop_range_rect (0)
+ , transport_punch_range_rect (0)
+ , transport_punchin_line (0)
+ , transport_punchout_line (0)
+ , transport_preroll_rect (0)
+ , transport_postroll_rect (0)
+ , temp_location (0)
+ , rubberband_rect (0)
+ , _route_groups (0)
+ , _routes (0)
+ , _regions (0)
+ , _snapshots (0)
+ , _locations (0)
+ , autoscroll_horizontal_allowed (false)
+ , autoscroll_vertical_allowed (false)
+ , autoscroll_cnt (0)
+ , autoscroll_widget (0)
+ , show_gain_after_trim (false)
, selection_op_cmd_depth (0)
, selection_op_history_it (0)
-
- /* nudge */
-
- , nudge_clock (new AudioClock (X_("nudge"), false, X_("nudge"), true, false, true))
- , meters_running(false)
+ , no_save_instant (false)
+ , current_timefx (0)
+ , current_mixer_strip (0)
+ , show_editor_mixer_when_tracks_arrive (false)
+ , nudge_clock (new AudioClock (X_("nudge"), false, X_("nudge"), true, false, true))
+ , current_stepping_trackview (0)
+ , last_track_height_step_timestamp (0)
+ , entered_track (0)
+ , entered_regionview (0)
+ , clear_entered_track (false)
+ , _edit_point (EditAtMouse)
+ , meters_running (false)
+ , rhythm_ferret (0)
+ , _have_idled (false)
+ , resize_idle_id (-1)
+ , _pending_resize_amount (0)
+ , _pending_resize_view (0)
, _pending_locate_request (false)
, _pending_initial_locate (false)
+ , _summary (0)
+ , _group_tabs (0)
+ , _last_motion_y (0)
+ , layering_order_editor (0)
, _last_cut_copy_source_track (0)
-
, _region_selection_change_updates_region_list (true)
+ , _cursors (0)
, _following_mixer_selection (false)
, _control_point_toggled_on_press (false)
, _stepping_axis_view (0)
+ , quantize_dialog (0)
+ , _main_menu_disabler (0)
+ , myactions (X_("editor"))
{
- constructed = false;
-
/* we are a singleton */
PublicEditor::_instance = this;
_have_idled = false;
-
- selection = new Selection (this);
- cut_buffer = new Selection (this);
- _selection_memento = new SelectionMemento ();
+
+ last_event_time.tv_sec = 0;
+ last_event_time.tv_usec = 0;
+
selection_op_history.clear();
before.clear();
- clicked_regionview = 0;
- clicked_axisview = 0;
- clicked_routeview = 0;
- clicked_control_point = 0;
- last_update_frame = 0;
- last_paste_pos = 0;
- paste_count = 0;
- _drags = new DragManager (this);
- lock_dialog = 0;
- ruler_dialog = 0;
- current_mixer_strip = 0;
- tempo_lines = 0;
-
snap_type_strings = I18N (_snap_type_strings);
snap_mode_strings = I18N (_snap_mode_strings);
zoom_focus_strings = I18N (_zoom_focus_strings);
build_snap_type_menu();
build_edit_point_menu();
- snap_threshold = 5.0;
- bbt_beat_subdivision = 4;
- _visible_canvas_width = 0;
- _visible_canvas_height = 0;
- autoscroll_horizontal_allowed = false;
- autoscroll_vertical_allowed = false;
- logo_item = 0;
-
- analysis_window = 0;
-
- current_interthread_info = 0;
- _show_measures = true;
- _maximised = false;
- show_gain_after_trim = false;
-
- have_pending_keyboard_selection = false;
- _follow_playhead = true;
- _stationary_playhead = false;
- editor_ruler_menu = 0;
- no_ruler_shown_update = false;
- marker_menu = 0;
- range_marker_menu = 0;
- marker_menu_item = 0;
- tempo_or_meter_marker_menu = 0;
- transport_marker_menu = 0;
- new_transport_marker_menu = 0;
- editor_mixer_strip_width = Wide;
- show_editor_mixer_when_tracks_arrive = false;
- region_edit_menu_split_multichannel_item = 0;
- region_edit_menu_split_item = 0;
- temp_location = 0;
- leftmost_frame = 0;
- current_stepping_trackview = 0;
- entered_track = 0;
- entered_regionview = 0;
- entered_marker = 0;
- clear_entered_track = false;
- current_timefx = 0;
- playhead_cursor = 0;
- button_release_can_deselect = true;
- _dragging_playhead = false;
- _dragging_edit_point = false;
- select_new_marker = false;
- rhythm_ferret = 0;
- layering_order_editor = 0;
- no_save_visual = false;
- resize_idle_id = -1;
- within_track_canvas = false;
-
- scrubbing_direction = 0;
-
- sfbrowser = 0;
-
- location_marker_color = ARDOUR_UI::config()->color ("location marker");
- location_range_color = ARDOUR_UI::config()->color ("location range");
- location_cd_marker_color = ARDOUR_UI::config()->color ("location cd marker");
- location_loop_color = ARDOUR_UI::config()->color ("location loop");
- location_punch_color = ARDOUR_UI::config()->color ("location punch");
+ location_marker_color = UIConfiguration::instance().color ("location marker");
+ location_range_color = UIConfiguration::instance().color ("location range");
+ location_cd_marker_color = UIConfiguration::instance().color ("location cd marker");
+ location_loop_color = UIConfiguration::instance().color ("location loop");
+ location_punch_color = UIConfiguration::instance().color ("location punch");
- zoom_focus = ZoomFocusPlayhead;
- _edit_point = EditAtMouse;
- _visible_track_count = -1;
-
- samples_per_pixel = 2048; /* too early to use reset_zoom () */
+ timebar_height = std::max (12., ceil (15. * UIConfiguration::instance().get_ui_scale()));
- timebar_height = std::max(12., ceil (15. * ARDOUR_UI::ui_scale));
TimeAxisView::setup_sizes ();
- Marker::setup_sizes (timebar_height);
-
- _scroll_callbacks = 0;
+ ArdourMarker::setup_sizes (timebar_height);
+ TempoCurve::setup_sizes (timebar_height);
bbt_label.set_name ("EditorRulerLabel");
bbt_label.set_size_request (-1, (int)timebar_height);
initialize_canvas ();
- CairoWidget::set_focus_handler (sigc::mem_fun (*this, &Editor::reset_focus));
+ CairoWidget::set_focus_handler (sigc::mem_fun (ARDOUR_UI::instance(), &ARDOUR_UI::reset_focus));
_summary = new EditorSummary (this);
selection->TimeChanged.connect (sigc::mem_fun(*this, &Editor::time_selection_changed));
- selection->TracksChanged.connect (sigc::mem_fun(*this, &Editor::track_selection_changed));
editor_regions_selection_changed_connection = selection->RegionsChanged.connect (sigc::mem_fun(*this, &Editor::region_selection_changed));
controls_layout.signal_scroll_event().connect (sigc::mem_fun(*this, &Editor::control_layout_scroll), false);
_cursors = new MouseCursors;
- _cursors->set_cursor_set (ARDOUR_UI::config()->get_icon_set());
- cerr << "Set cursor set to " << ARDOUR_UI::config()->get_icon_set() << endl;
+ _cursors->set_cursor_set (UIConfiguration::instance().get_icon_set());
+ cerr << "Set cursor set to " << UIConfiguration::instance().get_icon_set() << endl;
/* Push default cursor to ever-present bottom of cursor stack. */
push_canvas_cursor(_cursors->grabber);
bottom_hbox.set_border_width (2);
bottom_hbox.set_spacing (3);
+ PresentationInfo::Change.connect (*this, MISSING_INVALIDATOR, boost::bind (&Editor::presentation_info_changed, this, _1), gui_context());
+
_route_groups = new EditorRouteGroups (this);
_routes = new EditorRoutes (this);
_regions = new EditorRegions (this);
_snapshots = new EditorSnapshots (this);
_locations = new EditorLocations (this);
+ _time_info_box = new TimeInfoBox ("EditorTimeInfo", true);
/* these are static location signals */
_notebook_shrunk = false;
- editor_summary_pane.pack1(edit_packer);
- Button* summary_arrows_left_left = manage (new Button);
- summary_arrows_left_left->add (*manage (new Arrow (ARROW_LEFT, SHADOW_NONE)));
- summary_arrows_left_left->signal_pressed().connect (sigc::hide_return (sigc::bind (sigc::mem_fun (*this, &Editor::scroll_press), LEFT)));
- summary_arrows_left_left->signal_released().connect (sigc::mem_fun (*this, &Editor::scroll_release));
+ /* Pick up some settings we need to cache, early */
- Button* summary_arrows_left_right = manage (new Button);
- summary_arrows_left_right->add (*manage (new Arrow (ARROW_RIGHT, SHADOW_NONE)));
- summary_arrows_left_right->signal_pressed().connect (sigc::hide_return (sigc::bind (sigc::mem_fun (*this, &Editor::scroll_press), RIGHT)));
- summary_arrows_left_right->signal_released().connect (sigc::mem_fun (*this, &Editor::scroll_release));
+ XMLNode* settings = ARDOUR_UI::instance()->editor_settings();
- VBox* summary_arrows_left = manage (new VBox);
- summary_arrows_left->pack_start (*summary_arrows_left_left);
- summary_arrows_left->pack_start (*summary_arrows_left_right);
+ if (settings) {
+ settings->get_property ("notebook-shrunk", _notebook_shrunk);
+ }
+
+ editor_summary_pane.set_check_divider_position (true);
+ editor_summary_pane.add (edit_packer);
- Button* summary_arrows_right_up = manage (new Button);
- summary_arrows_right_up->add (*manage (new Arrow (ARROW_UP, SHADOW_NONE)));
- summary_arrows_right_up->signal_pressed().connect (sigc::hide_return (sigc::bind (sigc::mem_fun (*this, &Editor::scroll_press), UP)));
- summary_arrows_right_up->signal_released().connect (sigc::mem_fun (*this, &Editor::scroll_release));
+ Button* summary_arrow_left = manage (new Button);
+ summary_arrow_left->add (*manage (new Arrow (ARROW_LEFT, SHADOW_NONE)));
+ summary_arrow_left->signal_pressed().connect (sigc::hide_return (sigc::bind (sigc::mem_fun (*this, &Editor::scroll_press), LEFT)));
+ summary_arrow_left->signal_released().connect (sigc::mem_fun (*this, &Editor::scroll_release));
- Button* summary_arrows_right_down = manage (new Button);
- summary_arrows_right_down->add (*manage (new Arrow (ARROW_DOWN, SHADOW_NONE)));
- summary_arrows_right_down->signal_pressed().connect (sigc::hide_return (sigc::bind (sigc::mem_fun (*this, &Editor::scroll_press), DOWN)));
- summary_arrows_right_down->signal_released().connect (sigc::mem_fun (*this, &Editor::scroll_release));
+ Button* summary_arrow_right = manage (new Button);
+ summary_arrow_right->add (*manage (new Arrow (ARROW_RIGHT, SHADOW_NONE)));
+ summary_arrow_right->signal_pressed().connect (sigc::hide_return (sigc::bind (sigc::mem_fun (*this, &Editor::scroll_press), RIGHT)));
+ summary_arrow_right->signal_released().connect (sigc::mem_fun (*this, &Editor::scroll_release));
+
+ VBox* summary_arrows_left = manage (new VBox);
+ summary_arrows_left->pack_start (*summary_arrow_left);
VBox* summary_arrows_right = manage (new VBox);
- summary_arrows_right->pack_start (*summary_arrows_right_up);
- summary_arrows_right->pack_start (*summary_arrows_right_down);
+ summary_arrows_right->pack_start (*summary_arrow_right);
Frame* summary_frame = manage (new Frame);
summary_frame->set_shadow_type (Gtk::SHADOW_ETCHED_IN);
_summary_hbox.pack_start (*summary_arrows_right, false, false);
if (!ARDOUR::Profile->get_trx()) {
- editor_summary_pane.pack2 (_summary_hbox);
+ editor_summary_pane.add (_summary_hbox);
}
- edit_pane.pack1 (editor_summary_pane, true, true);
+ edit_pane.set_check_divider_position (true);
+ edit_pane.add (editor_summary_pane);
if (!ARDOUR::Profile->get_trx()) {
- edit_pane.pack2 (_the_notebook, false, true);
+ _editor_list_vbox.pack_start (*_time_info_box, false, false, 0);
+ _editor_list_vbox.pack_start (_the_notebook);
+ edit_pane.add (_editor_list_vbox);
+ edit_pane.set_child_minsize (_editor_list_vbox, 30); /* rough guess at width of notebook tabs */
}
- editor_summary_pane.signal_size_allocate().connect (sigc::bind (sigc::mem_fun (*this, &Editor::pane_allocation_handler), static_cast<Paned*> (&editor_summary_pane)));
+ edit_pane.set_drag_cursor (*_cursors->expand_left_right);
+ editor_summary_pane.set_drag_cursor (*_cursors->expand_up_down);
- /* XXX: editor_summary_pane might need similar to the edit_pane */
+ float fract;
+ if (!settings || !settings->get_property ("edit-horizontal-pane-pos", fract) || fract > 1.0) {
+ /* initial allocation is 90% to canvas, 10% to notebook */
+ fract = 0.90;
+ }
+ edit_pane.set_divider (0, fract);
- edit_pane.signal_size_allocate().connect (sigc::bind (sigc::mem_fun(*this, &Editor::pane_allocation_handler), static_cast<Paned*> (&edit_pane)));
+ if (!settings || !settings->get_property ("edit-vertical-pane-pos", fract) || fract > 1.0) {
+ /* initial allocation is 90% to canvas, 10% to summary */
+ fract = 0.90;
+ }
+ editor_summary_pane.set_divider (0, fract);
- Glib::PropertyProxy<int> proxy = edit_pane.property_position();
- proxy.signal_changed().connect (bind (sigc::ptr_fun (pane_size_watcher), static_cast<Paned*> (&edit_pane)));
+ global_vpacker.set_spacing (2);
+ global_vpacker.set_border_width (0);
- top_hbox.pack_start (toolbar_frame);
+ //the next three EventBoxes provide the ability for their child widgets to have a background color. That is all.
- HBox *hbox = manage (new HBox);
- hbox->pack_start (edit_pane, true, true);
+ Gtk::EventBox* ebox = manage (new Gtk::EventBox); //a themeable box
+ ebox->set_name("EditorWindow");
+ ebox->add (toolbar_hbox);
- global_vpacker.pack_start (top_hbox, false, false);
- global_vpacker.pack_start (*hbox, true, true);
+ Gtk::EventBox* epane_box = manage (new EventBoxExt); //a themeable box
+ epane_box->set_name("EditorWindow");
+ epane_box->add (edit_pane);
- global_hpacker.pack_start (global_vpacker, true, true);
+ Gtk::EventBox* epane_box2 = manage (new EventBoxExt); //a themeable box
+ epane_box2->set_name("EditorWindow");
+ epane_box2->add (global_vpacker);
- set_name ("EditorWindow");
- add_accel_group (ActionManager::ui_manager->get_accel_group());
+ global_vpacker.pack_start (*ebox, false, false);
+ global_vpacker.pack_start (*epane_box, true, true);
+ global_hpacker.pack_start (*epane_box2, true, true);
- status_bar_hpacker.show ();
+ /* need to show the "contents" widget so that notebook will show if tab is switched to
+ */
- vpacker.pack_end (status_bar_hpacker, false, false);
- vpacker.pack_end (global_hpacker, true, true);
+ global_hpacker.show ();
/* register actions now so that set_state() can find them and set toggles/checks etc */
register_actions ();
- /* when we start using our own keybinding system for the editor, this
- * will be uncommented
- */
- // load_bindings ();
+ load_bindings ();
setup_toolbar ();
- set_zoom_focus (zoom_focus);
- set_visible_track_count (_visible_track_count);
- _snap_type = SnapToBeat;
- set_snap_to (_snap_type);
- _snap_mode = SnapOff;
- set_snap_mode (_snap_mode);
- set_mouse_mode (MouseObject, true);
- pre_internal_snap_type = _snap_type;
- pre_internal_snap_mode = _snap_mode;
- internal_snap_type = _snap_type;
- internal_snap_mode = _snap_mode;
- set_edit_point_preference (EditAtMouse, true);
-
_playlist_selector = new PlaylistSelector();
_playlist_selector->signal_delete_event().connect (sigc::bind (sigc::ptr_fun (just_hide_it), static_cast<Window *> (_playlist_selector)));
/* nudge stuff */
nudge_forward_button.set_name ("nudge button");
- nudge_forward_button.set_image(::get_icon("nudge_right"));
+ nudge_forward_button.set_icon(ArdourIcon::NudgeRight);
nudge_backward_button.set_name ("nudge button");
- nudge_backward_button.set_image(::get_icon("nudge_left"));
+ nudge_backward_button.set_icon(ArdourIcon::NudgeLeft);
fade_context_menu.set_name ("ArdourContextMenu");
- /* icons, titles, WM stuff */
-
- list<Glib::RefPtr<Gdk::Pixbuf> > window_icons;
- Glib::RefPtr<Gdk::Pixbuf> icon;
-
- if ((icon = ::get_icon ("ardour_icon_16px")) != 0) {
- window_icons.push_back (icon);
- }
- if ((icon = ::get_icon ("ardour_icon_22px")) != 0) {
- window_icons.push_back (icon);
- }
- if ((icon = ::get_icon ("ardour_icon_32px")) != 0) {
- window_icons.push_back (icon);
- }
- if ((icon = ::get_icon ("ardour_icon_48px")) != 0) {
- window_icons.push_back (icon);
- }
- if (!window_icons.empty()) {
- // set_icon_list (window_icons);
- set_default_icon_list (window_icons);
- }
-
- WindowTitle title(Glib::get_application_name());
- title += _("Editor");
- set_title (title.get_string());
- set_wmclass (X_("ardour_editor"), PROGRAM_NAME);
-
- add (vpacker);
- add_events (Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK);
-
- signal_configure_event().connect (sigc::mem_fun (*ARDOUR_UI::instance(), &ARDOUR_UI::configure_handler));
- signal_delete_event().connect (sigc::mem_fun (*ARDOUR_UI::instance(), &ARDOUR_UI::exit_on_main_window_close));
-
Gtkmm2ext::Keyboard::the_keyboard().ZoomVerticalModifierReleased.connect (sigc::mem_fun (*this, &Editor::zoom_vertical_modifier_released));
-
+
/* allow external control surfaces/protocols to do various things */
ControlProtocol::ZoomToSession.connect (*this, invalidator (*this), boost::bind (&Editor::temporal_zoom_session, this), gui_context());
ControlProtocol::VerticalZoomInSelected.connect (*this, invalidator (*this), boost::bind (&Editor::control_vertical_zoom_in_selected, this), gui_context());
ControlProtocol::VerticalZoomOutSelected.connect (*this, invalidator (*this), boost::bind (&Editor::control_vertical_zoom_out_selected, this), gui_context());
- ControlProtocol::AddRouteToSelection.connect (*this, invalidator (*this), boost::bind (&Editor::control_select, this, _1, Selection::Add), gui_context());
- ControlProtocol::RemoveRouteFromSelection.connect (*this, invalidator (*this), boost::bind (&Editor::control_select, this, _1, Selection::Toggle), gui_context());
- ControlProtocol::SetRouteSelection.connect (*this, invalidator (*this), boost::bind (&Editor::control_select, this, _1, Selection::Set), gui_context());
- ControlProtocol::ToggleRouteSelection.connect (*this, invalidator (*this), boost::bind (&Editor::control_select, this, _1, Selection::Toggle), gui_context());
- ControlProtocol::ClearRouteSelection.connect (*this, invalidator (*this), boost::bind (&Editor::control_unselect, this), gui_context());
+ ControlProtocol::AddStripableToSelection.connect (*this, invalidator (*this), boost::bind (&Editor::control_select, this, _1, Selection::Add), gui_context());
+ ControlProtocol::RemoveStripableFromSelection.connect (*this, invalidator (*this), boost::bind (&Editor::control_select, this, _1, Selection::Toggle), gui_context());
+ ControlProtocol::SetStripableSelection.connect (*this, invalidator (*this), boost::bind (&Editor::control_select, this, _1, Selection::Set), gui_context());
+ ControlProtocol::ToggleStripableSelection.connect (*this, invalidator (*this), boost::bind (&Editor::control_select, this, _1, Selection::Toggle), gui_context());
+ ControlProtocol::ClearStripableSelection.connect (*this, invalidator (*this), boost::bind (&Editor::control_unselect, this), gui_context());
BasicUI::AccessAction.connect (*this, invalidator (*this), boost::bind (&Editor::access_action, this, _1, _2), gui_context());
+ /* handle escape */
+
+ ARDOUR_UI::instance()->Escape.connect (*this, invalidator (*this), boost::bind (&Editor::escape, this), gui_context());
+
/* problematic: has to return a value and thus cannot be x-thread */
Session::AskAboutPlaylistDeletion.connect_same_thread (*this, boost::bind (&Editor::playlist_deletion_dialog, this, _1));
Config->ParameterChanged.connect (*this, invalidator (*this), boost::bind (&Editor::parameter_changed, this, _1), gui_context());
- ARDOUR_UI::config()->ParameterChanged.connect (sigc::mem_fun (*this, &Editor::ui_parameter_changed));
+ UIConfiguration::instance().ParameterChanged.connect (sigc::mem_fun (*this, &Editor::ui_parameter_changed));
TimeAxisView::CatchDeletion.connect (*this, invalidator (*this), boost::bind (&Editor::timeaxisview_deleted, this, _1), gui_context());
_last_region_menu_was_main = false;
_popup_region_menu_item = 0;
- _ignore_follow_edits = false;
-
_show_marker_lines = false;
- /* Button bindings */
+ /* Button bindings */
- button_bindings = new Bindings;
+ button_bindings = new Bindings ("editor-mouse");
XMLNode* node = button_settings();
- if (node) {
- for (XMLNodeList::const_iterator i = node->children().begin(); i != node->children().end(); ++i) {
- button_bindings->load (**i);
- }
- }
+ if (node) {
+ for (XMLNodeList::const_iterator i = node->children().begin(); i != node->children().end(); ++i) {
+ button_bindings->load_operation (**i);
+ }
+ }
constructed = true;
/* grab current parameter state */
boost::function<void (string)> pc (boost::bind (&Editor::ui_parameter_changed, this, _1));
- ARDOUR_UI::config()->map_parameters (pc);
+ UIConfiguration::instance().map_parameters (pc);
setup_fade_images ();
Editor::~Editor()
{
- delete button_bindings;
+ delete button_bindings;
delete _routes;
delete _route_groups;
delete _track_canvas_viewport;
delete _drags;
delete nudge_clock;
+ delete _verbose_cursor;
+ delete quantize_dialog;
+ delete _summary;
+ delete _group_tabs;
+ delete _regions;
+ delete _snapshots;
+ delete _locations;
+ delete _playlist_selector;
+ delete _time_info_box;
+ delete selection;
+ delete cut_buffer;
+ delete _cursors;
+
+ LuaInstance::destroy_instance ();
+
+ for (list<XMLNode *>::iterator i = selection_op_history.begin(); i != selection_op_history.end(); ++i) {
+ delete *i;
+ }
+ for (std::map<ARDOUR::FadeShape, Gtk::Image*>::const_iterator i = _xfade_in_images.begin(); i != _xfade_in_images.end (); ++i) {
+ delete i->second;
+ }
+ for (std::map<ARDOUR::FadeShape, Gtk::Image*>::const_iterator i = _xfade_out_images.begin(); i != _xfade_out_images.end (); ++i) {
+ delete i->second;
+ }
}
XMLNode*
return node;
}
-void
-Editor::add_toplevel_menu (Container& cont)
-{
- vpacker.pack_start (cont, false, false);
- cont.show_all ();
-}
-
-void
-Editor::add_transport_frame (Container& cont)
-{
- if(ARDOUR::Profile->get_mixbus()) {
- global_vpacker.pack_start (cont, false, false);
- global_vpacker.reorder_child (cont, 0);
- cont.show_all ();
- } else {
- vpacker.pack_start (cont, false, false);
- }
-}
-
bool
Editor::get_smart_mode () const
{
}
}
-void
-Editor::show_window ()
-{
- if (!is_visible ()) {
- DisplaySuspender ds;
- show_all ();
-
- /* XXX: this is a bit unfortunate; it would probably
- be nicer if we could just call show () above rather
- than needing the show_all ()
- */
-
- /* re-hide stuff if necessary */
- editor_list_button_toggled ();
- parameter_changed ("show-summary");
- parameter_changed ("show-group-tabs");
- parameter_changed ("show-zoom-tools");
-
- /* now reset all audio_time_axis heights, because widgets might need
- to be re-hidden
- */
-
- TimeAxisView *tv;
-
- for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
- tv = (static_cast<TimeAxisView*>(*i));
- tv->reset_height ();
- }
-
- if (current_mixer_strip) {
- current_mixer_strip->hide_things ();
- current_mixer_strip->parameter_changed ("mixer-element-visibility");
- }
- }
-
- present ();
-}
-
void
Editor::instant_save ()
{
- if (!constructed || !ARDOUR_UI::instance()->session_loaded) {
+ if (!constructed || !ARDOUR_UI::instance()->session_loaded || no_save_instant) {
return;
}
}
void
-Editor::control_select (uint32_t rid, Selection::Operation op)
+Editor::control_select (boost::shared_ptr<Stripable> s, Selection::Operation op)
{
- /* handles the (static) signal from the ControlProtocol class that
- * requests setting the selected track to a given RID
- */
-
- if (!_session) {
- return;
- }
-
- boost::shared_ptr<Route> r = _session->route_by_remote_id (rid);
-
- if (!r) {
- return;
- }
-
- TimeAxisView* tav = axis_view_from_route (r);
+ TimeAxisView* tav = time_axis_view_from_stripable (s);
if (tav) {
switch (op) {
}
void
-Editor::access_action (std::string action_group, std::string action_item)
+Editor::access_action (const std::string& action_group, const std::string& action_item)
{
if (!_session) {
return;
}
}
+void
+Editor::set_toggleaction (const std::string& action_group, const std::string& action_item, bool s)
+{
+ ActionManager::set_toggleaction_state (action_group.c_str(), action_item.c_str(), s);
+}
+
void
Editor::on_realize ()
{
- Window::on_realize ();
Realized ();
- if (ARDOUR_UI::config()->get_lock_gui_after_seconds()) {
+ if (UIConfiguration::instance().get_lock_gui_after_seconds()) {
start_lock_event_timing ();
}
-
- signal_event().connect (sigc::mem_fun (*this, &Editor::generic_event_handler));
}
void
case GDK_MOTION_NOTIFY:
case GDK_KEY_PRESS:
case GDK_KEY_RELEASE:
- gettimeofday (&last_event_time, 0);
+ if (contents().is_mapped()) {
+ gettimeofday (&last_event_time, 0);
+ }
break;
case GDK_LEAVE_NOTIFY:
case GDK_NOTIFY_UNKNOWN:
case GDK_NOTIFY_INFERIOR:
case GDK_NOTIFY_ANCESTOR:
- break;
+ break;
case GDK_NOTIFY_VIRTUAL:
case GDK_NOTIFY_NONLINEAR:
case GDK_NOTIFY_NONLINEAR_VIRTUAL:
/* leaving window, so reset focus, thus ending any and
all text entry operations.
*/
- reset_focus();
+ ARDOUR_UI::instance()->reset_focus (&contents());
break;
}
break;
timersub (&now, &last_event_time, &delta);
- if (delta.tv_sec > (time_t) ARDOUR_UI::config()->get_lock_gui_after_seconds()) {
+ if (delta.tv_sec > (time_t) UIConfiguration::instance().get_lock_gui_after_seconds()) {
lock ();
/* don't call again. Returning false will effectively
disconnect us from the timer callback.
void
Editor::update_title ()
{
- ENSURE_GUI_THREAD (*this, &Editor::update_title)
+ ENSURE_GUI_THREAD (*this, &Editor::update_title);
+
+ if (!own_window()) {
+ return;
+ }
if (_session) {
bool dirty = _session->dirty();
}
WindowTitle title(session_name);
+ title += S_("Window|Editor");
title += Glib::get_application_name();
- set_title (title.get_string());
+ own_window()->set_title (title.get_string());
} else {
/* ::session_going_away() will have taken care of it */
}
return;
}
+ //initialize leftmost_frame to the extents of the session
+ //this prevents a bogus setting of leftmost = "0" if the summary view asks for the leftmost frame before the visible state has been loaded from instant.xml
+ leftmost_frame = session_gui_extents().first;
+
_playlist_selector->set_session (_session);
nudge_clock->set_session (_session);
_summary->set_session (_session);
_snapshots->set_session (_session);
_routes->set_session (_session);
_locations->set_session (_session);
+ _time_info_box->set_session (_session);
if (rhythm_ferret) {
rhythm_ferret->set_session (_session);
XMLNode* node = ARDOUR_UI::instance()->editor_settings();
set_state (*node, Stateful::loading_state_version);
+ /* catch up on selection state, etc. */
+
+ PropertyChange sc;
+ sc.add (Properties::selected);
+ presentation_info_changed (sc);
+
/* catch up with the playhead */
_session->request_locate (playhead_cursor->current_frame ());
_session->StepEditStatusChange.connect (_session_connections, invalidator (*this), boost::bind (&Editor::step_edit_status_change, this, _1), gui_context());
_session->TransportStateChange.connect (_session_connections, invalidator (*this), boost::bind (&Editor::map_transport_state, this), gui_context());
+ _session->TransportLooped.connect (_session_connections, invalidator (*this), boost::bind (&Editor::transport_looped, this), gui_context());
_session->PositionChanged.connect (_session_connections, invalidator (*this), boost::bind (&Editor::map_position_change, this, _1), gui_context());
+ _session->vca_manager().VCAAdded.connect (_session_connections, invalidator (*this), boost::bind (&Editor::add_vcas, this, _1), gui_context());
_session->RouteAdded.connect (_session_connections, invalidator (*this), boost::bind (&Editor::add_routes, this, _1), gui_context());
_session->DirtyChanged.connect (_session_connections, invalidator (*this), boost::bind (&Editor::update_title, this), gui_context());
_session->tempo_map().PropertyChanged.connect (_session_connections, invalidator (*this), boost::bind (&Editor::tempo_map_changed, this, _1), gui_context());
+ _session->tempo_map().MetricPositionChanged.connect (_session_connections, invalidator (*this), boost::bind (&Editor::tempometric_position_changed, this, _1), gui_context());
_session->Located.connect (_session_connections, invalidator (*this), boost::bind (&Editor::located, this), gui_context());
_session->config.ParameterChanged.connect (_session_connections, invalidator (*this), boost::bind (&Editor::parameter_changed, this, _1), gui_context());
_session->StateSaved.connect (_session_connections, invalidator (*this), boost::bind (&Editor::session_state_saved, this, _1), gui_context());
_session->register_with_memento_command_factory(id(), this);
_session->register_with_memento_command_factory(_selection_memento->id(), _selection_memento);
- ActionManager::ui_manager->signal_pre_activate().connect (sigc::mem_fun (*this, &Editor::action_pre_activated));
+ LuaInstance::instance()->set_session(_session);
start_updating_meters ();
}
-void
-Editor::action_pre_activated (Glib::RefPtr<Action> const & a)
-{
- if (a->get_name() == "RegionMenu") {
- /* When the main menu's region menu is opened, we setup the actions so that they look right
- in the menu. I can't find a way of getting a signal when this menu is subsequently closed,
- so we resensitize all region actions when the entered regionview or the region selection
- changes. HOWEVER we can't always resensitize on entered_regionview change because that
- happens after the region context menu is opened. So we set a flag here, too.
-
- What a carry on :(
- */
- sensitize_the_right_region_actions ();
- _last_region_menu_was_main = true;
- }
-}
-
void
Editor::fill_xfade_menu (Menu_Helpers::MenuList& items, bool start)
{
sigc::bind (sigc::mem_fun (*this, emf), FadeLinear)
)
);
-
+
dynamic_cast<ImageMenuItem*>(&items.back())->set_always_show_image ();
-
+
items.push_back (
ImageMenuElem (
_("Constant power"),
*(*images)[FadeConstantPower],
sigc::bind (sigc::mem_fun (*this, emf), FadeConstantPower)
));
-
+
dynamic_cast<ImageMenuItem*>(&items.back())->set_always_show_image ();
-
+
items.push_back (
ImageMenuElem (
_("Symmetric"),
sigc::bind (sigc::mem_fun (*this, emf), FadeSymmetric)
)
);
-
+
dynamic_cast<ImageMenuItem*>(&items.back())->set_always_show_image ();
-
+
items.push_back (
ImageMenuElem (
_("Slow"),
*(*images)[FadeSlow],
sigc::bind (sigc::mem_fun (*this, emf), FadeSlow)
));
-
+
dynamic_cast<ImageMenuItem*>(&items.back())->set_always_show_image ();
-
+
items.push_back (
ImageMenuElem (
_("Fast"),
*(*images)[FadeFast],
sigc::bind (sigc::mem_fun (*this, emf), FadeFast)
));
-
+
dynamic_cast<ImageMenuItem*>(&items.back())->set_always_show_image ();
}
/* When the region menu is opened, we setup the actions so that they look right
in the menu.
*/
- sensitize_the_right_region_actions ();
+ sensitize_the_right_region_actions (false);
_last_region_menu_was_main = false;
menu->signal_hide().connect (sigc::bind (sigc::mem_fun (*this, &Editor::sensitize_all_region_actions), true));
{
using namespace Menu_Helpers;
- MenuList& edit_items = track_context_menu.items();
+ MenuList& edit_items = track_context_menu.items();
edit_items.clear();
add_dstream_context_items (edit_items);
{
using namespace Menu_Helpers;
- MenuList& edit_items = track_context_menu.items();
+ MenuList& edit_items = track_context_menu.items();
edit_items.clear();
add_bus_context_items (edit_items);
}
void
-Editor::analyze_region_selection ()
+Editor::loudness_analyze_region_selection ()
+{
+ if (!_session) {
+ return;
+ }
+ Selection& s (PublicEditor::instance ().get_selection ());
+ RegionSelection ars = s.regions;
+ ARDOUR::AnalysisGraph ag (_session);
+ framecnt_t total_work = 0;
+
+ for (RegionSelection::iterator j = ars.begin (); j != ars.end (); ++j) {
+ AudioRegionView* arv = dynamic_cast<AudioRegionView*> (*j);
+ if (!arv) {
+ continue;
+ }
+ if (!boost::dynamic_pointer_cast<AudioRegion> (arv->region ())) {
+ continue;
+ }
+ assert (dynamic_cast<RouteTimeAxisView *> (&arv->get_time_axis_view ()));
+ total_work += arv->region ()->length ();
+ }
+
+ SimpleProgressDialog spd (_("Region Loudness Analysis"), sigc::mem_fun (ag, &AnalysisGraph::cancel));
+ ScopedConnection c;
+ ag.set_total_frames (total_work);
+ ag.Progress.connect_same_thread (c, boost::bind (&SimpleProgressDialog::update_progress, &spd, _1, _2));
+ spd.show();
+
+ for (RegionSelection::iterator j = ars.begin (); j != ars.end (); ++j) {
+ AudioRegionView* arv = dynamic_cast<AudioRegionView*> (*j);
+ if (!arv) {
+ continue;
+ }
+ boost::shared_ptr<AudioRegion> ar = boost::dynamic_pointer_cast<AudioRegion> (arv->region ());
+ if (!ar) {
+ continue;
+ }
+ ag.analyze_region (ar);
+ }
+ spd.hide();
+ if (!ag.canceled ()) {
+ ExportReport er (_("Audio Report/Analysis"), ag.results ());
+ er.run();
+ }
+}
+
+void
+Editor::loudness_analyze_range_selection ()
+{
+ if (!_session) {
+ return;
+ }
+ Selection& s (PublicEditor::instance ().get_selection ());
+ TimeSelection ts = s.time;
+ ARDOUR::AnalysisGraph ag (_session);
+ framecnt_t total_work = 0;
+
+ for (TrackSelection::iterator i = s.tracks.begin (); i != s.tracks.end (); ++i) {
+ boost::shared_ptr<AudioPlaylist> pl = boost::dynamic_pointer_cast<AudioPlaylist> ((*i)->playlist ());
+ if (!pl) {
+ continue;
+ }
+ RouteUI *rui = dynamic_cast<RouteUI *> (*i);
+ if (!pl || !rui) {
+ continue;
+ }
+ for (std::list<AudioRange>::iterator j = ts.begin (); j != ts.end (); ++j) {
+ total_work += j->length ();
+ }
+ }
+
+ SimpleProgressDialog spd (_("Range Loudness Analysis"), sigc::mem_fun (ag, &AnalysisGraph::cancel));
+ ScopedConnection c;
+ ag.set_total_frames (total_work);
+ ag.Progress.connect_same_thread (c, boost::bind (&SimpleProgressDialog::update_progress, &spd, _1, _2));
+ spd.show();
+
+ for (TrackSelection::iterator i = s.tracks.begin (); i != s.tracks.end (); ++i) {
+ boost::shared_ptr<AudioPlaylist> pl = boost::dynamic_pointer_cast<AudioPlaylist> ((*i)->playlist ());
+ if (!pl) {
+ continue;
+ }
+ RouteUI *rui = dynamic_cast<RouteUI *> (*i);
+ if (!pl || !rui) {
+ continue;
+ }
+ ag.analyze_range (rui->route (), pl, ts);
+ }
+ spd.hide();
+ if (!ag.canceled ()) {
+ ExportReport er (_("Audio Report/Analysis"), ag.results ());
+ er.run();
+ }
+}
+
+void
+Editor::spectral_analyze_region_selection ()
{
if (analysis_window == 0) {
analysis_window = new AnalysisWindow();
}
void
-Editor::analyze_range_selection()
+Editor::spectral_analyze_range_selection()
{
if (analysis_window == 0) {
analysis_window = new AnalysisWindow();
RegionSelection rs = get_regions_from_selection_and_entered ();
- string::size_type pos = 0;
string menu_item_name = (rs.size() == 1) ? rs.front()->region()->name() : _("Selected Regions");
- /* we have to hack up the region name because "_" has a special
- meaning for menu titles.
- */
-
- while ((pos = menu_item_name.find ("_", pos)) != string::npos) {
- menu_item_name.replace (pos, 1, "__");
- pos += 2;
- }
-
if (_popup_region_menu_item == 0) {
- _popup_region_menu_item = new MenuItem (menu_item_name);
+ _popup_region_menu_item = new MenuItem (menu_item_name, false);
_popup_region_menu_item->set_submenu (*dynamic_cast<Menu*> (ActionManager::get_widget (X_("/PopupRegionMenu"))));
_popup_region_menu_item->show ();
} else {
_popup_region_menu_item->set_label (menu_item_name);
}
- /* No latering allowed in later is higher layering model */
+ /* No layering allowed in later is higher layering model */
RefPtr<Action> act = ActionManager::get_action (X_("EditorMenu"), X_("RegionMenuLayering"));
if (act && Config->get_layer_model() == LaterHigher) {
act->set_sensitive (false);
edit_items.push_back (MenuElem (_("Loop Range"), sigc::bind (sigc::mem_fun(*this, &Editor::set_loop_from_selection), true)));
edit_items.push_back (SeparatorElem());
- edit_items.push_back (MenuElem (_("Zoom to Range"), sigc::bind (sigc::mem_fun(*this, &Editor::temporal_zoom_selection), false)));
+ edit_items.push_back (MenuElem (_("Zoom to Range"), sigc::bind (sigc::mem_fun(*this, &Editor::temporal_zoom_selection), Horizontal)));
edit_items.push_back (SeparatorElem());
- edit_items.push_back (MenuElem (_("Spectral Analysis"), sigc::mem_fun(*this, &Editor::analyze_range_selection)));
+ edit_items.push_back (MenuElem (_("Loudness Analysis"), sigc::mem_fun(*this, &Editor::loudness_analyze_range_selection)));
+ edit_items.push_back (MenuElem (_("Spectral Analysis"), sigc::mem_fun(*this, &Editor::spectral_analyze_range_selection)));
edit_items.push_back (SeparatorElem());
edit_items.push_back (SeparatorElem());
edit_items.push_back (MenuElem (_("Crop Region to Range"), sigc::mem_fun(*this, &Editor::crop_region_to_selection)));
- edit_items.push_back (MenuElem (_("Fill Range with Region"), sigc::mem_fun(*this, &Editor::region_fill_selection)));
edit_items.push_back (MenuElem (_("Duplicate Range"), sigc::bind (sigc::mem_fun(*this, &Editor::duplicate_range), false)));
edit_items.push_back (SeparatorElem());
edit_items.push_back (MenuElem (_("Consolidate Range"), sigc::bind (sigc::mem_fun(*this, &Editor::bounce_range_selection), true, false)));
- edit_items.push_back (MenuElem (_("Consolidate Range With Processing"), sigc::bind (sigc::mem_fun(*this, &Editor::bounce_range_selection), true, true)));
+ edit_items.push_back (MenuElem (_("Consolidate Range with Processing"), sigc::bind (sigc::mem_fun(*this, &Editor::bounce_range_selection), true, true)));
edit_items.push_back (MenuElem (_("Bounce Range to Region List"), sigc::bind (sigc::mem_fun(*this, &Editor::bounce_range_selection), false, false)));
- edit_items.push_back (MenuElem (_("Bounce Range to Region List With Processing"), sigc::bind (sigc::mem_fun(*this, &Editor::bounce_range_selection), false, true)));
+ edit_items.push_back (MenuElem (_("Bounce Range to Region List with Processing"), sigc::bind (sigc::mem_fun(*this, &Editor::bounce_range_selection), false, true)));
edit_items.push_back (MenuElem (_("Export Range..."), sigc::mem_fun(*this, &Editor::export_selection)));
if (ARDOUR_UI::instance()->video_timeline->get_duration() > 0) {
edit_items.push_back (MenuElem (_("Export Video Range..."), sigc::bind (sigc::mem_fun(*(ARDOUR_UI::instance()), &ARDOUR_UI::export_video), true)));
MenuList& play_items = play_menu->items();
play_menu->set_name ("ArdourContextMenu");
- play_items.push_back (MenuElem (_("Play From Edit Point"), sigc::mem_fun(*this, &Editor::play_from_edit_point)));
- play_items.push_back (MenuElem (_("Play From Start"), sigc::mem_fun(*this, &Editor::play_from_start)));
+ play_items.push_back (MenuElem (_("Play from Edit Point"), sigc::mem_fun(*this, &Editor::play_from_edit_point)));
+ play_items.push_back (MenuElem (_("Play from Start"), sigc::mem_fun(*this, &Editor::play_from_start)));
play_items.push_back (MenuElem (_("Play Region"), sigc::mem_fun(*this, &Editor::play_selected_region)));
play_items.push_back (SeparatorElem());
play_items.push_back (MenuElem (_("Loop Region"), sigc::bind (sigc::mem_fun (*this, &Editor::set_loop_from_region), true)));
select_items.push_back (MenuElem (_("Set Range to Punch Range"), sigc::mem_fun(*this, &Editor::set_selection_from_punch)));
select_items.push_back (MenuElem (_("Set Range to Selected Regions"), sigc::mem_fun(*this, &Editor::set_selection_from_region)));
select_items.push_back (SeparatorElem());
- select_items.push_back (MenuElem (_("Select All After Edit Point"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_edit), true)));
- select_items.push_back (MenuElem (_("Select All Before Edit Point"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_edit), false)));
+ select_items.push_back (MenuElem (_("Select All After Edit Point"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_edit), true, true)));
+ select_items.push_back (MenuElem (_("Select All Before Edit Point"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_edit), false, true)));
select_items.push_back (MenuElem (_("Select All After Playhead"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_cursor), playhead_cursor, true)));
select_items.push_back (MenuElem (_("Select All Before Playhead"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_cursor), playhead_cursor, false)));
select_items.push_back (MenuElem (_("Select All Between Playhead and Edit Point"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_between), false)));
MenuList& play_items = play_menu->items();
play_menu->set_name ("ArdourContextMenu");
- play_items.push_back (MenuElem (_("Play From Edit Point"), sigc::mem_fun(*this, &Editor::play_from_edit_point)));
- play_items.push_back (MenuElem (_("Play From Start"), sigc::mem_fun(*this, &Editor::play_from_start)));
+ play_items.push_back (MenuElem (_("Play from Edit Point"), sigc::mem_fun(*this, &Editor::play_from_edit_point)));
+ play_items.push_back (MenuElem (_("Play from Start"), sigc::mem_fun(*this, &Editor::play_from_start)));
edit_items.push_back (MenuElem (_("Play"), *play_menu));
/* Selection */
select_items.push_back (MenuElem (_("Invert Selection in Track"), sigc::mem_fun(*this, &Editor::invert_selection_in_track)));
select_items.push_back (MenuElem (_("Invert Selection"), sigc::mem_fun(*this, &Editor::invert_selection)));
select_items.push_back (SeparatorElem());
- select_items.push_back (MenuElem (_("Select All After Edit Point"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_edit), true)));
- select_items.push_back (MenuElem (_("Select All Before Edit Point"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_edit), false)));
+ select_items.push_back (MenuElem (_("Select All After Edit Point"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_edit), true, true)));
+ select_items.push_back (MenuElem (_("Select All Before Edit Point"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_edit), false, true)));
select_items.push_back (MenuElem (_("Select All After Playhead"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_cursor), playhead_cursor, true)));
select_items.push_back (MenuElem (_("Select All Before Playhead"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_cursor), playhead_cursor, false)));
return _snap_type;
}
+bool
+Editor::snap_musical() const
+{
+ switch (_snap_type) {
+ case SnapToBeatDiv128:
+ case SnapToBeatDiv64:
+ case SnapToBeatDiv32:
+ case SnapToBeatDiv28:
+ case SnapToBeatDiv24:
+ case SnapToBeatDiv20:
+ case SnapToBeatDiv16:
+ case SnapToBeatDiv14:
+ case SnapToBeatDiv12:
+ case SnapToBeatDiv10:
+ case SnapToBeatDiv8:
+ case SnapToBeatDiv7:
+ case SnapToBeatDiv6:
+ case SnapToBeatDiv5:
+ case SnapToBeatDiv4:
+ case SnapToBeatDiv3:
+ case SnapToBeatDiv2:
+ case SnapToBeat:
+ case SnapToBar:
+ return true;
+ default:
+ break;
+ }
+
+ return false;
+}
+
SnapMode
Editor::snap_mode() const
{
case SnapToBeatDiv4:
case SnapToBeatDiv3:
case SnapToBeatDiv2: {
- ARDOUR::TempoMap::BBTPointList::const_iterator current_bbt_points_begin;
- ARDOUR::TempoMap::BBTPointList::const_iterator current_bbt_points_end;
-
- compute_current_bbt_points (leftmost_frame, leftmost_frame + current_page_samples(),
- current_bbt_points_begin, current_bbt_points_end);
- compute_bbt_ruler_scale (leftmost_frame, leftmost_frame + current_page_samples(),
- current_bbt_points_begin, current_bbt_points_end);
- update_tempo_based_rulers (current_bbt_points_begin, current_bbt_points_end);
+ compute_bbt_ruler_scale (leftmost_frame, leftmost_frame + current_page_samples());
+ update_tempo_based_rulers ();
break;
}
}
reset_canvas_action_sensitivity (in_track_canvas);
+ sensitize_the_right_region_actions (false);
instant_save ();
}
int
-Editor::set_state (const XMLNode& node, int /*version*/)
+Editor::set_state (const XMLNode& node, int version)
{
- const XMLProperty* prop;
- XMLNode* geometry;
- int x, y;
- Gdk::Geometry g;
-
set_id (node);
+ PBD::Unwinder<bool> nsi (no_save_instant, true);
+ bool yn;
- g.base_width = default_width;
- g.base_height = default_height;
- x = 1;
- y = 1;
-
- if ((geometry = find_named_node (node, "geometry")) != 0) {
-
- XMLProperty* prop;
-
- if ((prop = geometry->property("x_size")) == 0) {
- prop = geometry->property ("x-size");
- }
- if (prop) {
- g.base_width = atoi(prop->value());
- }
- if ((prop = geometry->property("y_size")) == 0) {
- prop = geometry->property ("y-size");
- }
- if (prop) {
- g.base_height = atoi(prop->value());
- }
-
- if ((prop = geometry->property ("x_pos")) == 0) {
- prop = geometry->property ("x-pos");
- }
- if (prop) {
- x = atoi (prop->value());
-
- }
- if ((prop = geometry->property ("y_pos")) == 0) {
- prop = geometry->property ("y-pos");
- }
- if (prop) {
- y = atoi (prop->value());
- }
- }
-
- set_default_size (g.base_width, g.base_height);
- move (x, y);
+ Tabbable::set_state (node, version);
- if (_session && (prop = node.property ("playhead"))) {
- framepos_t pos;
- sscanf (prop->value().c_str(), "%" PRIi64, &pos);
- if (pos >= 0) {
- playhead_cursor->set_position (pos);
+ framepos_t ph_pos;
+ if (_session && node.get_property ("playhead", ph_pos)) {
+ if (ph_pos >= 0) {
+ playhead_cursor->set_position (ph_pos);
} else {
warning << _("Playhead position stored with a negative value - ignored (use zero instead)") << endmsg;
playhead_cursor->set_position (0);
playhead_cursor->set_position (0);
}
- if ((prop = node.property ("mixer-width"))) {
- editor_mixer_strip_width = Width (string_2_enum (prop->value(), editor_mixer_strip_width));
- }
+ node.get_property ("mixer-width", editor_mixer_strip_width);
- if ((prop = node.property ("zoom-focus"))) {
- zoom_focus_selection_done ((ZoomFocus) string_2_enum (prop->value(), zoom_focus));
- }
+ node.get_property ("zoom-focus", zoom_focus);
+ zoom_focus_selection_done (zoom_focus);
- if ((prop = node.property ("zoom"))) {
+ double z;
+ if (node.get_property ("zoom", z)) {
/* older versions of ardour used floating point samples_per_pixel */
- double f = PBD::atof (prop->value());
- reset_zoom (llrintf (f));
+ reset_zoom (llrintf (z));
} else {
reset_zoom (samples_per_pixel);
}
- if ((prop = node.property ("visible-track-count"))) {
- set_visible_track_count (PBD::atoi (prop->value()));
- }
-
- if ((prop = node.property ("snap-to"))) {
- snap_type_selection_done ((SnapType) string_2_enum (prop->value(), _snap_type));
+ int32_t cnt;
+ if (node.get_property ("visible-track-count", cnt)) {
+ set_visible_track_count (cnt);
}
- if ((prop = node.property ("snap-mode"))) {
- snap_mode_selection_done((SnapMode) string_2_enum (prop->value(), _snap_mode));
+ SnapType snap_type;
+ if (!node.get_property ("snap-to", snap_type)) {
+ snap_type = _snap_type;
}
+ set_snap_to (snap_type);
- if ((prop = node.property ("internal-snap-to"))) {
- internal_snap_type = (SnapType) string_2_enum (prop->value(), internal_snap_type);
- }
-
- if ((prop = node.property ("internal-snap-mode"))) {
- internal_snap_mode = (SnapMode) string_2_enum (prop->value(), internal_snap_mode);
- }
-
- if ((prop = node.property ("pre-internal-snap-to"))) {
- pre_internal_snap_type = (SnapType) string_2_enum (prop->value(), pre_internal_snap_type);
+ SnapMode sm;
+ if (node.get_property ("snap-mode", sm)) {
+ snap_mode_selection_done(sm);
+ /* set text of Dropdown. in case _snap_mode == SnapOff (default)
+ * snap_mode_selection_done() will only mark an already active item as active
+ * which does not trigger set_text().
+ */
+ set_snap_mode (sm);
+ } else {
+ set_snap_mode (_snap_mode);
}
- if ((prop = node.property ("pre-internal-snap-mode"))) {
- pre_internal_snap_mode = (SnapMode) string_2_enum (prop->value(), pre_internal_snap_mode);
- }
+ node.get_property ("internal-snap-to", internal_snap_type);
+ node.get_property ("internal-snap-mode", internal_snap_mode);
+ node.get_property ("pre-internal-snap-to", pre_internal_snap_type);
+ node.get_property ("pre-internal-snap-mode", pre_internal_snap_mode);
- if ((prop = node.property ("mouse-mode"))) {
- MouseMode m = str2mousemode(prop->value());
+ std::string mm_str;
+ if (node.get_property ("mouse-mode", mm_str)) {
+ MouseMode m = str2mousemode(mm_str);
set_mouse_mode (m, true);
} else {
set_mouse_mode (MouseObject, true);
}
- if ((prop = node.property ("left-frame")) != 0) {
- framepos_t pos;
- if (sscanf (prop->value().c_str(), "%" PRId64, &pos) == 1) {
- if (pos < 0) {
- pos = 0;
- }
- reset_x_origin (pos);
+ framepos_t lf_pos;
+ if (node.get_property ("left-frame", lf_pos)) {
+ if (lf_pos < 0) {
+ lf_pos = 0;
}
+ reset_x_origin (lf_pos);
}
- if ((prop = node.property ("y-origin")) != 0) {
- reset_y_origin (atof (prop->value ()));
+ double y_origin;
+ if (node.get_property ("y-origin", y_origin)) {
+ reset_y_origin (y_origin);
}
- if ((prop = node.property ("join-object-range"))) {
+ if (node.get_property ("join-object-range", yn)) {
RefPtr<Action> act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-object-range"));
- bool yn = string_is_affirmative (prop->value());
if (act) {
RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
tact->set_active (!yn);
set_mouse_mode(mouse_mode, true);
}
- if ((prop = node.property ("edit-point"))) {
- set_edit_point_preference ((EditPoint) string_2_enum (prop->value(), _edit_point), true);
+ EditPoint ep;
+ if (node.get_property ("edit-point", ep)) {
+ set_edit_point_preference (ep, true);
+ } else {
+ set_edit_point_preference (_edit_point);
}
- if ((prop = node.property ("show-measures"))) {
- bool yn = string_is_affirmative (prop->value());
- _show_measures = yn;
- }
+ node.get_property ("show-measures", _show_measures);
- if ((prop = node.property ("follow-playhead"))) {
- bool yn = string_is_affirmative (prop->value());
+ if (node.get_property ("follow-playhead", yn)) {
set_follow_playhead (yn);
}
- if ((prop = node.property ("stationary-playhead"))) {
- bool yn = string_is_affirmative (prop->value());
+ if (node.get_property ("stationary-playhead", yn)) {
set_stationary_playhead (yn);
}
- if ((prop = node.property ("region-list-sort-type"))) {
- RegionListSortType st;
- _regions->reset_sort_type ((RegionListSortType) string_2_enum (prop->value(), st), true);
+ RegionListSortType sort_type;
+ if (node.get_property ("region-list-sort-type", sort_type)) {
+ _regions->reset_sort_type (sort_type, true);
}
- if ((prop = node.property ("show-editor-mixer"))) {
+ if (node.get_property ("show-editor-mixer", yn)) {
Glib::RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("show-editor-mixer"));
assert (act);
Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
- bool yn = string_is_affirmative (prop->value());
/* do it twice to force the change */
tact->set_active (yn);
}
- if ((prop = node.property ("show-editor-list"))) {
+ if (node.get_property ("show-editor-list", yn)) {
Glib::RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("show-editor-list"));
assert (act);
Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
- bool yn = string_is_affirmative (prop->value());
/* do it twice to force the change */
tact->set_active (yn);
}
- if ((prop = node.property (X_("editor-list-page")))) {
- _the_notebook.set_current_page (atoi (prop->value ()));
+ int32_t el_page;
+ if (node.get_property (X_("editor-list-page"), el_page)) {
+ _the_notebook.set_current_page (el_page);
}
- if ((prop = node.property (X_("show-marker-lines")))) {
+ if (node.get_property (X_("show-marker-lines"), yn)) {
Glib::RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("show-marker-lines"));
assert (act);
Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
- bool yn = string_is_affirmative (prop->value ());
tact->set_active (!yn);
tact->set_active (yn);
for (XMLNodeList::const_iterator i = children.begin(); i != children.end(); ++i) {
selection->set_state (**i, Stateful::current_state_version);
_regions->set_state (**i);
+ _locations->set_state (**i);
}
- if ((prop = node.property ("maximised"))) {
- bool yn = string_is_affirmative (prop->value());
+ if (node.get_property ("maximised", yn)) {
Glib::RefPtr<Action> act = ActionManager::get_action (X_("Common"), X_("ToggleMaximalEditor"));
assert (act);
Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
}
}
- if ((prop = node.property ("nudge-clock-value"))) {
- framepos_t f;
- sscanf (prop->value().c_str(), "%" PRId64, &f);
- nudge_clock->set (f);
+ framepos_t nudge_clock_value;
+ if (node.get_property ("nudge-clock-value", nudge_clock_value)) {
+ nudge_clock->set (nudge_clock_value);
} else {
nudge_clock->set_mode (AudioClock::Timecode);
nudge_clock->set (_session->frame_rate() * 5, true);
* those that are linked to a private variable may need changing
*/
RefPtr<Action> act;
- bool yn;
act = ActionManager::get_action (X_("Editor"), X_("ToggleMeasureVisibility"));
if (act) {
}
}
- return 0;
+ return LuaInstance::instance()->set_state(node);
}
XMLNode&
Editor::get_state ()
{
- XMLNode* node = new XMLNode ("Editor");
- char buf[32];
-
- id().print (buf, sizeof (buf));
- node->add_property ("id", buf);
+ XMLNode* node = new XMLNode (X_("Editor"));
- if (is_realized()) {
- Glib::RefPtr<Gdk::Window> win = get_window();
+ node->set_property ("id", id().to_s ());
- int x, y, width, height;
- win->get_root_origin(x, y);
- win->get_size(width, height);
+ node->add_child_nocopy (Tabbable::get_state());
- XMLNode* geometry = new XMLNode ("geometry");
-
- snprintf(buf, sizeof(buf), "%d", width);
- geometry->add_property("x-size", string(buf));
- snprintf(buf, sizeof(buf), "%d", height);
- geometry->add_property("y-size", string(buf));
- snprintf(buf, sizeof(buf), "%d", x);
- geometry->add_property("x-pos", string(buf));
- snprintf(buf, sizeof(buf), "%d", y);
- geometry->add_property("y-pos", string(buf));
- snprintf(buf,sizeof(buf), "%d",gtk_paned_get_position (static_cast<Paned*>(&edit_pane)->gobj()));
- geometry->add_property("edit-horizontal-pane-pos", string(buf));
- geometry->add_property("notebook-shrunk", _notebook_shrunk ? "1" : "0");
- snprintf(buf,sizeof(buf), "%d",gtk_paned_get_position (static_cast<Paned*>(&editor_summary_pane)->gobj()));
- geometry->add_property("edit-vertical-pane-pos", string(buf));
-
- node->add_child_nocopy (*geometry);
- }
+ node->set_property("edit-horizontal-pane-pos", edit_pane.get_divider ());
+ node->set_property("notebook-shrunk", _notebook_shrunk);
+ node->set_property("edit-vertical-pane-pos", editor_summary_pane.get_divider());
maybe_add_mixer_strip_width (*node);
- node->add_property ("zoom-focus", enum_2_string (zoom_focus));
-
- snprintf (buf, sizeof(buf), "%" PRId64, samples_per_pixel);
- node->add_property ("zoom", buf);
- node->add_property ("snap-to", enum_2_string (_snap_type));
- node->add_property ("snap-mode", enum_2_string (_snap_mode));
- node->add_property ("internal-snap-to", enum_2_string (internal_snap_type));
- node->add_property ("internal-snap-mode", enum_2_string (internal_snap_mode));
- node->add_property ("pre-internal-snap-to", enum_2_string (pre_internal_snap_type));
- node->add_property ("pre-internal-snap-mode", enum_2_string (pre_internal_snap_mode));
- node->add_property ("edit-point", enum_2_string (_edit_point));
- snprintf (buf, sizeof(buf), "%d", _visible_track_count);
- node->add_property ("visible-track-count", buf);
-
- snprintf (buf, sizeof (buf), "%" PRIi64, playhead_cursor->current_frame ());
- node->add_property ("playhead", buf);
- snprintf (buf, sizeof (buf), "%" PRIi64, leftmost_frame);
- node->add_property ("left-frame", buf);
- snprintf (buf, sizeof (buf), "%f", vertical_adjustment.get_value ());
- node->add_property ("y-origin", buf);
-
- node->add_property ("show-measures", _show_measures ? "yes" : "no");
- node->add_property ("maximised", _maximised ? "yes" : "no");
- node->add_property ("follow-playhead", _follow_playhead ? "yes" : "no");
- node->add_property ("stationary-playhead", _stationary_playhead ? "yes" : "no");
- node->add_property ("region-list-sort-type", enum_2_string (_regions->sort_type ()));
- node->add_property ("mouse-mode", enum2str(mouse_mode));
- node->add_property ("join-object-range", smart_mode_action->get_active () ? "yes" : "no");
+ node->set_property ("zoom-focus", zoom_focus);
+
+ node->set_property ("zoom", samples_per_pixel);
+ node->set_property ("snap-to", _snap_type);
+ node->set_property ("snap-mode", _snap_mode);
+ node->set_property ("internal-snap-to", internal_snap_type);
+ node->set_property ("internal-snap-mode", internal_snap_mode);
+ node->set_property ("pre-internal-snap-to", pre_internal_snap_type);
+ node->set_property ("pre-internal-snap-mode", pre_internal_snap_mode);
+ node->set_property ("edit-point", _edit_point);
+ node->set_property ("visible-track-count", _visible_track_count);
+
+ node->set_property ("playhead", playhead_cursor->current_frame ());
+ node->set_property ("left-frame", leftmost_frame);
+ node->set_property ("y-origin", vertical_adjustment.get_value ());
+
+ node->set_property ("show-measures", _show_measures);
+ node->set_property ("maximised", _maximised);
+ node->set_property ("follow-playhead", _follow_playhead);
+ node->set_property ("stationary-playhead", _stationary_playhead);
+ node->set_property ("region-list-sort-type", _regions->sort_type ());
+ node->set_property ("mouse-mode", mouse_mode);
+ node->set_property ("join-object-range", smart_mode_action->get_active ());
Glib::RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("show-editor-mixer"));
if (act) {
Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
- node->add_property (X_("show-editor-mixer"), tact->get_active() ? "yes" : "no");
+ node->set_property (X_("show-editor-mixer"), tact->get_active());
}
act = ActionManager::get_action (X_("Editor"), X_("show-editor-list"));
if (act) {
Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
- node->add_property (X_("show-editor-list"), tact->get_active() ? "yes" : "no");
+ node->set_property (X_("show-editor-list"), tact->get_active());
}
- snprintf (buf, sizeof (buf), "%d", _the_notebook.get_current_page ());
- node->add_property (X_("editor-list-page"), buf);
+ node->set_property (X_("editor-list-page"), _the_notebook.get_current_page ());
- if (button_bindings) {
- XMLNode* bb = new XMLNode (X_("Buttons"));
- button_bindings->save (*bb);
- node->add_child_nocopy (*bb);
- }
+ if (button_bindings) {
+ XMLNode* bb = new XMLNode (X_("Buttons"));
+ button_bindings->save (*bb);
+ node->add_child_nocopy (*bb);
+ }
- node->add_property (X_("show-marker-lines"), _show_marker_lines ? "yes" : "no");
+ node->set_property (X_("show-marker-lines"), _show_marker_lines);
node->add_child_nocopy (selection->get_state ());
node->add_child_nocopy (_regions->get_state ());
- snprintf (buf, sizeof (buf), "%" PRId64, nudge_clock->current_duration());
- node->add_property ("nudge-clock-value", buf);
+ node->set_property ("nudge-clock-value", nudge_clock->current_duration());
+
+ node->add_child_nocopy (LuaInstance::instance()->get_action_state());
+ node->add_child_nocopy (LuaInstance::instance()->get_hook_state());
+ node->add_child_nocopy (_locations->get_state ());
return *node;
}
}
for (TrackViewList::const_iterator iter = track_views.begin(); iter != track_views.end(); ++iter) {
-
+
std::pair<TimeAxisView*, double> const r = (*iter)->covers_y_position (y);
-
+
if (r.first) {
return r;
}
* @param event Event to get current key modifier information from, or 0.
*/
void
-Editor::snap_to_with_modifier (framepos_t& start, GdkEvent const * event, RoundMode direction, bool for_mark)
+Editor::snap_to_with_modifier (MusicFrame& start, GdkEvent const * event, RoundMode direction, bool for_mark)
{
if (!_session || !event) {
return;
if (ArdourKeyboard::indicates_snap (event->button.state)) {
if (_snap_mode == SnapOff) {
snap_to_internal (start, direction, for_mark);
+ } else {
+ start.set (start.frame, 0);
}
} else {
if (_snap_mode != SnapOff) {
} else if (ArdourKeyboard::indicates_snap_delta (event->button.state)) {
/* SnapOff, but we pressed the snap_delta modifier */
snap_to_internal (start, direction, for_mark);
+ } else {
+ start.set (start.frame, 0);
}
}
}
void
-Editor::snap_to (framepos_t& start, RoundMode direction, bool for_mark, bool ensure_snap)
+Editor::snap_to (MusicFrame& start, RoundMode direction, bool for_mark, bool ensure_snap)
{
if (!_session || (_snap_mode == SnapOff && !ensure_snap)) {
+ start.set (start.frame, 0);
return;
}
}
void
-Editor::timecode_snap_to_internal (framepos_t& start, RoundMode direction, bool /*for_mark*/)
+Editor::timecode_snap_to_internal (MusicFrame& pos, RoundMode direction, bool /*for_mark*/)
{
- const framepos_t one_timecode_second = (framepos_t)(rint(_session->timecode_frames_per_second()) * _session->frames_per_timecode_frame());
- framepos_t one_timecode_minute = (framepos_t)(rint(_session->timecode_frames_per_second()) * _session->frames_per_timecode_frame() * 60);
+ framepos_t start = pos.frame;
+ const framepos_t one_timecode_second = (framepos_t)(rint(_session->timecode_frames_per_second()) * _session->samples_per_timecode_frame());
+ framepos_t one_timecode_minute = (framepos_t)(rint(_session->timecode_frames_per_second()) * _session->samples_per_timecode_frame() * 60);
switch (_snap_type) {
case SnapToTimecodeFrame:
if ((direction == RoundUpMaybe || direction == RoundDownMaybe) &&
- fmod((double)start, (double)_session->frames_per_timecode_frame()) == 0) {
+ fmod((double)start, (double)_session->samples_per_timecode_frame()) == 0) {
/* start is already on a whole timecode frame, do nothing */
- } else if (((direction == 0) && (fmod((double)start, (double)_session->frames_per_timecode_frame()) > (_session->frames_per_timecode_frame() / 2))) || (direction > 0)) {
- start = (framepos_t) (ceil ((double) start / _session->frames_per_timecode_frame()) * _session->frames_per_timecode_frame());
+ } else if (((direction == 0) && (fmod((double)start, (double)_session->samples_per_timecode_frame()) > (_session->samples_per_timecode_frame() / 2))) || (direction > 0)) {
+ start = (framepos_t) (ceil ((double) start / _session->samples_per_timecode_frame()) * _session->samples_per_timecode_frame());
} else {
- start = (framepos_t) (floor ((double) start / _session->frames_per_timecode_frame()) * _session->frames_per_timecode_frame());
+ start = (framepos_t) (floor ((double) start / _session->samples_per_timecode_frame()) * _session->samples_per_timecode_frame());
}
break;
fatal << "Editor::smpte_snap_to_internal() called with non-timecode snap type!" << endmsg;
abort(); /*NOTREACHED*/
}
+
+ pos.set (start, 0);
}
void
-Editor::snap_to_internal (framepos_t& start, RoundMode direction, bool for_mark, bool ensure_snap)
+Editor::snap_to_internal (MusicFrame& start, RoundMode direction, bool for_mark, bool ensure_snap)
{
const framepos_t one_second = _session->frame_rate();
const framepos_t one_minute = _session->frame_rate() * 60;
- framepos_t presnap = start;
+ framepos_t presnap = start.frame;
framepos_t before;
framepos_t after;
case SnapToCDFrame:
if ((direction == RoundUpMaybe || direction == RoundDownMaybe) &&
- start % (one_second/75) == 0) {
+ start.frame % (one_second/75) == 0) {
/* start is already on a whole CD frame, do nothing */
- } else if (((direction == 0) && (start % (one_second/75) > (one_second/75) / 2)) || (direction > 0)) {
- start = (framepos_t) ceil ((double) start / (one_second / 75)) * (one_second / 75);
+ } else if (((direction == 0) && (start.frame % (one_second/75) > (one_second/75) / 2)) || (direction > 0)) {
+ start.frame = (framepos_t) ceil ((double) start.frame / (one_second / 75)) * (one_second / 75);
} else {
- start = (framepos_t) floor ((double) start / (one_second / 75)) * (one_second / 75);
+ start.frame = (framepos_t) floor ((double) start.frame / (one_second / 75)) * (one_second / 75);
}
+
+ start.set (start.frame, 0);
+
break;
case SnapToSeconds:
if ((direction == RoundUpMaybe || direction == RoundDownMaybe) &&
- start % one_second == 0) {
+ start.frame % one_second == 0) {
/* start is already on a whole second, do nothing */
- } else if (((direction == 0) && (start % one_second > one_second / 2)) || (direction > 0)) {
- start = (framepos_t) ceil ((double) start / one_second) * one_second;
+ } else if (((direction == 0) && (start.frame % one_second > one_second / 2)) || (direction > 0)) {
+ start.frame = (framepos_t) ceil ((double) start.frame / one_second) * one_second;
} else {
- start = (framepos_t) floor ((double) start / one_second) * one_second;
+ start.frame = (framepos_t) floor ((double) start.frame / one_second) * one_second;
}
+
+ start.set (start.frame, 0);
+
break;
case SnapToMinutes:
if ((direction == RoundUpMaybe || direction == RoundDownMaybe) &&
- start % one_minute == 0) {
+ start.frame % one_minute == 0) {
/* start is already on a whole minute, do nothing */
- } else if (((direction == 0) && (start % one_minute > one_minute / 2)) || (direction > 0)) {
- start = (framepos_t) ceil ((double) start / one_minute) * one_minute;
+ } else if (((direction == 0) && (start.frame % one_minute > one_minute / 2)) || (direction > 0)) {
+ start.frame = (framepos_t) ceil ((double) start.frame / one_minute) * one_minute;
} else {
- start = (framepos_t) floor ((double) start / one_minute) * one_minute;
+ start.frame = (framepos_t) floor ((double) start.frame / one_minute) * one_minute;
}
+
+ start.set (start.frame, 0);
+
break;
case SnapToBar:
- start = _session->tempo_map().round_to_bar (start, direction);
+ start = _session->tempo_map().round_to_bar (start.frame, direction);
break;
case SnapToBeat:
- start = _session->tempo_map().round_to_beat (start, direction);
+ start = _session->tempo_map().round_to_beat (start.frame, direction);
break;
case SnapToBeatDiv128:
- start = _session->tempo_map().round_to_beat_subdivision (start, 128, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 128, direction);
break;
case SnapToBeatDiv64:
- start = _session->tempo_map().round_to_beat_subdivision (start, 64, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 64, direction);
break;
case SnapToBeatDiv32:
- start = _session->tempo_map().round_to_beat_subdivision (start, 32, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 32, direction);
break;
case SnapToBeatDiv28:
- start = _session->tempo_map().round_to_beat_subdivision (start, 28, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 28, direction);
break;
case SnapToBeatDiv24:
- start = _session->tempo_map().round_to_beat_subdivision (start, 24, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 24, direction);
break;
case SnapToBeatDiv20:
- start = _session->tempo_map().round_to_beat_subdivision (start, 20, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 20, direction);
break;
case SnapToBeatDiv16:
- start = _session->tempo_map().round_to_beat_subdivision (start, 16, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 16, direction);
break;
case SnapToBeatDiv14:
- start = _session->tempo_map().round_to_beat_subdivision (start, 14, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 14, direction);
break;
case SnapToBeatDiv12:
- start = _session->tempo_map().round_to_beat_subdivision (start, 12, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 12, direction);
break;
case SnapToBeatDiv10:
- start = _session->tempo_map().round_to_beat_subdivision (start, 10, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 10, direction);
break;
case SnapToBeatDiv8:
- start = _session->tempo_map().round_to_beat_subdivision (start, 8, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 8, direction);
break;
case SnapToBeatDiv7:
- start = _session->tempo_map().round_to_beat_subdivision (start, 7, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 7, direction);
break;
case SnapToBeatDiv6:
- start = _session->tempo_map().round_to_beat_subdivision (start, 6, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 6, direction);
break;
case SnapToBeatDiv5:
- start = _session->tempo_map().round_to_beat_subdivision (start, 5, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 5, direction);
break;
case SnapToBeatDiv4:
- start = _session->tempo_map().round_to_beat_subdivision (start, 4, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 4, direction);
break;
case SnapToBeatDiv3:
- start = _session->tempo_map().round_to_beat_subdivision (start, 3, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 3, direction);
break;
case SnapToBeatDiv2:
- start = _session->tempo_map().round_to_beat_subdivision (start, 2, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 2, direction);
break;
case SnapToMark:
return;
}
- _session->locations()->marks_either_side (start, before, after);
+ _session->locations()->marks_either_side (start.frame, before, after);
if (before == max_framepos && after == max_framepos) {
/* No marks to snap to, so just don't snap */
return;
} else if (before == max_framepos) {
- start = after;
+ start.frame = after;
} else if (after == max_framepos) {
- start = before;
+ start.frame = before;
} else if (before != max_framepos && after != max_framepos) {
- /* have before and after */
- if ((start - before) < (after - start)) {
- start = before;
- } else {
- start = after;
+ if ((direction == RoundUpMaybe || direction == RoundUpAlways))
+ start.frame = after;
+ else if ((direction == RoundDownMaybe || direction == RoundDownAlways))
+ start.frame = before;
+ else if (direction == 0 ) {
+ if ((start.frame - before) < (after - start.frame)) {
+ start.frame = before;
+ } else {
+ start.frame = after;
+ }
}
}
+ start.set (start.frame, 0);
+
break;
case SnapToRegionStart:
vector<framepos_t>::iterator next = region_boundary_cache.end ();
if (direction > 0) {
- next = std::upper_bound (region_boundary_cache.begin(), region_boundary_cache.end(), start);
+ next = std::upper_bound (region_boundary_cache.begin(), region_boundary_cache.end(), start.frame);
} else {
- next = std::lower_bound (region_boundary_cache.begin(), region_boundary_cache.end(), start);
+ next = std::lower_bound (region_boundary_cache.begin(), region_boundary_cache.end(), start.frame);
}
if (next != region_boundary_cache.begin ()) {
framepos_t const p = (prev == region_boundary_cache.end()) ? region_boundary_cache.front () : *prev;
framepos_t const n = (next == region_boundary_cache.end()) ? region_boundary_cache.back () : *next;
- if (start > (p + n) / 2) {
- start = n;
+ if (start.frame > (p + n) / 2) {
+ start.frame = n;
} else {
- start = p;
+ start.frame = p;
}
}
+
+ start.set (start.frame, 0);
+
break;
}
return;
}
- if (presnap > start) {
- if (presnap > (start + pixel_to_sample(snap_threshold))) {
- start = presnap;
+ if (presnap > start.frame) {
+ if (presnap > (start.frame + pixel_to_sample(snap_threshold))) {
+ start.set (presnap, 0);
}
- } else if (presnap < start) {
- if (presnap < (start - pixel_to_sample(snap_threshold))) {
- start = presnap;
+ } else if (presnap < start.frame) {
+ if (presnap < (start.frame - pixel_to_sample(snap_threshold))) {
+ start.set (presnap, 0);
}
}
default:
/* handled at entry */
return;
-
}
}
mouse_mode_size_group->add_widget (mouse_draw_button);
mouse_mode_size_group->add_widget (mouse_content_button);
- mouse_mode_size_group->add_widget (zoom_in_button);
- mouse_mode_size_group->add_widget (zoom_out_button);
- mouse_mode_size_group->add_widget (zoom_preset_selector);
- mouse_mode_size_group->add_widget (zoom_out_full_button);
- mouse_mode_size_group->add_widget (zoom_focus_selector);
-
- mouse_mode_size_group->add_widget (tav_shrink_button);
- mouse_mode_size_group->add_widget (tav_expand_button);
- mouse_mode_size_group->add_widget (visible_tracks_selector);
+ if (!Profile->get_mixbus()) {
+ mouse_mode_size_group->add_widget (zoom_in_button);
+ mouse_mode_size_group->add_widget (zoom_out_button);
+ mouse_mode_size_group->add_widget (zoom_out_full_button);
+ mouse_mode_size_group->add_widget (zoom_focus_selector);
+ mouse_mode_size_group->add_widget (tav_shrink_button);
+ mouse_mode_size_group->add_widget (tav_expand_button);
+ } else {
+ mouse_mode_size_group->add_widget (zoom_preset_selector);
+ mouse_mode_size_group->add_widget (visible_tracks_selector);
+ }
mouse_mode_size_group->add_widget (snap_type_selector);
mouse_mode_size_group->add_widget (snap_mode_selector);
if (!ARDOUR::Profile->get_mixbus()) {
mouse_mode_hbox->pack_start (mouse_cut_button, false, false);
}
-
+
if (!ARDOUR::Profile->get_trx()) {
mouse_mode_hbox->pack_start (mouse_timefx_button, false, false);
mouse_mode_hbox->pack_start (mouse_audition_button, false, false);
if (!ARDOUR::Profile->get_trx()) {
mode_box->pack_start (edit_mode_selector, false, false);
}
- mode_box->pack_start (*mouse_mode_box, false, false);
-
- _mouse_mode_tearoff = manage (new TearOff (*mode_box));
- _mouse_mode_tearoff->set_name ("MouseModeBase");
- _mouse_mode_tearoff->tearoff_window().signal_key_press_event().connect (sigc::bind (sigc::ptr_fun (relay_key_press), &_mouse_mode_tearoff->tearoff_window()), false);
-
- if (Profile->get_sae() || Profile->get_mixbus() ) {
- _mouse_mode_tearoff->set_can_be_torn_off (false);
- }
- _mouse_mode_tearoff->Detach.connect (sigc::bind (sigc::mem_fun(*this, &Editor::detach_tearoff), static_cast<Box*>(&toolbar_hbox),
- &_mouse_mode_tearoff->tearoff_window()));
- _mouse_mode_tearoff->Attach.connect (sigc::bind (sigc::mem_fun(*this, &Editor::reattach_tearoff), static_cast<Box*> (&toolbar_hbox),
- &_mouse_mode_tearoff->tearoff_window(), 1));
- _mouse_mode_tearoff->Hidden.connect (sigc::bind (sigc::mem_fun(*this, &Editor::detach_tearoff), static_cast<Box*>(&toolbar_hbox),
- &_mouse_mode_tearoff->tearoff_window()));
- _mouse_mode_tearoff->Visible.connect (sigc::bind (sigc::mem_fun(*this, &Editor::reattach_tearoff), static_cast<Box*> (&toolbar_hbox),
- &_mouse_mode_tearoff->tearoff_window(), 1));
+ mode_box->pack_start (*mouse_mode_box, false, false);
/* Zoom */
RefPtr<Action> act;
zoom_preset_selector.set_name ("zoom button");
- zoom_preset_selector.set_image(::get_icon ("time_exp"));
- zoom_preset_selector.set_size_request (42, -1);
+ zoom_preset_selector.set_icon (ArdourIcon::ZoomExpand);
zoom_in_button.set_name ("zoom button");
- zoom_in_button.set_image(::get_icon ("zoom_in"));
+ zoom_in_button.set_icon (ArdourIcon::ZoomIn);
act = ActionManager::get_action (X_("Editor"), X_("temporal-zoom-in"));
zoom_in_button.set_related_action (act);
zoom_out_button.set_name ("zoom button");
- zoom_out_button.set_image(::get_icon ("zoom_out"));
+ zoom_out_button.set_icon (ArdourIcon::ZoomOut);
act = ActionManager::get_action (X_("Editor"), X_("temporal-zoom-out"));
zoom_out_button.set_related_action (act);
zoom_out_full_button.set_name ("zoom button");
- zoom_out_full_button.set_image(::get_icon ("zoom_full"));
+ zoom_out_full_button.set_icon (ArdourIcon::ZoomFull);
act = ActionManager::get_action (X_("Editor"), X_("zoom-to-session"));
zoom_out_full_button.set_related_action (act);
}
/* Track zoom buttons */
+ _track_box.set_spacing (2);
+ _track_box.set_border_width (2);
+
visible_tracks_selector.set_name ("zoom button");
if (Profile->get_mixbus()) {
- visible_tracks_selector.set_image(::get_icon ("tav_exp"));
- visible_tracks_selector.set_size_request (42, -1);
+ visible_tracks_selector.set_icon (ArdourIcon::TimeAxisExpand);
} else {
set_size_request_to_display_given_text (visible_tracks_selector, _("All"), 30, 2);
}
tav_expand_button.set_name ("zoom button");
- tav_expand_button.set_image(::get_icon ("tav_exp"));
+ tav_expand_button.set_icon (ArdourIcon::TimeAxisExpand);
act = ActionManager::get_action (X_("Editor"), X_("expand-tracks"));
tav_expand_button.set_related_action (act);
tav_shrink_button.set_name ("zoom button");
- tav_shrink_button.set_image(::get_icon ("tav_shrink"));
+ tav_shrink_button.set_icon (ArdourIcon::TimeAxisShrink);
act = ActionManager::get_action (X_("Editor"), X_("shrink-tracks"));
tav_shrink_button.set_related_action (act);
if (ARDOUR::Profile->get_mixbus()) {
- _zoom_box.pack_start (visible_tracks_selector);
+ _track_box.pack_start (visible_tracks_selector);
} else if (ARDOUR::Profile->get_trx()) {
- _zoom_box.pack_start (tav_shrink_button);
- _zoom_box.pack_start (tav_expand_button);
+ _track_box.pack_start (tav_shrink_button);
+ _track_box.pack_start (tav_expand_button);
} else {
- _zoom_box.pack_start (visible_tracks_selector);
- _zoom_box.pack_start (tav_shrink_button);
- _zoom_box.pack_start (tav_expand_button);
- }
-
- if (!ARDOUR::Profile->get_trx()) {
- _zoom_tearoff = manage (new TearOff (_zoom_box));
-
- _zoom_tearoff->Detach.connect (sigc::bind (sigc::mem_fun(*this, &Editor::detach_tearoff), static_cast<Box*>(&toolbar_hbox),
- &_zoom_tearoff->tearoff_window()));
- _zoom_tearoff->Attach.connect (sigc::bind (sigc::mem_fun(*this, &Editor::reattach_tearoff), static_cast<Box*> (&toolbar_hbox),
- &_zoom_tearoff->tearoff_window(), 0));
- _zoom_tearoff->Hidden.connect (sigc::bind (sigc::mem_fun(*this, &Editor::detach_tearoff), static_cast<Box*>(&toolbar_hbox),
- &_zoom_tearoff->tearoff_window()));
- _zoom_tearoff->Visible.connect (sigc::bind (sigc::mem_fun(*this, &Editor::reattach_tearoff), static_cast<Box*> (&toolbar_hbox),
- &_zoom_tearoff->tearoff_window(), 0));
- }
-
- if (Profile->get_sae() || Profile->get_mixbus() ) {
- _zoom_tearoff->set_can_be_torn_off (false);
+ _track_box.pack_start (visible_tracks_selector);
+ _track_box.pack_start (tav_shrink_button);
+ _track_box.pack_start (tav_expand_button);
}
snap_box.set_spacing (2);
snap_box.pack_start (snap_mode_selector, false, false);
snap_box.pack_start (snap_type_selector, false, false);
- snap_box.pack_start (edit_point_selector, false, false);
+
+ /* Edit Point*/
+ HBox *ep_box = manage (new HBox);
+ ep_box->set_spacing (2);
+ ep_box->set_border_width (2);
+
+ ep_box->pack_start (edit_point_selector, false, false);
/* Nudge */
/* Pack everything in... */
- HBox* hbox = manage (new HBox);
- hbox->set_spacing(2);
+ toolbar_hbox.set_spacing (2);
+ toolbar_hbox.set_border_width (2);
- _tools_tearoff = manage (new TearOff (*hbox));
- _tools_tearoff->set_name ("MouseModeBase");
- _tools_tearoff->tearoff_window().signal_key_press_event().connect (sigc::bind (sigc::ptr_fun (relay_key_press), &_tools_tearoff->tearoff_window()), false);
+ toolbar_hbox.pack_start (*mode_box, false, false);
- if (Profile->get_sae() || Profile->get_mixbus()) {
- _tools_tearoff->set_can_be_torn_off (false);
- }
+ if (!ARDOUR::Profile->get_trx()) {
- _tools_tearoff->Detach.connect (sigc::bind (sigc::mem_fun(*this, &Editor::detach_tearoff), static_cast<Box*>(&toolbar_hbox),
- &_tools_tearoff->tearoff_window()));
- _tools_tearoff->Attach.connect (sigc::bind (sigc::mem_fun(*this, &Editor::reattach_tearoff), static_cast<Box*> (&toolbar_hbox),
- &_tools_tearoff->tearoff_window(), 0));
- _tools_tearoff->Hidden.connect (sigc::bind (sigc::mem_fun(*this, &Editor::detach_tearoff), static_cast<Box*>(&toolbar_hbox),
- &_tools_tearoff->tearoff_window()));
- _tools_tearoff->Visible.connect (sigc::bind (sigc::mem_fun(*this, &Editor::reattach_tearoff), static_cast<Box*> (&toolbar_hbox),
- &_tools_tearoff->tearoff_window(), 0));
+ toolbar_hbox.pack_start (*(manage (new ArdourVSpacer ())), false, false, 3);
- toolbar_hbox.set_spacing (2);
- toolbar_hbox.set_border_width (1);
+ toolbar_hbox.pack_start (_zoom_box, false, false);
- toolbar_hbox.pack_start (*_mouse_mode_tearoff, false, false);
- if (!ARDOUR::Profile->get_trx()) {
- toolbar_hbox.pack_start (*_zoom_tearoff, false, false);
- toolbar_hbox.pack_start (*_tools_tearoff, false, false);
- }
+ toolbar_hbox.pack_start (*(manage (new ArdourVSpacer ())), false, false, 3);
- if (!ARDOUR::Profile->get_trx()) {
- hbox->pack_start (snap_box, false, false);
- if ( !Profile->get_small_screen() || Profile->get_mixbus() ) {
- hbox->pack_start (*nudge_box, false, false);
- } else {
- ARDOUR_UI::instance()->editor_transport_box().pack_start (*nudge_box, false, false);
- }
- }
- hbox->pack_start (panic_box, false, false);
+ toolbar_hbox.pack_start (_track_box, false, false);
+
+ toolbar_hbox.pack_start (*(manage (new ArdourVSpacer ())), false, false, 3);
- hbox->show_all ();
+ toolbar_hbox.pack_start (snap_box, false, false);
- toolbar_base.set_name ("ToolBarBase");
- toolbar_base.add (toolbar_hbox);
+ toolbar_hbox.pack_start (*(manage (new ArdourVSpacer ())), false, false, 3);
- _toolbar_viewport.add (toolbar_base);
- /* stick to the required height but allow width to vary if there's not enough room */
- _toolbar_viewport.set_size_request (1, -1);
+ toolbar_hbox.pack_start (*ep_box, false, false);
- toolbar_frame.set_shadow_type (SHADOW_OUT);
- toolbar_frame.set_name ("BaseFrame");
- toolbar_frame.add (_toolbar_viewport);
+ toolbar_hbox.pack_start (*(manage (new ArdourVSpacer ())), false, false, 3);
+
+ toolbar_hbox.pack_start (*nudge_box, false, false);
+ }
+
+ toolbar_hbox.show_all ();
}
void
Editor::build_edit_mode_menu ()
{
using namespace Menu_Helpers;
-
+
edit_mode_selector.AddMenuElem (MenuElem ( edit_mode_strings[(int)Slide], sigc::bind (sigc::mem_fun(*this, &Editor::edit_mode_selection_done), (EditMode) Slide)));
// edit_mode_selector.AddMenuElem (MenuElem ( edit_mode_strings[(int)Splice], sigc::bind (sigc::mem_fun(*this, &Editor::edit_mode_selection_done), (EditMode) Splice)));
edit_mode_selector.AddMenuElem (MenuElem ( edit_mode_strings[(int)Ripple], sigc::bind (sigc::mem_fun(*this, &Editor::edit_mode_selection_done), (EditMode) Ripple)));
void
Editor::setup_tooltips ()
{
- ARDOUR_UI::instance()->set_tip (smart_mode_button, _("Smart Mode (add Range functions to Grab mode)"));
- ARDOUR_UI::instance()->set_tip (mouse_move_button, _("Grab Mode (select/move objects)"));
- ARDOUR_UI::instance()->set_tip (mouse_cut_button, _("Cut Mode (split regions)"));
- ARDOUR_UI::instance()->set_tip (mouse_select_button, _("Range Mode (select time ranges)"));
- ARDOUR_UI::instance()->set_tip (mouse_draw_button, _("Draw Mode (draw and edit gain/notes/automation)"));
- ARDOUR_UI::instance()->set_tip (mouse_timefx_button, _("Stretch Mode (time-stretch audio and midi regions, preserving pitch)"));
- ARDOUR_UI::instance()->set_tip (mouse_audition_button, _("Audition Mode (listen to regions)"));
- ARDOUR_UI::instance()->set_tip (mouse_content_button, _("Internal Edit Mode (edit notes and gain curves inside regions)"));
- ARDOUR_UI::instance()->set_tip (*_group_tabs, _("Groups: click to (de)activate\nContext-click for other operations"));
- ARDOUR_UI::instance()->set_tip (nudge_forward_button, _("Nudge Region/Selection Later"));
- ARDOUR_UI::instance()->set_tip (nudge_backward_button, _("Nudge Region/Selection Earlier"));
- ARDOUR_UI::instance()->set_tip (zoom_in_button, _("Zoom In"));
- ARDOUR_UI::instance()->set_tip (zoom_out_button, _("Zoom Out"));
- ARDOUR_UI::instance()->set_tip (zoom_preset_selector, _("Zoom to Time Scale"));
- ARDOUR_UI::instance()->set_tip (zoom_out_full_button, _("Zoom to Session"));
- ARDOUR_UI::instance()->set_tip (zoom_focus_selector, _("Zoom focus"));
- ARDOUR_UI::instance()->set_tip (tav_expand_button, _("Expand Tracks"));
- ARDOUR_UI::instance()->set_tip (tav_shrink_button, _("Shrink Tracks"));
- ARDOUR_UI::instance()->set_tip (visible_tracks_selector, _("Number of visible tracks"));
- ARDOUR_UI::instance()->set_tip (snap_type_selector, _("Snap/Grid Units"));
- ARDOUR_UI::instance()->set_tip (snap_mode_selector, _("Snap/Grid Mode"));
- ARDOUR_UI::instance()->set_tip (edit_point_selector, _("Edit point"));
- ARDOUR_UI::instance()->set_tip (edit_mode_selector, _("Edit Mode"));
- ARDOUR_UI::instance()->set_tip (nudge_clock, _("Nudge Clock\n(controls distance used to nudge regions and selections)"));
+ set_tooltip (smart_mode_button, _("Smart Mode (add range functions to Grab Mode)"));
+ set_tooltip (mouse_move_button, _("Grab Mode (select/move objects)"));
+ set_tooltip (mouse_cut_button, _("Cut Mode (split regions)"));
+ set_tooltip (mouse_select_button, _("Range Mode (select time ranges)"));
+ set_tooltip (mouse_draw_button, _("Draw Mode (draw and edit gain/notes/automation)"));
+ set_tooltip (mouse_timefx_button, _("Stretch Mode (time-stretch audio and midi regions, preserving pitch)"));
+ set_tooltip (mouse_audition_button, _("Audition Mode (listen to regions)"));
+ set_tooltip (mouse_content_button, _("Internal Edit Mode (edit notes and automation points)"));
+ set_tooltip (*_group_tabs, _("Groups: click to (de)activate\nContext-click for other operations"));
+ set_tooltip (nudge_forward_button, _("Nudge Region/Selection Later"));
+ set_tooltip (nudge_backward_button, _("Nudge Region/Selection Earlier"));
+ set_tooltip (zoom_in_button, _("Zoom In"));
+ set_tooltip (zoom_out_button, _("Zoom Out"));
+ set_tooltip (zoom_preset_selector, _("Zoom to Time Scale"));
+ set_tooltip (zoom_out_full_button, _("Zoom to Session"));
+ set_tooltip (zoom_focus_selector, _("Zoom Focus"));
+ set_tooltip (tav_expand_button, _("Expand Tracks"));
+ set_tooltip (tav_shrink_button, _("Shrink Tracks"));
+ set_tooltip (visible_tracks_selector, _("Number of visible tracks"));
+ set_tooltip (snap_type_selector, _("Snap/Grid Units"));
+ set_tooltip (snap_mode_selector, _("Snap/Grid Mode"));
+ set_tooltip (edit_point_selector, _("Edit Point"));
+ set_tooltip (edit_mode_selector, _("Edit Mode"));
+ set_tooltip (nudge_clock, _("Nudge Clock\n(controls distance used to nudge regions and selections)"));
}
int
update_loop_range_view ();
}
+void
+Editor::transport_looped ()
+{
+ /* reset Playhead position interpolation.
+ * see Editor::super_rapid_screen_update
+ */
+ _last_update_time = 0;
+}
+
/* UNDO/REDO */
void
The user has undone some selection ops and then made a new one,
making anything earlier in the list invalid.
*/
-
+
list<XMLNode *>::iterator it = selection_op_history.begin();
list<XMLNode *>::iterator e_it = it;
advance (e_it, selection_op_history_it);
-
+
for ( ; it != e_it; ++it) {
delete *it;
}
if (redo_action && _session) {
if (_session->redo_depth() == 0) {
label = _("Redo");
+ redo_action->set_sensitive (false);
} else {
label = string_compose(_("Redo (%1)"), _session->next_redo());
+ redo_action->set_sensitive (true);
}
redo_action->property_label() = label;
}
} else if (get_smart_mode()) {
if (selection->time.length()) {
duplicate_selection (times);
- } else
+ } else
duplicate_some_regions (rs, times);
} else {
duplicate_some_regions (rs, times);
{
switch (Config->get_edit_mode()) {
case Slide:
- if (Profile->get_sae()) {
- Config->set_edit_mode (Lock);
- } else {
- Config->set_edit_mode (Ripple);
- }
+ Config->set_edit_mode (Ripple);
break;
case Splice:
case Ripple:
zoom_preset_selector.AddMenuElem (MenuElem (_("Zoom to 8 hours"), sigc::bind (sigc::mem_fun(*this, &Editor::set_zoom_preset), 8 * 60 * 60 * 1000)));
zoom_preset_selector.AddMenuElem (MenuElem (_("Zoom to 24 hours"), sigc::bind (sigc::mem_fun(*this, &Editor::set_zoom_preset), 24 * 60 * 60 * 1000)));
zoom_preset_selector.AddMenuElem (MenuElem (_("Zoom to Session"), sigc::mem_fun(*this, &Editor::temporal_zoom_session)));
- zoom_preset_selector.AddMenuElem (MenuElem (_("Zoom to Range/Region Selection"), sigc::bind (sigc::mem_fun(*this, &Editor::temporal_zoom_selection), false)));
+ zoom_preset_selector.AddMenuElem (MenuElem (_("Zoom to Range/Region Selection"), sigc::bind (sigc::mem_fun(*this, &Editor::temporal_zoom_selection), Horizontal)));
}
}
temporal_zoom_session();
return;
}
-
+
ARDOUR::framecnt_t const sample_rate = ARDOUR::AudioEngine::instance()->sample_rate();
temporal_zoom( (sample_rate * ms / 1000) / _visible_canvas_width );
}
allocation happens, we will get called again and then we can do the
real work.
*/
-
+
if (_visible_canvas_height <= 1) {
return;
}
int h;
string str;
DisplaySuspender ds;
-
+
if (_visible_track_count > 0) {
h = trackviews_height() / _visible_track_count;
std::ostringstream s;
str = s.str();
} else if (_visible_track_count == 0) {
uint32_t n = 0;
- for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
+ for (TrackViewList::const_iterator i = track_views.begin(); i != track_views.end(); ++i) {
if ((*i)->marked_for_display()) {
++n;
+ TimeAxisView::Children cl ((*i)->get_child_list ());
+ for (TimeAxisView::Children::const_iterator j = cl.begin(); j != cl.end(); ++j) {
+ if ((*j)->marked_for_display()) {
+ ++n;
+ }
+ }
}
}
+ if (n == 0) {
+ visible_tracks_selector.set_text (X_("*"));
+ return;
+ }
h = trackviews_height() / n;
str = _("All");
} else {
- /* negative value means that the visible track count has
+ /* negative value means that the visible track count has
been overridden by explicit track height changes.
*/
visible_tracks_selector.set_text (X_("*"));
for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
(*i)->set_height (h, TimeAxisView::HeightPerLane);
}
-
+
if (str != visible_tracks_selector.get_text()) {
visible_tracks_selector.set_text (str);
}
Editor::edit_controls_button_release (GdkEventButton* ev)
{
if (Keyboard::is_context_menu_event (ev)) {
- ARDOUR_UI::instance()->add_route (this);
+ ARDOUR_UI::instance()->add_route ();
} else if (ev->button == 1) {
selection->clear_tracks ();
}
}
}
-void
-Editor::ensure_float (Window& win)
-{
- win.set_transient_for (*this);
-}
-
-void
-Editor::pane_allocation_handler (Allocation &alloc, Paned* which)
-{
- /* recover or initialize pane positions. do this here rather than earlier because
- we don't want the positions to change the child allocations, which they seem to do.
- */
-
- int pos;
- XMLProperty* prop;
- char buf[32];
- XMLNode* node = ARDOUR_UI::instance()->editor_settings();
-
- enum Pane {
- Horizontal = 0x1,
- Vertical = 0x2
- };
-
- static Pane done;
-
- XMLNode* geometry = find_named_node (*node, "geometry");
-
- if (which == static_cast<Paned*> (&edit_pane)) {
-
- if (done & Horizontal) {
- return;
- }
-
- if (geometry && (prop = geometry->property ("notebook-shrunk"))) {
- _notebook_shrunk = string_is_affirmative (prop->value ());
- }
-
- if (!geometry || (prop = geometry->property ("edit-horizontal-pane-pos")) == 0) {
- /* initial allocation is 90% to canvas, 10% to notebook */
- pos = (int) floor (alloc.get_width() * 0.90f);
- snprintf (buf, sizeof(buf), "%d", pos);
- } else {
- pos = atoi (prop->value());
- }
-
- if (GTK_WIDGET(edit_pane.gobj())->allocation.width > pos) {
- edit_pane.set_position (pos);
- }
-
- done = (Pane) (done | Horizontal);
-
- } else if (which == static_cast<Paned*> (&editor_summary_pane)) {
-
- if (done & Vertical) {
- return;
- }
-
- if (!geometry || (prop = geometry->property ("edit-vertical-pane-pos")) == 0) {
- /* initial allocation is 90% to canvas, 10% to summary */
- pos = (int) floor (alloc.get_height() * 0.90f);
- snprintf (buf, sizeof(buf), "%d", pos);
- } else {
-
- pos = atoi (prop->value());
- }
-
- if (GTK_WIDGET(editor_summary_pane.gobj())->allocation.height > pos) {
- editor_summary_pane.set_position (pos);
- }
-
- done = (Pane) (done | Vertical);
- }
-}
-
-void
-Editor::detach_tearoff (Box* /*b*/, Window* /*w*/)
-{
- if ((_tools_tearoff->torn_off() || !_tools_tearoff->visible()) &&
- (_mouse_mode_tearoff->torn_off() || !_mouse_mode_tearoff->visible()) &&
- (_zoom_tearoff && (_zoom_tearoff->torn_off() || !_zoom_tearoff->visible()))) {
- top_hbox.remove (toolbar_frame);
- }
-}
-
-void
-Editor::reattach_tearoff (Box* /*b*/, Window* /*w*/, int32_t /*n*/)
-{
- if (toolbar_frame.get_parent() == 0) {
- top_hbox.pack_end (toolbar_frame);
- }
-}
-
void
Editor::set_show_measures (bool yn)
{
tempo_lines->show();
}
- ARDOUR::TempoMap::BBTPointList::const_iterator begin;
- ARDOUR::TempoMap::BBTPointList::const_iterator end;
-
- compute_current_bbt_points (leftmost_frame, leftmost_frame + current_page_samples(), begin, end);
- draw_measures (begin, end);
- }
+ std::vector<TempoMap::BBTPoint> grid;
+ compute_current_bbt_points (grid, leftmost_frame, leftmost_frame + current_page_samples());
+ draw_measures (grid);
+ }
instant_save ();
}
framecnt_t offset = paste_count * duration;
/* snap offset so pos + offset is aligned to the grid */
- framepos_t offset_pos = pos + offset;
+ MusicFrame offset_pos (pos + offset, 0);
snap_to(offset_pos, RoundUpMaybe);
- offset = offset_pos - pos;
+ offset = offset_pos.frame - pos;
return offset;
}
return 0;
}
+/** returns the current musical grid divisiions using the supplied modifier mask from a GtkEvent.
+ if the grid is non-musical, returns 0.
+ if the grid is snapped to bars, returns -1.
+ @param event_state the current keyboard modifier mask.
+*/
+int32_t
+Editor::get_grid_music_divisions (uint32_t event_state)
+{
+ if (snap_mode() == Editing::SnapOff && !ArdourKeyboard::indicates_snap (event_state)) {
+ return 0;
+ }
+
+ if (snap_mode() != Editing::SnapOff && ArdourKeyboard::indicates_snap (event_state)) {
+ return 0;
+ }
+
+ switch (_snap_type) {
+ case SnapToBeatDiv128: return 128;
+ case SnapToBeatDiv64: return 64;
+ case SnapToBeatDiv32: return 32;
+ case SnapToBeatDiv28: return 28;
+ case SnapToBeatDiv24: return 24;
+ case SnapToBeatDiv20: return 20;
+ case SnapToBeatDiv16: return 16;
+ case SnapToBeatDiv14: return 14;
+ case SnapToBeatDiv12: return 12;
+ case SnapToBeatDiv10: return 10;
+ case SnapToBeatDiv8: return 8;
+ case SnapToBeatDiv7: return 7;
+ case SnapToBeatDiv6: return 6;
+ case SnapToBeatDiv5: return 5;
+ case SnapToBeatDiv4: return 4;
+ case SnapToBeatDiv3: return 3;
+ case SnapToBeatDiv2: return 2;
+ case SnapToBeat: return 1;
+ case SnapToBar : return -1;
+ default: return 0;
+ }
+ return 0;
+}
+
Evoral::Beats
Editor::get_grid_type_as_beats (bool& success, framepos_t position)
{
switch (_snap_type) {
case SnapToBeat:
- return Evoral::Beats(1.0);
+ return Evoral::Beats(4.0 / _session->tempo_map().meter_at_frame (position).note_divisor());
case SnapToBar:
if (_session) {
- return Evoral::Beats(_session->tempo_map().meter_at (position).divisions_per_bar());
+ const Meter& m = _session->tempo_map().meter_at_frame (position);
+ return Evoral::Beats((4.0 * m.divisions_per_bar()) / m.note_divisor());
}
break;
default:
label.show ();
+ dialog.add_button (_("Delete All Unused"), RESPONSE_YES); // needs clarification. this and all remaining ones
dialog.add_button (_("Delete Playlist"), RESPONSE_ACCEPT);
- dialog.add_button (_("Keep Playlist"), RESPONSE_REJECT);
+ Button* keep = dialog.add_button (_("Keep Playlist"), RESPONSE_REJECT);
+ dialog.add_button (_("Keep Remaining"), RESPONSE_NO); // ditto
dialog.add_button (_("Cancel"), RESPONSE_CANCEL);
+ // by default gtk uses the left most button
+ keep->grab_focus ();
+
switch (dialog.run ()) {
+ case RESPONSE_NO:
+ /* keep this and all remaining ones */
+ return -2;
+ break;
+
+ case RESPONSE_YES:
+ /* delete this and all others */
+ return 2;
+ break;
+
case RESPONSE_ACCEPT:
/* delete the playlist */
- return 0;
+ return 1;
break;
case RESPONSE_REJECT:
/* keep the playlist */
- return 1;
+ return 0;
break;
default:
_snapshots->redisplay ();
}
-void
-Editor::update_tearoff_visibility()
-{
- bool visible = ARDOUR_UI::config()->get_keep_tearoffs();
- _mouse_mode_tearoff->set_visible (visible);
- _tools_tearoff->set_visible (visible);
- if (_zoom_tearoff) {
- _zoom_tearoff->set_visible (visible);
- }
-}
-
-void
-Editor::reattach_all_tearoffs ()
-{
- if (_mouse_mode_tearoff) _mouse_mode_tearoff->put_it_back ();
- if (_tools_tearoff) _tools_tearoff->put_it_back ();
- if (_zoom_tearoff) _zoom_tearoff->put_it_back ();
-}
-
void
Editor::maximise_editing_space ()
{
return;
}
- fullscreen ();
+ Gtk::Window* toplevel = current_toplevel();
- _maximised = true;
+ if (toplevel) {
+ toplevel->fullscreen ();
+ _maximised = true;
+ }
}
void
return;
}
- unfullscreen();
+ Gtk::Window* toplevel = current_toplevel();
- _maximised = false;
+ if (toplevel) {
+ toplevel->unfullscreen();
+ _maximised = false;
+ }
}
/**
begin_reversible_command (_("new playlists"));
vector<boost::shared_ptr<ARDOUR::Playlist> > playlists;
_session->playlists->get (playlists);
- mapover_tracks (sigc::bind (sigc::mem_fun (*this, &Editor::mapped_use_new_playlist), playlists), v, ARDOUR::Properties::select.property_id);
+ mapover_tracks (sigc::bind (sigc::mem_fun (*this, &Editor::mapped_use_new_playlist), playlists), v, ARDOUR::Properties::group_select.property_id);
commit_reversible_command ();
}
begin_reversible_command (_("copy playlists"));
vector<boost::shared_ptr<ARDOUR::Playlist> > playlists;
_session->playlists->get (playlists);
- mapover_tracks (sigc::bind (sigc::mem_fun (*this, &Editor::mapped_use_copy_playlist), playlists), v, ARDOUR::Properties::select.property_id);
+ mapover_tracks (sigc::bind (sigc::mem_fun (*this, &Editor::mapped_use_copy_playlist), playlists), v, ARDOUR::Properties::group_select.property_id);
commit_reversible_command ();
}
void
Editor::clear_playlists (TimeAxisView* v)
{
- begin_reversible_command (_("clear playlists"));
+ begin_reversible_command (_("clear playlists"));
vector<boost::shared_ptr<ARDOUR::Playlist> > playlists;
_session->playlists->get (playlists);
- mapover_tracks (sigc::mem_fun (*this, &Editor::mapped_clear_playlist), v, ARDOUR::Properties::select.property_id);
+ mapover_tracks (sigc::mem_fun (*this, &Editor::mapped_clear_playlist), v, ARDOUR::Properties::group_select.property_id);
commit_reversible_command ();
}
void
Editor::mapped_use_new_playlist (RouteTimeAxisView& atv, uint32_t sz, vector<boost::shared_ptr<ARDOUR::Playlist> > const & playlists)
{
- atv.use_new_playlist (sz > 1 ? false : true, playlists);
+ atv.use_new_playlist (sz > 1 ? false : true, playlists, false);
}
void
Editor::mapped_use_copy_playlist (RouteTimeAxisView& atv, uint32_t sz, vector<boost::shared_ptr<ARDOUR::Playlist> > const & playlists)
{
- atv.use_copy_playlist (sz > 1 ? false : true, playlists);
+ atv.use_new_playlist (sz > 1 ? false : true, playlists, true);
}
void
atv.clear_playlist ();
}
-bool
-Editor::on_key_press_event (GdkEventKey* ev)
-{
- return key_press_focus_accelerator_handler (*this, ev);
-}
-
-bool
-Editor::on_key_release_event (GdkEventKey* ev)
-{
- return Gtk::Window::on_key_release_event (ev);
- // return key_press_focus_accelerator_handler (*this, ev);
-}
-
double
Editor::get_y_origin () const
{
vs->leftmost_frame = leftmost_frame;
vs->zoom_focus = zoom_focus;
- if (with_tracks) {
- *vs->gui_state = *ARDOUR_UI::instance()->gui_object_state;
+ if (with_tracks) {
+ vs->gui_state->set_state (ARDOUR_UI::instance()->gui_object_state->get_state());
}
return vs;
set_zoom_focus (vs.zoom_focus);
reposition_and_zoom (vs.leftmost_frame, vs.samples_per_pixel);
-
+
if (vs.gui_state) {
- *ARDOUR_UI::instance()->gui_object_state = *vs.gui_state;
-
- for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
+ ARDOUR_UI::instance()->gui_object_state->set_state (vs.gui_state->get_state());
+
+ for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
(*i)->clear_property_cache();
(*i)->reset_visual_state ();
}
}
samples_per_pixel = spp;
+}
+void
+Editor::on_samples_per_pixel_changed ()
+{
if (tempo_lines) {
- tempo_lines->tempo_map_changed();
+ tempo_lines->tempo_map_changed(_session->tempo_map().music_origin());
}
bool const showing_time_selection = selection->time.length() > 0;
instant_save ();
}
+framepos_t
+Editor::playhead_cursor_sample () const
+{
+ return playhead_cursor->current_frame();
+}
+
void
Editor::queue_visual_videotimeline_update ()
{
- /* TODO:
- * pending_visual_change.add (VisualChange::VideoTimeline);
- * or maybe even more specific: which videotimeline-image
- * currently it calls update_video_timeline() to update
- * _all outdated_ images on the video-timeline.
- * see 'exposeimg()' in video_image_frame.cc
- */
+ pending_visual_change.add (VisualChange::VideoTimeline);
ensure_visual_change_idle_handler ();
}
return static_cast<Editor*>(arg)->idle_visual_changer ();
}
+void
+Editor::pre_render ()
+{
+ visual_change_queued = false;
+
+ if (pending_visual_change.pending != 0) {
+ ensure_visual_change_idle_handler();
+ }
+}
+
int
Editor::idle_visual_changer ()
{
+ pending_visual_change.idle_handler_id = -1;
+
+ if (pending_visual_change.pending == 0) {
+ return 0;
+ }
+
/* set_horizontal_position() below (and maybe other calls) call
gtk_main_iteration(), so it's possible that a signal will be handled
half-way through this method. If this signal wants an
the last one.
*/
- pending_visual_change.idle_handler_id = -1;
+ if (visual_change_queued) {
+ return 0;
+ }
+
pending_visual_change.being_handled = true;
-
+
VisualChange vc = pending_visual_change;
pending_visual_change.pending = (VisualChange::Type) 0;
pending_visual_change.being_handled = false;
+ visual_change_queued = true;
+
return 0; /* this is always a one-shot call */
}
void
Editor::visual_changer (const VisualChange& vc)
{
- double const last_time_origin = horizontal_position ();
-
+ /**
+ * Changed first so the correct horizontal canvas position is calculated in
+ * Editor::set_horizontal_position
+ */
if (vc.pending & VisualChange::ZoomLevel) {
set_samples_per_pixel (vc.samples_per_pixel);
-
- compute_fixed_ruler_scale ();
-
- ARDOUR::TempoMap::BBTPointList::const_iterator current_bbt_points_begin;
- ARDOUR::TempoMap::BBTPointList::const_iterator current_bbt_points_end;
-
- compute_current_bbt_points (vc.time_origin, pending_visual_change.time_origin + current_page_samples(),
- current_bbt_points_begin, current_bbt_points_end);
- compute_bbt_ruler_scale (vc.time_origin, pending_visual_change.time_origin + current_page_samples(),
- current_bbt_points_begin, current_bbt_points_end);
- update_tempo_based_rulers (current_bbt_points_begin, current_bbt_points_end);
-
- update_video_timeline();
}
if (vc.pending & VisualChange::TimeOrigin) {
- set_horizontal_position (vc.time_origin / samples_per_pixel);
+ double new_time_origin = sample_to_pixel_unrounded (vc.time_origin);
+ set_horizontal_position (new_time_origin);
}
if (vc.pending & VisualChange::YOrigin) {
vertical_adjustment.set_value (vc.y_origin);
}
- if (last_time_origin == horizontal_position ()) {
- /* changed signal not emitted */
- update_fixed_rulers ();
- redisplay_tempo (true);
+ /**
+ * Now the canvas is in the final state before render the canvas items that
+ * support the Item::prepare_for_render interface can calculate the correct
+ * item to visible canvas intersection.
+ */
+ if (vc.pending & VisualChange::ZoomLevel) {
+ on_samples_per_pixel_changed ();
+
+ compute_fixed_ruler_scale ();
+
+ compute_bbt_ruler_scale (vc.time_origin, pending_visual_change.time_origin + current_page_samples());
+ update_tempo_based_rulers ();
}
if (!(vc.pending & VisualChange::ZoomLevel)) {
+ /**
+ * If the canvas is not being zoomed then the canvas items will not change
+ * and cause Item::prepare_for_render to be called so do it here manually.
+ *
+ * Not ideal, but I can't think of a better solution atm.
+ */
+ _track_canvas->prepare_for_render();
+ }
+
+ // If we are only scrolling vertically there is no need to update these
+ if (vc.pending != VisualChange::YOrigin) {
+ update_fixed_rulers ();
+ redisplay_tempo (true);
+
+ /* video frames & position need to be updated for zoom, horiz-scroll
+ * and (explicitly) VisualChange::VideoTimeline.
+ */
update_video_timeline();
}
framepos_t where = 0;
EditPoint ep = _edit_point;
- if (Profile->get_mixbus())
- if (ep == EditAtSelectedMarker)
+ if (Profile->get_mixbus()) {
+ if (ep == EditAtSelectedMarker) {
ep = EditAtPlayhead;
+ }
+ }
if (from_outside_canvas && (ep == EditAtMouse)) {
ep = EditAtPlayhead;
} else if (from_context_menu && (ep == EditAtMouse)) {
- return canvas_event_sample (&context_click_event, 0, 0);
+ return canvas_event_sample (&context_click_event, 0, 0);
}
if (entered_marker) {
- DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("GPEP: use entered marker @ %1\n", entered_marker->position()));
+ DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("GPEP: use entered marker @ %1\n", entered_marker->position()));
return entered_marker->position();
}
ep = EditAtPlayhead;
}
+ MusicFrame snap_mf (0, 0);
+
switch (ep) {
case EditAtPlayhead:
- if (_dragging_playhead) {
- if (!mouse_frame (where, ignored)) {
- /* XXX not right but what can we do ? */
- return 0;
- }
+ if (_dragging_playhead && _control_scroll_target) {
+ where = *_control_scroll_target;
} else {
where = _session->audible_frame();
}
- DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("GPEP: use playhead @ %1\n", where));
+ DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("GPEP: use playhead @ %1\n", where));
break;
case EditAtSelectedMarker:
} else {
where = loc->end();
}
- DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("GPEP: use selected marker @ %1\n", where));
+ DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("GPEP: use selected marker @ %1\n", where));
break;
}
}
/* XXX not right but what can we do ? */
return 0;
}
- snap_to (where);
- DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("GPEP: use mouse @ %1\n", where));
+ snap_mf.frame = where;
+ snap_to (snap_mf);
+ where = snap_mf.frame;
+ DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("GPEP: use mouse @ %1\n", where));
break;
}
Location* tll;
if ((tll = transport_loop_location()) == 0) {
- Location* loc = new Location (*_session, start, end, _("Loop"), Location::IsAutoLoop);
+ Location* loc = new Location (*_session, start, end, _("Loop"), Location::IsAutoLoop, get_grid_music_divisions(0));
XMLNode &before = _session->locations()->get_state();
_session->locations()->add (loc, true);
_session->set_auto_loop_location (loc);
Location* tpl;
if ((tpl = transport_punch_location()) == 0) {
- Location* loc = new Location (*_session, start, end, _("Punch"), Location::IsAutoPunch);
+ Location* loc = new Location (*_session, start, end, _("Punch"), Location::IsAutoPunch, get_grid_music_divisions(0));
XMLNode &before = _session->locations()->get_state();
_session->locations()->add (loc, true);
_session->set_auto_punch_location (loc);
*/
RegionSelection
-Editor::get_regions_from_selection_and_edit_point ()
+Editor::get_regions_from_selection_and_edit_point (EditIgnoreOption ignore, bool from_context_menu, bool from_outside_canvas)
{
RegionSelection regions;
if (!tracks.empty()) {
/* no region selected or entered, but some selected tracks:
* act on all regions on the selected tracks at the edit point
- */
- framepos_t const where = get_preferred_edit_position ();
+ */
+ framepos_t const where = get_preferred_edit_position (ignore, from_context_menu, from_outside_canvas);
get_regions_at(regions, where, tracks);
}
}
if (!tracks.empty()) {
/* no region selected or entered, but some selected tracks:
* act on all regions on the selected tracks at the edit point
- */
+ */
get_regions_at(regions, pos, tracks);
}
}
*/
RegionSelection
-Editor::get_regions_from_selection_and_entered ()
+Editor::get_regions_from_selection_and_entered () const
{
RegionSelection regions = selection->regions;
{
for (TrackViewList::const_iterator i = track_views.begin(); i != track_views.end(); ++i) {
RouteTimeAxisView* rtav;
-
+
if ((rtav = dynamic_cast<RouteTimeAxisView*> (*i)) != 0) {
boost::shared_ptr<Playlist> pl;
std::vector<boost::shared_ptr<Region> > results;
boost::shared_ptr<Track> tr;
-
+
if ((tr = rtav->track()) == 0) {
/* bus */
continue;
}
-
+
if ((pl = (tr->playlist())) != 0) {
boost::shared_ptr<Region> r = pl->region_by_id (id);
if (r) {
mtav->get_per_region_note_selection (selection);
}
}
-
+
}
void
}
}
+RegionView*
+Editor::regionview_from_region (boost::shared_ptr<Region> region) const
+{
+ for (TrackViewList::const_iterator i = track_views.begin(); i != track_views.end(); ++i) {
+ RouteTimeAxisView* tatv;
+ if ((tatv = dynamic_cast<RouteTimeAxisView*> (*i)) != 0) {
+ if (!tatv->track()) {
+ continue;
+ }
+ RegionView* marv = tatv->view()->find_view (region);
+ if (marv) {
+ return marv;
+ }
+ }
+ }
+ return NULL;
+}
+
+RouteTimeAxisView*
+Editor::rtav_from_route (boost::shared_ptr<Route> route) const
+{
+ for (TrackViewList::const_iterator i = track_views.begin(); i != track_views.end(); ++i) {
+ RouteTimeAxisView* rtav;
+ if ((rtav = dynamic_cast<RouteTimeAxisView*> (*i)) != 0) {
+ if (rtav->route() == route) {
+ return rtav;
+ }
+ }
+ }
+ return NULL;
+}
+
void
Editor::show_rhythm_ferret ()
{
Editor::first_idle ()
{
MessageDialog* dialog = 0;
-
+
if (track_views.size() > 1) {
+ Timers::TimerSuspender t;
dialog = new MessageDialog (
- *this,
string_compose (_("Please wait while %1 loads visual data."), PROGRAM_NAME),
true
);
dialog->present ();
- ARDOUR_UI::instance()->flush_pending ();
+ ARDOUR_UI::instance()->flush_pending (60);
}
for (TrackViewList::iterator t = track_views.begin(); t != track_views.end(); ++t) {
(*t)->first_idle();
}
+ /* now that all regionviews should exist, setup region selection */
+
+ RegionSelection rs;
+
+ for (list<PBD::ID>::iterator pr = selection->regions.pending.begin (); pr != selection->regions.pending.end (); ++pr) {
+ /* this is cumulative: rs is NOT cleared each time */
+ get_regionviews_by_id (*pr, rs);
+ }
+
+ selection->set (rs);
+
// first idle adds route children (automation tracks), so we need to redisplay here
_routes->redisplay ();
_pending_locate_request = false;
_pending_initial_locate = false;
+ _last_update_time = 0;
}
void
Editor::region_view_added (RegionView * rv)
{
- for (list<PBD::ID>::iterator pr = selection->regions.pending.begin (); pr != selection->regions.pending.end (); ++pr) {
- if (rv->region ()->id () == (*pr)) {
- selection->add (rv);
- selection->regions.pending.erase (pr);
- break;
- }
- }
-
MidiRegionView* mrv = dynamic_cast<MidiRegionView*> (rv);
if (mrv) {
- list<pair<PBD::ID const, list<boost::shared_ptr<Evoral::Note<Evoral::Beats> > > > >::iterator rnote;
+ list<pair<PBD::ID const, list<Evoral::event_id_t> > >::iterator rnote;
for (rnote = selection->pending_midi_note_selection.begin(); rnote != selection->pending_midi_note_selection.end(); ++rnote) {
if (rv->region()->id () == (*rnote).first) {
mrv->select_notes ((*rnote).second);
_summary->set_background_dirty ();
}
-RouteTimeAxisView*
-Editor::axis_view_from_route (boost::shared_ptr<Route> r) const
+AxisView*
+Editor::axis_view_by_stripable (boost::shared_ptr<Stripable> s) const
{
- TrackViewList::const_iterator j = track_views.begin ();
- while (j != track_views.end()) {
- RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*j);
- if (rtv && rtv->route() == r) {
- return rtv;
+ for (TrackViewList::const_iterator j = track_views.begin (); j != track_views.end(); ++j) {
+ if ((*j)->stripable() == s) {
+ return *j;
}
- ++j;
}
return 0;
}
+AxisView*
+Editor::axis_view_by_control (boost::shared_ptr<AutomationControl> c) const
+{
+ for (TrackViewList::const_iterator j = track_views.begin (); j != track_views.end(); ++j) {
+ if ((*j)->control() == c) {
+ return *j;
+ }
+
+ TimeAxisView::Children kids = (*j)->get_child_list ();
+
+ for (TimeAxisView::Children::iterator k = kids.begin(); k != kids.end(); ++k) {
+ if ((*k)->control() == c) {
+ return (*k).get();
+ }
+ }
+ }
+
+ return 0;
+}
TrackViewList
Editor::axis_views_from_routes (boost::shared_ptr<RouteList> r) const
TrackViewList t;
for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
- TimeAxisView* tv = axis_view_from_route (*i);
+ TimeAxisView* tv = time_axis_view_from_stripable (*i);
if (tv) {
t.push_back (tv);
}
}
void
-Editor::add_routes (RouteList& routes)
+Editor::add_vcas (VCAList& vlist)
{
- ENSURE_GUI_THREAD (*this, &Editor::handle_new_route, routes)
+ StripableList sl;
- RouteTimeAxisView *rtv;
- list<RouteTimeAxisView*> new_views;
+ for (VCAList::iterator v = vlist.begin(); v != vlist.end(); ++v) {
+ sl.push_back (boost::dynamic_pointer_cast<Stripable> (*v));
+ }
+
+ add_stripables (sl);
+}
+
+void
+Editor::add_routes (RouteList& rlist)
+{
+ StripableList sl;
+
+ for (RouteList::iterator r = rlist.begin(); r != rlist.end(); ++r) {
+ sl.push_back (*r);
+ }
+
+ add_stripables (sl);
+}
+
+void
+Editor::add_stripables (StripableList& sl)
+{
+ list<TimeAxisView*> new_views;
+ boost::shared_ptr<VCA> v;
+ boost::shared_ptr<Route> r;
TrackViewList new_selection;
bool from_scratch = (track_views.size() == 0);
- for (RouteList::iterator x = routes.begin(); x != routes.end(); ++x) {
- boost::shared_ptr<Route> route = (*x);
+ sl.sort (Stripable::Sorter());
- if (route->is_auditioner() || route->is_monitor()) {
- continue;
- }
+ for (StripableList::iterator s = sl.begin(); s != sl.end(); ++s) {
- DataType dt = route->input()->default_type();
+ if ((v = boost::dynamic_pointer_cast<VCA> (*s)) != 0) {
- if (dt == ARDOUR::DataType::AUDIO) {
- rtv = new AudioTimeAxisView (*this, _session, *_track_canvas);
- rtv->set_route (route);
- } else if (dt == ARDOUR::DataType::MIDI) {
- rtv = new MidiTimeAxisView (*this, _session, *_track_canvas);
- rtv->set_route (route);
- } else {
- throw unknown_type();
- }
+ VCATimeAxisView* vtv = new VCATimeAxisView (*this, _session, *_track_canvas);
+ vtv->set_vca (v);
+ new_views.push_back (vtv);
- new_views.push_back (rtv);
- track_views.push_back (rtv);
- new_selection.push_back (rtv);
+ } else if ((r = boost::dynamic_pointer_cast<Route> (*s)) != 0) {
- rtv->effective_gain_display ();
+ if (r->is_auditioner() || r->is_monitor()) {
+ continue;
+ }
+
+ RouteTimeAxisView* rtv;
+ DataType dt = r->input()->default_type();
- rtv->view()->RegionViewAdded.connect (sigc::mem_fun (*this, &Editor::region_view_added));
- rtv->view()->RegionViewRemoved.connect (sigc::mem_fun (*this, &Editor::region_view_removed));
+ if (dt == ARDOUR::DataType::AUDIO) {
+ rtv = new AudioTimeAxisView (*this, _session, *_track_canvas);
+ rtv->set_route (r);
+ } else if (dt == ARDOUR::DataType::MIDI) {
+ rtv = new MidiTimeAxisView (*this, _session, *_track_canvas);
+ rtv->set_route (r);
+ } else {
+ throw unknown_type();
+ }
+
+ new_views.push_back (rtv);
+ track_views.push_back (rtv);
+ new_selection.push_back (rtv);
+
+ rtv->effective_gain_display ();
+
+ rtv->view()->RegionViewAdded.connect (sigc::mem_fun (*this, &Editor::region_view_added));
+ rtv->view()->RegionViewRemoved.connect (sigc::mem_fun (*this, &Editor::region_view_removed));
+ }
}
if (new_views.size() > 0) {
- _routes->routes_added (new_views);
- _summary->routes_added (new_views);
+ _routes->time_axis_views_added (new_views);
+ //_summary->routes_added (new_selection); /* XXX requires RouteTimeAxisViewList */
}
- if (!from_scratch) {
- selection->tracks.clear();
- selection->add (new_selection);
+ /* note: !new_selection.empty() means that we got some routes rather
+ * than just VCAs
+ */
+
+ if (!from_scratch && !new_selection.empty()) {
+ selection->set (new_selection);
begin_selection_op_history();
}
- if (show_editor_mixer_when_tracks_arrive) {
+ if (show_editor_mixer_when_tracks_arrive && !new_selection.empty()) {
show_editor_mixer (true);
}
next_tv = (*i);
}
+ // skip VCAs (cannot be selected, n/a in editor-mixer)
+ if (dynamic_cast<VCATimeAxisView*> (next_tv)) {
+ /* VCAs are sorted last in line -- route_sorter.h, jump to top */
+ next_tv = track_views.front();
+ }
+ if (dynamic_cast<VCATimeAxisView*> (next_tv)) {
+ /* just in case: no master, only a VCA remains */
+ next_tv = 0;
+ }
+
if (next_tv) {
set_selected_mixer_strip (*next_tv);
void
Editor::hide_track_in_display (TimeAxisView* tv, bool apply_to_selection)
{
+ if (!tv) {
+ return;
+ }
if (apply_to_selection) {
for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ) {
}
}
+void
+Editor::show_track_in_display (TimeAxisView* tv, bool move_into_view)
+{
+ if (!tv) {
+ return;
+ }
+ _routes->show_track_in_display (*tv);
+ if (move_into_view) {
+ ensure_time_axis_view_is_visible (*tv, false);
+ }
+}
+
bool
Editor::sync_track_view_list_and_routes ()
{
track_views = TrackViewList (_routes->views ());
- _summary->set_dirty ();
+ _summary->set_background_dirty();
_group_tabs->set_dirty ();
return false; // do not call again (until needed)
}
}
-/** Find a RouteTimeAxisView by the ID of its route */
-RouteTimeAxisView*
-Editor::get_route_view_by_route_id (const PBD::ID& id) const
+/** Find a StripableTimeAxisView by the ID of its stripable */
+StripableTimeAxisView*
+Editor::get_stripable_time_axis_by_id (const PBD::ID& id) const
{
- RouteTimeAxisView* v;
+ StripableTimeAxisView* v;
for (TrackViewList::const_iterator i = track_views.begin(); i != track_views.end(); ++i) {
- if((v = dynamic_cast<RouteTimeAxisView*>(*i)) != 0) {
- if(v->route()->id() == id) {
+ if((v = dynamic_cast<StripableTimeAxisView*>(*i)) != 0) {
+ if(v->stripable()->id() == id) {
return v;
}
}
} else {
framepos_t l = 0;
-
+
if (frame < leftmost_frame) {
/* moving left */
if (_session->transport_rolling()) {
if (l < 0) {
l = 0;
}
-
+
center_screen_internal (l + (current_page_samples() / 2), current_page_samples ());
}
}
/* METERING / MIXER STRIPS */
/* update track meters, if required */
- if (is_mapped() && meters_running) {
+ if (contents().is_mapped() && meters_running) {
RouteTimeAxisView* rtv;
for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
if ((rtv = dynamic_cast<RouteTimeAxisView*>(*i)) != 0) {
/* PLAYHEAD AND VIEWPORT */
- framepos_t const frame = _session->audible_frame();
-
/* There are a few reasons why we might not update the playhead / viewport stuff:
*
* 1. we don't update things when there's a pending locate request, otherwise
* 2. if we're not rolling, there's nothing to do here (locates are handled elsewhere).
* 3. if we're still at the same frame that we were last time, there's nothing to do.
*/
+ if (_pending_locate_request || !_session->transport_rolling ()) {
+ _last_update_time = 0;
+ return;
+ }
- if (!_pending_locate_request && _session->transport_speed() != 0 && frame != last_update_frame) {
+ if (_dragging_playhead) {
+ _last_update_time = 0;
+ return;
+ }
- last_update_frame = frame;
+ bool latent_locate = false;
+ framepos_t frame = _session->audible_frame (&latent_locate);
+ const int64_t now = g_get_monotonic_time ();
+ double err = 0;
- if (!_dragging_playhead) {
- playhead_cursor->set_position (frame);
- }
+ if (_session->exporting ()) {
+ /* freewheel/export may be faster or slower than transport_speed() / SR.
+ * Also exporting multiple ranges locates/jumps without a _pending_locate_request.
+ */
+ _last_update_time = 0;
+ }
- if (!_stationary_playhead) {
+ if (_last_update_time > 0) {
+ /* interpolate and smoothen playhead position */
+ const double ds = (now - _last_update_time) * _session->transport_speed() * _session->nominal_frame_rate () * 1e-6;
+ framepos_t guess = playhead_cursor->current_frame () + rint (ds);
+ err = frame - guess;
- if (!_dragging_playhead && _follow_playhead && _session->requested_return_frame() < 0 && !pending_visual_change.being_handled) {
- /* We only do this if we aren't already
- handling a visual change (ie if
- pending_visual_change.being_handled is
- false) so that these requests don't stack
- up there are too many of them to handle in
- time.
- */
- reset_x_origin_to_follow_playhead ();
- }
+ guess += err * .12 + _err_screen_engine; // time-constant based on 25fps (super_rapid_screen_update)
+ _err_screen_engine += .0144 * (err - _err_screen_engine); // tc^2
- } else {
+#if 0 // DEBUG
+ printf ("eng: %ld gui:%ld (%+6.1f) diff: %6.1f (err: %7.2f)\n",
+ frame, guess, ds,
+ err, _err_screen_engine);
+#endif
- /* don't do continuous scroll till the new position is in the rightmost quarter of the
- editor canvas
- */
-#if 0
- // FIXME DO SOMETHING THAT WORKS HERE - this is 2.X code
- double target = ((double)frame - (double)current_page_samples()/2.0) / samples_per_pixel;
- if (target <= 0.0) {
- target = 0.0;
- }
- if (fabs(target - current) < current_page_samples() / samples_per_pixel) {
- target = (target * 0.15) + (current * 0.85);
- } else {
- /* relax */
- }
+ frame = guess;
+ } else {
+ _err_screen_engine = 0;
+ }
- current = target;
- set_horizontal_position (current);
-#endif
- }
+ if (err > 8192 || latent_locate) {
+ // in case of x-runs or freewheeling
+ _last_update_time = 0;
+ frame = _session->audible_frame ();
+ } else {
+ _last_update_time = now;
+ }
+ if (playhead_cursor->current_frame () == frame) {
+ return;
+ }
+
+ playhead_cursor->set_position (frame);
+
+ if (_session->requested_return_frame() >= 0) {
+ _last_update_time = 0;
+ return;
+ }
+
+ if (!_follow_playhead || pending_visual_change.being_handled) {
+ /* We only do this if we aren't already
+ * handling a visual change (ie if
+ * pending_visual_change.being_handled is
+ * false) so that these requests don't stack
+ * up there are too many of them to handle in
+ * time.
+ */
+ return;
+ }
+
+ if (!_stationary_playhead) {
+ reset_x_origin_to_follow_playhead ();
+ } else {
+ framepos_t const frame = playhead_cursor->current_frame ();
+ double target = ((double)frame - (double)current_page_samples() / 2.0);
+ if (target <= 0.0) {
+ target = 0.0;
+ }
+ // compare to EditorCursor::set_position()
+ double const old_pos = sample_to_pixel_unrounded (leftmost_frame);
+ double const new_pos = sample_to_pixel_unrounded (target);
+ if (rint (new_pos) != rint (old_pos)) {
+ reset_x_origin (pixel_to_sample (new_pos));
+ }
}
}
clicked_routeview = 0;
entered_regionview = 0;
entered_track = 0;
- last_update_frame = 0;
+ _last_update_time = 0;
_drags->abort ();
playhead_cursor->hide ();
hide_measures ();
clear_marker_display ();
+ delete tempo_lines;
+ tempo_lines = 0;
+
stop_step_editing ();
-
- /* get rid of any existing editor mixer strip */
- WindowTitle title(Glib::get_application_name());
- title += _("Editor");
+ if (own_window()) {
- set_title (title.get_string());
+ /* get rid of any existing editor mixer strip */
+
+ WindowTitle title(Glib::get_application_name());
+ title += _("Editor");
+
+ own_window()->set_title (title.get_string());
+ }
SessionHandlePtr::session_going_away ();
}
+void
+Editor::trigger_script (int i)
+{
+ LuaInstance::instance()-> call_action (i);
+}
void
Editor::show_editor_list (bool yn)
{
if (yn) {
- _the_notebook.show ();
+ _editor_list_vbox.show ();
} else {
- _the_notebook.hide ();
+ _editor_list_vbox.hide ();
}
}
void
Editor::setup_fade_images ()
{
- _fade_in_images[FadeLinear] = new Gtk::Image (get_icon_path (X_("fadein-linear")));
- _fade_in_images[FadeSymmetric] = new Gtk::Image (get_icon_path (X_("fadein-symmetric")));
- _fade_in_images[FadeFast] = new Gtk::Image (get_icon_path (X_("fadein-fast-cut")));
- _fade_in_images[FadeSlow] = new Gtk::Image (get_icon_path (X_("fadein-slow-cut")));
- _fade_in_images[FadeConstantPower] = new Gtk::Image (get_icon_path (X_("fadein-constant-power")));
-
- _fade_out_images[FadeLinear] = new Gtk::Image (get_icon_path (X_("fadeout-linear")));
- _fade_out_images[FadeSymmetric] = new Gtk::Image (get_icon_path (X_("fadeout-symmetric")));
- _fade_out_images[FadeFast] = new Gtk::Image (get_icon_path (X_("fadeout-fast-cut")));
- _fade_out_images[FadeSlow] = new Gtk::Image (get_icon_path (X_("fadeout-slow-cut")));
- _fade_out_images[FadeConstantPower] = new Gtk::Image (get_icon_path (X_("fadeout-constant-power")));
-
_xfade_in_images[FadeLinear] = new Gtk::Image (get_icon_path (X_("fadein-linear")));
_xfade_in_images[FadeSymmetric] = new Gtk::Image (get_icon_path (X_("fadein-symmetric")));
_xfade_in_images[FadeFast] = new Gtk::Image (get_icon_path (X_("fadein-fast-cut")));
if (_notebook_shrunk) {
if (pre_notebook_shrink_pane_width) {
- edit_pane.set_position (*pre_notebook_shrink_pane_width);
+ edit_pane.set_divider (0, *pre_notebook_shrink_pane_width);
}
_notebook_shrunk = false;
} else {
- pre_notebook_shrink_pane_width = edit_pane.get_position();
+ pre_notebook_shrink_pane_width = edit_pane.get_divider();
/* this expands the LHS of the edit pane to cover the notebook
PAGE but leaves the tabs visible.
*/
- edit_pane.set_position (edit_pane.get_position() + page->get_width());
+ edit_pane.set_divider (0, edit_pane.get_divider() + page->get_width());
_notebook_shrunk = true;
}
}
Editor::popup_control_point_context_menu (ArdourCanvas::Item* item, GdkEvent* event)
{
using namespace Menu_Helpers;
-
+
MenuList& items = _control_point_context_menu.items ();
items.clear ();
-
+
items.push_back (MenuElem (_("Edit..."), sigc::bind (sigc::mem_fun (*this, &Editor::edit_control_point), item)));
items.push_back (MenuElem (_("Delete"), sigc::bind (sigc::mem_fun (*this, &Editor::remove_control_point), item)));
if (!can_remove_control_point (item)) {
MidiRegionView& mrv = note->region_view();
const RegionSelection rs = get_regions_from_selection_and_entered ();
+ const uint32_t sel_size = mrv.selection_size ();
MenuList& items = _note_context_menu.items();
items.clear();
- items.push_back(MenuElem(_("Delete"),
- sigc::mem_fun(mrv, &MidiRegionView::delete_selection)));
+ if (sel_size > 0) {
+ items.push_back(MenuElem(_("Delete"),
+ sigc::mem_fun(mrv, &MidiRegionView::delete_selection)));
+ }
+
items.push_back(MenuElem(_("Edit..."),
- sigc::bind(sigc::mem_fun(*this, &Editor::edit_notes), &mrv)));
+ sigc::bind(sigc::mem_fun(*this, &Editor::edit_notes), &mrv)));
+ if (sel_size != 1) {
+ items.back().set_sensitive (false);
+ }
+
+ items.push_back(MenuElem(_("Transpose..."),
+ sigc::bind(sigc::mem_fun(*this, &Editor::transpose_regions), rs)));
+
+
items.push_back(MenuElem(_("Legatize"),
- sigc::bind(sigc::mem_fun(*this, &Editor::legatize_regions), rs, false)));
+ sigc::bind(sigc::mem_fun(*this, &Editor::legatize_regions), rs, false)));
+ if (sel_size < 2) {
+ items.back().set_sensitive (false);
+ }
+
items.push_back(MenuElem(_("Quantize..."),
sigc::bind(sigc::mem_fun(*this, &Editor::quantize_regions), rs)));
+
items.push_back(MenuElem(_("Remove Overlap"),
- sigc::bind(sigc::mem_fun(*this, &Editor::legatize_regions), rs, true)));
+ sigc::bind(sigc::mem_fun(*this, &Editor::legatize_regions), rs, true)));
+ if (sel_size < 2) {
+ items.back().set_sensitive (false);
+ }
+
items.push_back(MenuElem(_("Transform..."),
sigc::bind(sigc::mem_fun(*this, &Editor::transform_regions), rs)));
while (!_cursor_stack.empty()) {
_cursor_stack.pop_back();
}
- _cursors->set_cursor_set (ARDOUR_UI::config()->get_icon_set());
+ _cursors->set_cursor_set (UIConfiguration::instance().get_icon_set());
_cursor_stack.push_back(_cursors->grabber);
+ edit_pane.set_drag_cursor (*_cursors->expand_left_right);
+ editor_summary_pane.set_drag_cursor (*_cursors->expand_up_down);
+
} else if (parameter == "draggable-playhead") {
if (_verbose_cursor) {
- playhead_cursor->set_sensitive (ARDOUR_UI::config()->get_draggable_playhead());
+ playhead_cursor->set_sensitive (UIConfiguration::instance().get_draggable_playhead());
}
}
}
+
+Gtk::Window*
+Editor::use_own_window (bool and_fill_it)
+{
+ bool new_window = !own_window();
+
+ Gtk::Window* win = Tabbable::use_own_window (and_fill_it);
+
+ if (win && new_window) {
+ win->set_name ("EditorWindow");
+
+ ARDOUR_UI::instance()->setup_toplevel_window (*win, _("Editor"), this);
+
+ // win->signal_realize().connect (*this, &Editor::on_realize);
+ win->signal_event().connect (sigc::bind (sigc::ptr_fun (&Keyboard::catch_user_event_for_pre_dialog_focus), win));
+ win->signal_event().connect (sigc::mem_fun (*this, &Editor::generic_event_handler));
+ win->set_data ("ardour-bindings", bindings);
+
+ update_title ();
+ }
+
+ DisplaySuspender ds;
+ contents().show_all ();
+
+ /* XXX: this is a bit unfortunate; it would probably
+ be nicer if we could just call show () above rather
+ than needing the show_all ()
+ */
+
+ /* re-hide stuff if necessary */
+ editor_list_button_toggled ();
+ parameter_changed ("show-summary");
+ parameter_changed ("show-group-tabs");
+ parameter_changed ("show-zoom-tools");
+
+ /* now reset all audio_time_axis heights, because widgets might need
+ to be re-hidden
+ */
+
+ TimeAxisView *tv;
+
+ for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
+ tv = (static_cast<TimeAxisView*>(*i));
+ tv->reset_height ();
+ }
+
+ if (current_mixer_strip) {
+ current_mixer_strip->hide_things ();
+ current_mixer_strip->parameter_changed ("mixer-element-visibility");
+ }
+
+ return win;
+}