#include "gtkmm2ext/bindings.h"
#include "gtkmm2ext/grouped_buttons.h"
#include "gtkmm2ext/gtk_ui.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 "actions.h"
#include "analysis_window.h"
+#include "ardour_spacer.h"
#include "audio_clock.h"
#include "audio_region_view.h"
#include "audio_streamview.h"
#include "editor_routes.h"
#include "editor_snapshots.h"
#include "editor_summary.h"
+#include "export_report.h"
#include "global_port_matrix.h"
#include "gui_object.h"
#include "gui_thread.h"
#include "keyboard.h"
+#include "keyeditor.h"
+#include "luainstance.h"
#include "marker.h"
#include "midi_region_view.h"
#include "midi_time_axis.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 "tooltips.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;
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 ()
: 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)
, _track_canvas_viewport (0)
, within_track_canvas (false)
, _verbose_cursor (0)
- , logo_item (0)
, tempo_group (0)
, meter_group (0)
, marker_group (0)
, tempo_lines (0)
, global_rect_group (0)
, time_line_group (0)
- , tempo_or_meter_marker_menu (0)
+ , tempo_marker_menu (0)
+ , meter_marker_menu (0)
, marker_menu (0)
, range_marker_menu (0)
, transport_marker_menu (0)
, _visible_track_count (-1)
, toolbar_selection_clock_table (2,3)
, automation_mode_button (_("mode"))
- , _toolbar_viewport (*manage (new Gtk::Adjustment (0, 0, 1e10)), *manage (new Gtk::Adjustment (0, 0, 1e10)))
, selection (new Selection (this))
, cut_buffer (new Selection (this))
, _selection_memento (new SelectionMemento())
, _all_region_actions_sensitized (false)
, _ignore_region_action (false)
, _last_region_menu_was_main (false)
- , _ignore_follow_edits (false)
, cd_marker_bar_drag_rect (0)
, range_bar_drag_rect (0)
, transport_bar_drag_rect (0)
, show_gain_after_trim (false)
, selection_op_cmd_depth (0)
, selection_op_history_it (0)
+ , no_save_instant (false)
, current_timefx (0)
, current_mixer_strip (0)
, show_editor_mixer_when_tracks_arrive (false)
, _stepping_axis_view (0)
, quantize_dialog (0)
, _main_menu_disabler (0)
+ , myactions (X_("editor"))
{
/* we are a singleton */
last_event_time.tv_sec = 0;
last_event_time.tv_usec = 0;
- global_hpacker.set_data ("ardour-bindings", &key_bindings);
-
selection_op_history.clear();
before.clear();
build_snap_type_menu();
build_edit_point_menu();
- 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");
timebar_height = std::max(12., ceil (15. * ARDOUR_UI::ui_scale));
TimeAxisView::setup_sizes ();
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));
_regions = new EditorRegions (this);
_snapshots = new EditorSnapshots (this);
_locations = new EditorLocations (this);
+ _time_info_box = new TimeInfoBox (true);
/* these are static location signals */
_notebook_shrunk = false;
- editor_summary_pane.pack1(edit_packer);
+
+ /* Pick up some settings we need to cache, early */
+
+ XMLNode* settings = ARDOUR_UI::instance()->editor_settings();
+ XMLProperty* prop;
+
+ if (settings && (prop = settings->property ("notebook-shrunk"))) {
+ _notebook_shrunk = string_is_affirmative (prop->value ());
+ }
+
+ editor_summary_pane.set_check_divider_position (true);
+ editor_summary_pane.add (edit_packer);
Button* summary_arrows_left_left = manage (new Button);
summary_arrows_left_left->add (*manage (new Arrow (ARROW_LEFT, SHADOW_NONE)));
_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;
- edit_pane.signal_size_allocate().connect (sigc::bind (sigc::mem_fun(*this, &Editor::pane_allocation_handler), static_cast<Paned*> (&edit_pane)));
+ {
+ LocaleGuard lg;
+
+ if (!settings || ((prop = settings->property ("edit-horizontal-pane-pos")) == 0) || ((fract = atof (prop->value())) > 1.0)) {
+ /* initial allocation is 90% to canvas, 10% to notebook */
+ edit_pane.set_divider (0, 0.90);
+ } else {
+ edit_pane.set_divider (0, fract);
+ }
+
+ if (!settings || ((prop = settings->property ("edit-vertical-pane-pos")) == 0) || ((fract = atof (prop->value())) > 1.0)) {
+ /* initial allocation is 90% to canvas, 10% to summary */
+ editor_summary_pane.set_divider (0, 0.90);
+ } else {
+
+ editor_summary_pane.set_divider (0, fract);
+ }
+ }
+
+ global_vpacker.set_spacing (2);
+ global_vpacker.set_border_width (0);
+
+ //the next three EventBoxes provide the ability for their child widgets to have a background color. That is all.
- Glib::PropertyProxy<int> proxy = edit_pane.property_position();
- proxy.signal_changed().connect (bind (sigc::ptr_fun (pane_size_watcher), static_cast<Paned*> (&edit_pane)));
+ Gtk::EventBox* ebox = manage (new Gtk::EventBox); //a themeable box
+ ebox->set_name("EditorWindow");
+ ebox->add (toolbar_hbox);
- top_hbox.pack_start (toolbar_frame);
+ Gtk::EventBox* epane_box = manage (new Gtk::EventBox); //a themeable box
+ epane_box->set_name("EditorWindow");
+ epane_box->add (edit_pane);
- HBox *hbox = manage (new HBox);
- hbox->pack_start (edit_pane, true, true);
+ Gtk::EventBox* epane_box2 = manage (new Gtk::EventBox); //a themeable box
+ epane_box2->set_name("EditorWindow");
+ epane_box2->add (global_vpacker);
- global_vpacker.pack_start (top_hbox, false, false);
- global_vpacker.pack_start (*hbox, true, true);
- global_hpacker.pack_start (global_vpacker, true, true);
+ global_vpacker.pack_start (*ebox, false, false);
+ global_vpacker.pack_start (*epane_box, true, true);
+ global_hpacker.pack_start (*epane_box2, true, true);
/* need to show the "contents" widget so that notebook will show if tab is switched to
*/
- global_hpacker.show ();
+ global_hpacker.show ();
/* register actions now so that set_state() can find them and set toggles/checks etc */
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());
+ PresentationInfo::Change.connect (*this, invalidator (*this), boost::bind (&Editor::presentation_info_changed, this, _1), 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));
_last_region_menu_was_main = false;
_popup_region_menu_item = 0;
- _ignore_follow_edits = false;
-
_show_marker_lines = false;
/* 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);
+ button_bindings->load_operation (**i);
}
}
setup_fade_images ();
+ LuaInstance::instance(); // instantiate
+ LuaInstance::instance()->ActionChanged.connect (sigc::mem_fun (*this, &Editor::set_script_action_name));
+
instant_save ();
}
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 _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;
+ }
+}
+
+void
+Editor::presentation_info_changed (PropertyChange const & what_changed)
+{
+ if (what_changed.contains (Properties::selected)) {
+ track_selection_changed ();
+ }
}
XMLNode*
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 = axis_view_from_stripable (s);
if (tav) {
switch (op) {
/* leaving window, so reset focus, thus ending any and
all text entry operations.
*/
- reset_focus();
+ ARDOUR_UI::instance()->reset_focus (&contents());
break;
}
break;
if (!own_window()) {
return;
}
-
+
if (_session) {
bool dirty = _session->dirty();
}
WindowTitle title(session_name);
+ title += S_("Window|Editor");
title += Glib::get_application_name();
own_window()->set_title (title.get_string());
} else {
_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);
_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->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());
break;
}
+ /* catch up on selection of stripables (other selection state is lost
+ * when a session is closed
+ */
+
+ StripableList sl;
+ TrackViewList tl;
+ _session->get_stripables (sl);
+ for (StripableList::const_iterator s = sl.begin(); s != sl.end(); ++s) {
+ if ((*s)->presentation_info().selected()) {
+ RouteTimeAxisView* rtav = get_route_view_by_route_id ((*s)->id());
+ if (rtav) {
+ tl.push_back (rtav);
+ }
+ }
+ }
+ if (!tl.empty()) {
+ selection->set (tl);
+ }
+
/* register for undo history */
_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 ();
}
{
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();
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());
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;
}
int
Editor::set_state (const XMLNode& node, int version)
{
- const XMLProperty* prop;
+ XMLProperty const * prop;
set_id (node);
+ PBD::Unwinder<bool> nsi (no_save_instant, true);
+ LocaleGuard lg;
Tabbable::set_state (node, version);
-
+
if (_session && (prop = node.property ("playhead"))) {
framepos_t pos;
sscanf (prop->value().c_str(), "%" PRIi64, &pos);
if ((prop = node.property ("zoom-focus"))) {
zoom_focus_selection_done ((ZoomFocus) string_2_enum (prop->value(), zoom_focus));
+ } else {
+ zoom_focus_selection_done (zoom_focus);
}
if ((prop = node.property ("zoom"))) {
if ((prop = node.property ("snap-to"))) {
snap_type_selection_done ((SnapType) string_2_enum (prop->value(), _snap_type));
+ set_snap_to ((SnapType) string_2_enum (prop->value(), _snap_type));
+ } else {
+ set_snap_to (_snap_type);
}
if ((prop = node.property ("snap-mode"))) {
snap_mode_selection_done((SnapMode) string_2_enum (prop->value(), _snap_mode));
+ /* 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 ((SnapMode) string_2_enum (prop->value(), _snap_mode));
+ } else {
+ set_snap_mode (_snap_mode);
}
if ((prop = node.property ("internal-snap-to"))) {
if ((prop = node.property ("edit-point"))) {
set_edit_point_preference ((EditPoint) string_2_enum (prop->value(), _edit_point), true);
+ } else {
+ set_edit_point_preference (_edit_point);
}
if ((prop = node.property ("show-measures"))) {
}
}
- return 0;
+ return LuaInstance::instance()->set_state(node);
}
XMLNode&
{
XMLNode* node = new XMLNode (X_("Editor"));
char buf[32];
+ LocaleGuard lg;
id().print (buf, sizeof (buf));
node->add_property ("id", buf);
node->add_child_nocopy (Tabbable::get_state());
-
- snprintf(buf,sizeof(buf), "%d",gtk_paned_get_position (static_cast<Paned*>(&edit_pane)->gobj()));
+
+ snprintf(buf,sizeof(buf), "%f", edit_pane.get_divider ());
node->add_property("edit-horizontal-pane-pos", string(buf));
node->add_property("notebook-shrunk", _notebook_shrunk ? "1" : "0");
- snprintf(buf,sizeof(buf), "%d",gtk_paned_get_position (static_cast<Paned*>(&editor_summary_pane)->gobj()));
+ snprintf(buf,sizeof(buf), "%f", editor_summary_pane.get_divider());
node->add_property("edit-vertical-pane-pos", string(buf));
-
+
maybe_add_mixer_strip_width (*node);
node->add_property ("zoom-focus", enum_2_string (zoom_focus));
snprintf (buf, sizeof (buf), "%" PRId64, nudge_clock->current_duration());
node->add_property ("nudge-clock-value", buf);
+ node->add_child_nocopy (LuaInstance::instance()->get_action_state());
+ node->add_child_nocopy (LuaInstance::instance()->get_hook_state());
+
return *node;
}
void
Editor::timecode_snap_to_internal (framepos_t& start, 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);
+ 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;
break;
case SnapToBeatDiv128:
- start = _session->tempo_map().round_to_beat_subdivision (start, 128, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 2, direction);
break;
case SnapToMark:
} else if (after == max_framepos) {
start = before;
} else if (before != max_framepos && after != max_framepos) {
- /* have before and after */
- if ((start - before) < (after - start)) {
- start = before;
- } else {
+ if ((direction == RoundUpMaybe || direction == RoundUpAlways))
start = after;
+ else if ((direction == RoundDownMaybe || direction == RoundDownAlways))
+ start = before;
+ else if (direction == 0 ) {
+ if ((start - before) < (after - start)) {
+ start = before;
+ } else {
+ start = after;
+ }
}
}
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_trx()) {
mode_box->pack_start (edit_mode_selector, false, false);
}
-
+
mode_box->pack_start (*mouse_mode_box, false, false);
-
+
/* Zoom */
_zoom_box.set_spacing (2);
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_icon (ArdourIcon::ZoomIn);
}
/* 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_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);
+ _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 (1);
+ toolbar_hbox.set_border_width (2);
toolbar_hbox.pack_start (*mode_box, false, false);
+
if (!ARDOUR::Profile->get_trx()) {
+
+ toolbar_hbox.pack_start (*(manage (new ArdourVSpacer ())), false, false, 3);
+
toolbar_hbox.pack_start (_zoom_box, false, false);
- toolbar_hbox.pack_start (*hbox, false, false);
- }
- if (!ARDOUR::Profile->get_trx()) {
- hbox->pack_start (snap_box, false, false);
- hbox->pack_start (*nudge_box, false, false);
- }
+ toolbar_hbox.pack_start (*(manage (new ArdourVSpacer ())), false, false, 3);
+
+ toolbar_hbox.pack_start (_track_box, false, false);
+
+ toolbar_hbox.pack_start (*(manage (new ArdourVSpacer ())), false, false, 3);
+
+ toolbar_hbox.pack_start (snap_box, false, false);
+
+ toolbar_hbox.pack_start (*(manage (new ArdourVSpacer ())), false, false, 3);
- hbox->show_all ();
+ toolbar_hbox.pack_start (*ep_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 (*nudge_box, false, false);
+ }
- toolbar_frame.set_shadow_type (SHADOW_OUT);
- toolbar_frame.set_name ("BaseFrame");
- toolbar_frame.add (_toolbar_viewport);
+ toolbar_hbox.show_all ();
}
void
{
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)));
}
}
Editor::edit_controls_button_release (GdkEventButton* ev)
{
if (Keyboard::is_context_menu_event (ev)) {
- ARDOUR_UI::instance()->add_route (current_toplevel());
+ ARDOUR_UI::instance()->add_route ();
} else if (ev->button == 1) {
selection->clear_tracks ();
}
}
}
-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::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 ();
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:
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 ();
}
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
vs->zoom_focus = zoom_focus;
if (with_tracks) {
- *vs->gui_state = *ARDOUR_UI::instance()->gui_object_state;
+ vs->gui_state->set_state (ARDOUR_UI::instance()->gui_object_state->get_state());
}
return vs;
reposition_and_zoom (vs.leftmost_frame, vs.samples_per_pixel);
if (vs.gui_state) {
- *ARDOUR_UI::instance()->gui_object_state = *vs.gui_state;
+ 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();
instant_save ();
}
+framepos_t
+Editor::playhead_cursor_sample () const
+{
+ return playhead_cursor->current_frame();
+}
+
void
Editor::queue_visual_videotimeline_update ()
{
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);
+ compute_bbt_ruler_scale (vc.time_origin, pending_visual_change.time_origin + current_page_samples());
+ update_tempo_based_rulers ();
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;
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_entered ()
+Editor::get_regions_from_selection_and_entered () const
{
RegionSelection regions = selection->regions;
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) {
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
+TimeAxisView*
+Editor::axis_view_from_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;
TrackViewList t;
for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
- TimeAxisView* tv = axis_view_from_route (*i);
+ TimeAxisView* tv = 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 (StripablePresentationInfoSorter());
- 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);
+
+ } else if ((r = boost::dynamic_pointer_cast<Route> (*s)) != 0) {
- new_views.push_back (rtv);
- track_views.push_back (rtv);
- new_selection.push_back (rtv);
+ if (r->is_auditioner() || r->is_monitor()) {
+ continue;
+ }
- rtv->effective_gain_display ();
+ 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) {
+ /* note: !new_selection.empty() means that we got some routes rather
+ * than just VCAs
+ */
+
+ if (!from_scratch && !new_selection.empty()) {
selection->tracks.clear();
selection->add (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);
stop_step_editing ();
if (own_window()) {
-
+
/* 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::set_script_action_name (int i, const std::string& n)
+{
+ string const a = string_compose (X_("script-action-%1"), i + 1);
+ Glib::RefPtr<Action> act = ActionManager::get_action(X_("Editor"), a.c_str());
+ assert (act);
+ if (n.empty ()) {
+ act->set_label (string_compose (_("Unset #%1"), i + 1));
+ act->set_tooltip (_("no action bound"));
+ act->set_sensitive (false);
+ } else {
+ act->set_label (n);
+ act->set_tooltip (n);
+ act->set_sensitive (true);
+ }
+ KeyEditor::UpdateBindings ();
+}
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;
}
}
}
_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 (UIConfiguration::instance().get_draggable_playhead());
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) {
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", &key_bindings);
-
+ 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;
}