X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;ds=sidebyside;f=gtk2_ardour%2Froute_time_axis.cc;h=8871b7bbe119c0179a9e8cad3cc0a1af7a0399cc;hb=c78528dcea03a61685ad0586eaa6302847af6fe9;hp=0e5088cd265ac4b838a73f9a9491469c1ccf2869;hpb=f450df300c9c057141a4caf79ff6dbfbf58492d9;p=ardour.git diff --git a/gtk2_ardour/route_time_axis.cc b/gtk2_ardour/route_time_axis.cc index 0e5088cd26..8871b7bbe1 100644 --- a/gtk2_ardour/route_time_axis.cc +++ b/gtk2_ardour/route_time_axis.cc @@ -23,6 +23,7 @@ #include #include #include +#include #include #include @@ -32,12 +33,12 @@ #include "pbd/whitespace.h" #include "pbd/memento_command.h" #include "pbd/enumwriter.h" +#include "pbd/stateful_diff_command.h" #include #include #include #include -#include #include #include @@ -60,6 +61,8 @@ #include "evoral/Parameter.hpp" #include "ardour_ui.h" +#include "debug.h" +#include "global_signals.h" #include "route_time_axis.h" #include "automation_time_axis.h" #include "canvas_impl.h" @@ -108,21 +111,17 @@ RouteTimeAxisView::RouteTimeAxisView (PublicEditor& ed, Session* sess, boost::sh , button_table (3, 3) , route_group_button (_("g")) , playlist_button (_("p")) - , size_button (_("h")) , automation_button (_("a")) - , visual_button (_("v")) , gm (sess, slider, true, 115) { - set_button_names (); - gm.set_controls (_route, _route->shared_peak_meter(), _route->amp()); gm.get_level_meter().set_no_show_all(); gm.get_level_meter().setup_meters(50); _has_state = true; - playlist_menu = 0; playlist_action_menu = 0; automation_action_menu = 0; + plugins_submenu_item = 0; mode_menu = 0; _view = 0; @@ -130,42 +129,25 @@ RouteTimeAxisView::RouteTimeAxisView (PublicEditor& ed, Session* sess, boost::sh _marked_for_display = true; } + mute_changed (0); + update_solo_display (); + timestretch_rect = 0; no_redraw = false; - destructive_track_mode_item = 0; - normal_track_mode_item = 0; - non_layered_track_mode_item = 0; ignore_toggle = false; route_group_button.set_name ("TrackGroupButton"); playlist_button.set_name ("TrackPlaylistButton"); automation_button.set_name ("TrackAutomationButton"); - size_button.set_name ("TrackSizeButton"); - visual_button.set_name ("TrackVisualButton"); - hide_button.set_name ("TrackRemoveButton"); route_group_button.unset_flags (Gtk::CAN_FOCUS); playlist_button.unset_flags (Gtk::CAN_FOCUS); automation_button.unset_flags (Gtk::CAN_FOCUS); - size_button.unset_flags (Gtk::CAN_FOCUS); - visual_button.unset_flags (Gtk::CAN_FOCUS); - hide_button.unset_flags (Gtk::CAN_FOCUS); - - hide_button.add (*(manage (new Image (::get_icon("hide"))))); - hide_button.show_all (); - route_group_button.signal_button_release_event().connect (sigc::mem_fun(*this, &RouteTimeAxisView::edit_click), false); + route_group_button.signal_button_release_event().connect (sigc::mem_fun(*this, &RouteTimeAxisView::route_group_click), false); playlist_button.signal_clicked().connect (sigc::mem_fun(*this, &RouteTimeAxisView::playlist_click)); automation_button.signal_clicked().connect (sigc::mem_fun(*this, &RouteTimeAxisView::automation_click)); - size_button.signal_button_release_event().connect (sigc::mem_fun(*this, &RouteTimeAxisView::size_click), false); - visual_button.signal_clicked().connect (sigc::mem_fun(*this, &RouteTimeAxisView::visual_click)); - hide_button.signal_clicked().connect (sigc::mem_fun(*this, &RouteTimeAxisView::hide_click)); - - solo_button->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::solo_press), false); - solo_button->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::solo_release), false); - mute_button->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::mute_press), false); - mute_button->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::mute_release), false); if (is_track()) { @@ -184,49 +166,40 @@ RouteTimeAxisView::RouteTimeAxisView (PublicEditor& ed, Session* sess, boost::sh } rec_enable_button->show_all (); - rec_enable_button->signal_button_press_event().connect (sigc::mem_fun(*this, &RouteUI::rec_enable_press), false); - rec_enable_button->signal_button_release_event().connect (sigc::mem_fun(*this, &RouteUI::rec_enable_release), false); controls_table.attach (*rec_enable_button, 5, 6, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0); - ARDOUR_UI::instance()->tooltips().set_tip(*rec_enable_button, _("Record")); + + if (is_midi_track()) { + ARDOUR_UI::instance()->set_tip(*rec_enable_button, _("Record (Right-click for Step Edit)")); + } else { + ARDOUR_UI::instance()->set_tip(*rec_enable_button, _("Record")); + } rec_enable_button->set_sensitive (_session->writable()); } controls_hbox.pack_start(gm.get_level_meter(), false, false); - _route->meter_change.connect (*this, ui_bind (&RouteTimeAxisView::meter_changed, this, _1), gui_context()); - _route->input()->changed.connect (*this, ui_bind (&RouteTimeAxisView::io_changed, this, _1, _2), gui_context()); - _route->output()->changed.connect (*this, ui_bind (&RouteTimeAxisView::io_changed, this, _1, _2), gui_context()); + _route->meter_change.connect (*this, invalidator (*this), bind (&RouteTimeAxisView::meter_changed, this), gui_context()); + _route->input()->changed.connect (*this, invalidator (*this), ui_bind (&RouteTimeAxisView::io_changed, this, _1, _2), gui_context()); + _route->output()->changed.connect (*this, invalidator (*this), ui_bind (&RouteTimeAxisView::io_changed, this, _1, _2), gui_context()); controls_table.attach (*mute_button, 6, 7, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0); - controls_table.attach (*solo_button, 7, 8, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0); + + if (!_route->is_master()) { + controls_table.attach (*solo_button, 7, 8, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0); + } controls_table.attach (route_group_button, 7, 8, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0); controls_table.attach (gm.get_gain_slider(), 0, 5, 1, 2, Gtk::SHRINK, Gtk::SHRINK, 0, 0); - ARDOUR_UI::instance()->tooltips().set_tip(*solo_button,_("Solo")); - ARDOUR_UI::instance()->tooltips().set_tip(*mute_button,_("Mute")); - ARDOUR_UI::instance()->tooltips().set_tip(route_group_button, _("Route Group")); - ARDOUR_UI::instance()->tooltips().set_tip(size_button,_("Display Height")); - ARDOUR_UI::instance()->tooltips().set_tip(playlist_button,_("Playlist")); - ARDOUR_UI::instance()->tooltips().set_tip(automation_button, _("Automation")); - ARDOUR_UI::instance()->tooltips().set_tip(visual_button, _("Visual options")); - ARDOUR_UI::instance()->tooltips().set_tip(hide_button, _("Hide this track")); + ARDOUR_UI::instance()->set_tip(*solo_button,_("Solo")); + ARDOUR_UI::instance()->set_tip(*mute_button,_("Mute")); + ARDOUR_UI::instance()->set_tip(route_group_button, _("Route Group")); + ARDOUR_UI::instance()->set_tip(playlist_button,_("Playlist")); + ARDOUR_UI::instance()->set_tip(automation_button, _("Automation")); label_view (); - if (0) { - - /* old school - when we used to put an extra row of buttons in place */ - - controls_table.attach (hide_button, 0, 1, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND); - controls_table.attach (visual_button, 1, 2, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND); - controls_table.attach (size_button, 2, 3, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND); - controls_table.attach (automation_button, 3, 4, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND); - - } else { - - controls_table.attach (automation_button, 6, 7, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND); - } + controls_table.attach (automation_button, 6, 7, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND); if (is_track() && track()->mode() == ARDOUR::Normal) { controls_table.attach (playlist_button, 5, 6, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND); @@ -234,19 +207,13 @@ RouteTimeAxisView::RouteTimeAxisView (PublicEditor& ed, Session* sess, boost::sh _y_position = -1; - _route->mute_changed.connect (*this, ui_bind (&RouteUI::mute_changed, this, _1), gui_context()); - _route->solo_changed.connect (*this, ui_bind (&RouteUI::solo_changed, this, _1), gui_context()); - _route->processors_changed.connect (*this, ui_bind (&RouteTimeAxisView::processors_changed, this, _1), gui_context()); - _route->NameChanged.connect (*this, boost::bind (&RouteTimeAxisView::route_name_changed, this), gui_context()); - _route->solo_isolated_changed.connect (*this, ui_bind (&RouteUI::solo_changed, this, _1), gui_context()); - + _route->processors_changed.connect (*this, invalidator (*this), ui_bind (&RouteTimeAxisView::processors_changed, this, _1), gui_context()); + _route->PropertyChanged.connect (*this, invalidator (*this), ui_bind (&RouteTimeAxisView::route_property_changed, this, _1), gui_context()); if (is_track()) { - track()->TrackModeChanged.connect (*this, boost::bind (&RouteTimeAxisView::track_mode_changed, this), gui_context()); - track()->FreezeChange.connect (*this, boost::bind (&RouteTimeAxisView::map_frozen, this), gui_context()); - track()->DiskstreamChanged.connect (*this, boost::bind (&RouteTimeAxisView::diskstream_changed, this), gui_context()); - get_diskstream()->SpeedChanged.connect (*this, boost::bind (&RouteTimeAxisView::speed_changed, this), gui_context()); + track()->FreezeChange.connect (*this, invalidator (*this), boost::bind (&RouteTimeAxisView::map_frozen, this), gui_context()); + track()->SpeedChanged.connect (*this, invalidator (*this), boost::bind (&RouteTimeAxisView::speed_changed, this), gui_context()); /* pick up the correct freeze state */ map_frozen (); @@ -254,41 +221,38 @@ RouteTimeAxisView::RouteTimeAxisView (PublicEditor& ed, Session* sess, boost::sh } _editor.ZoomChanged.connect (sigc::mem_fun(*this, &RouteTimeAxisView::reset_samples_per_unit)); + _editor.HorizontalPositionChanged.connect (sigc::mem_fun (*this, &RouteTimeAxisView::horizontal_position_changed)); ColorsChanged.connect (sigc::mem_fun (*this, &RouteTimeAxisView::color_handler)); - route_group_menu = new RouteGroupMenu ( - _session, - (RouteGroup::Property) (RouteGroup::Mute | RouteGroup::Solo | RouteGroup::Edit) - ); - - route_group_menu->GroupSelected.connect (sigc::mem_fun (*this, &RouteTimeAxisView::set_route_group_from_menu)); + PropertyList* plist = new PropertyList(); + + plist->add (ARDOUR::Properties::edit, true); + plist->add (ARDOUR::Properties::mute, true); + plist->add (ARDOUR::Properties::solo, true); + + route_group_menu = new RouteGroupMenu (_session, plist); gm.get_gain_slider().signal_scroll_event().connect(sigc::mem_fun(*this, &RouteTimeAxisView::controls_ebox_scroll), false); gm.get_gain_slider().set_name ("TrackGainFader"); + + show_name_entry (); + hide_name_label (); } RouteTimeAxisView::~RouteTimeAxisView () { - drop_references (); - drop_connections (); + CatchDeletion (this); for (list::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) { delete *i; } - delete playlist_menu; - playlist_menu = 0; - delete playlist_action_menu; playlist_action_menu = 0; delete _view; _view = 0; - for (AutomationTracks::iterator i = _automation_tracks.begin(); i != _automation_tracks.end(); ++i) { - delete i->second; - } - _automation_tracks.clear (); delete route_group_menu; @@ -301,6 +265,7 @@ RouteTimeAxisView::post_construct () update_diskstream_display (); + _subplugin_menu_map.clear (); subplugin_menu.items().clear (); _route->foreach_processor (sigc::mem_fun (*this, &RouteTimeAxisView::add_processor_to_subplugin_menu)); _route->foreach_processor (sigc::mem_fun (*this, &RouteTimeAxisView::add_existing_processor_automation_curves)); @@ -308,7 +273,7 @@ RouteTimeAxisView::post_construct () } gint -RouteTimeAxisView::edit_click (GdkEventButton *ev) +RouteTimeAxisView::route_group_click (GdkEventButton *ev) { if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) { if (_route->route_group()) { @@ -317,24 +282,15 @@ RouteTimeAxisView::edit_click (GdkEventButton *ev) return false; } - route_group_menu->rebuild (_route->route_group ()); - route_group_menu->popup (ev->button, ev->time); + WeakRouteList r; + r.push_back (route ()); + + route_group_menu->build (r); + route_group_menu->menu()->popup (ev->button, ev->time); return false; } -void -RouteTimeAxisView::set_route_group_from_menu (RouteGroup *eg) -{ - if (eg) { - eg->add (_route); - } else { - if (_route->route_group()) { - _route->route_group()->remove (_route); - } - } -} - void RouteTimeAxisView::playlist_changed () { @@ -350,18 +306,23 @@ RouteTimeAxisView::label_view () name_entry.set_text (x); } - ARDOUR_UI::instance()->tooltips().set_tip (name_entry, x); + if (x != name_label.get_text()) { + name_label.set_text (x); + } + + ARDOUR_UI::instance()->set_tip (name_entry, x); } void -RouteTimeAxisView::route_name_changed () +RouteTimeAxisView::route_property_changed (const PropertyChange& what_changed) { - label_view (); + if (what_changed.contains (ARDOUR::Properties::name)) { + label_view (); + } } void RouteTimeAxisView::take_name_changed (void *src) - { if (src != this) { label_view (); @@ -371,15 +332,7 @@ RouteTimeAxisView::take_name_changed (void *src) void RouteTimeAxisView::playlist_click () { - // always build a new action menu - - delete playlist_action_menu; - - playlist_action_menu = new Menu; - playlist_action_menu->set_name ("ArdourContextMenu"); - - build_playlist_menu (playlist_action_menu); - + build_playlist_menu (); conditionally_add_to_selection (); playlist_action_menu->popup (1, gtk_get_current_event_time()); } @@ -388,7 +341,7 @@ void RouteTimeAxisView::automation_click () { conditionally_add_to_selection (); - build_automation_action_menu (); + build_automation_action_menu (false); automation_action_menu->popup (1, gtk_get_current_event_time()); } @@ -422,44 +375,40 @@ RouteTimeAxisView::set_state (const XMLNode& node, int version) } void -RouteTimeAxisView::build_automation_action_menu () +RouteTimeAxisView::build_automation_action_menu (bool for_selection) { using namespace Menu_Helpers; - automation_action_menu = manage (new Menu); - MenuList& automation_items = automation_action_menu->items(); - automation_action_menu->set_name ("ArdourContextMenu"); - - automation_items.push_back (MenuElem (_("Show all automation"), - sigc::mem_fun(*this, &RouteTimeAxisView::show_all_automation))); - - automation_items.push_back (MenuElem (_("Show existing automation"), - sigc::mem_fun(*this, &RouteTimeAxisView::show_existing_automation))); - - automation_items.push_back (MenuElem (_("Hide all automation"), - sigc::mem_fun(*this, &RouteTimeAxisView::hide_all_automation))); - - if (subplugin_menu.get_attach_widget()) - subplugin_menu.detach(); - - automation_items.push_back (MenuElem (_("Plugins"), subplugin_menu)); - automation_items.back().set_sensitive (!subplugin_menu.items().empty()); + /* detach subplugin_menu from automation_action_menu before we delete automation_action_menu, + otherwise bad things happen (see comment for similar case in MidiTimeAxisView::build_automation_action_menu) + */ - map::iterator i; - for (i = _automation_tracks.begin(); i != _automation_tracks.end(); ++i) { + detach_menu (subplugin_menu); - automation_items.push_back (SeparatorElem()); + _main_automation_menu_map.clear (); + delete automation_action_menu; + automation_action_menu = new Menu; - delete i->second->menu_item; + MenuList& items = automation_action_menu->items(); - automation_items.push_back(CheckMenuElem (_route->describe_parameter(i->second->param), - sigc::bind (sigc::mem_fun(*this, &RouteTimeAxisView::toggle_automation_track), i->second->param))); + automation_action_menu->set_name ("ArdourContextMenu"); + + items.push_back (MenuElem (_("Show All Automation"), + sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::show_all_automation), for_selection))); + + items.push_back (MenuElem (_("Show Existing Automation"), + sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::show_existing_automation), for_selection))); + + items.push_back (MenuElem (_("Hide All Automation"), + sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::hide_all_automation), for_selection))); - i->second->menu_item = static_cast(&automation_items.back()); + items.push_back (SeparatorElem ()); + + /* Attach the plugin submenu. It may have previously been used elsewhere, + so it was detached above */ - i->second->menu_item->set_active(show_automation(i->second->param)); - //i->second->menu_item->set_active(false); - } + items.push_back (MenuElem (_("Plugins"), subplugin_menu)); + items.back().set_sensitive (!subplugin_menu.items().empty() && (!for_selection || _editor.get_selection().tracks.size() == 1));; } void @@ -467,10 +416,6 @@ RouteTimeAxisView::build_display_menu () { using namespace Menu_Helpers; - /* get the size menu ready */ - - build_size_menu (); - /* prepare it */ TimeAxisView::build_display_menu (); @@ -480,218 +425,342 @@ RouteTimeAxisView::build_display_menu () MenuList& items = display_menu->items(); display_menu->set_name ("ArdourContextMenu"); - items.push_back (MenuElem (_("Height"), *size_menu)); - items.push_back (MenuElem (_("Color"), sigc::mem_fun(*this, &RouteTimeAxisView::select_track_color))); + items.push_back (MenuElem (_("Color..."), sigc::mem_fun (*this, &RouteUI::choose_color))); + + if (_size_menu) { + detach_menu (*_size_menu); + } + build_size_menu (); + items.push_back (MenuElem (_("Height"), *_size_menu)); items.push_back (SeparatorElem()); if (!Profile->get_sae()) { items.push_back (MenuElem (_("Remote Control ID..."), sigc::mem_fun (*this, &RouteUI::open_remote_control_id_dialog))); - /* rebuild this every time */ - build_automation_action_menu (); - items.push_back (MenuElem (_("Automation"), *automation_action_menu)); + items.back().set_sensitive (_editor.get_selection().tracks.size() <= 1); items.push_back (SeparatorElem()); } // Hook for derived classes to add type specific stuff append_extra_display_menu_items (); - items.push_back (SeparatorElem()); if (is_track()) { - Menu *layers_menu = manage(new Menu); + Menu* layers_menu = manage (new Menu); MenuList &layers_items = layers_menu->items(); layers_menu->set_name("ArdourContextMenu"); RadioMenuItem::Group layers_group; - layers_items.push_back(RadioMenuElem (layers_group, _("Overlaid"), - sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::set_layer_display), Overlaid))); - layers_items.push_back(RadioMenuElem (layers_group, _("Stacked"), - sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::set_layer_display), Stacked))); + /* Find out how many overlaid/stacked tracks we have in the selection */ - items.push_back (MenuElem (_("Layers"), *layers_menu)); + int overlaid = 0; + int stacked = 0; + TrackSelection const & s = _editor.get_selection().tracks; + for (TrackSelection::const_iterator i = s.begin(); i != s.end(); ++i) { + StreamView* v = (*i)->view (); + if (!v) { + continue; + } - Menu* alignment_menu = manage (new Menu); - MenuList& alignment_items = alignment_menu->items(); - alignment_menu->set_name ("ArdourContextMenu"); + switch (v->layer_display ()) { + case Overlaid: + ++overlaid; + break; + case Stacked: + ++stacked; + break; + } + } - RadioMenuItem::Group align_group; + /* We're not connecting to signal_toggled() here; in the case where these two items are + set to be in the `inconsistent' state, it seems that one or other will end up active + as well as inconsistent (presumably due to the RadioMenuItem::Group). Then when you + select the active one, no toggled signal is emitted so nothing happens. + */ + + layers_items.push_back (RadioMenuElem (layers_group, _("Overlaid"))); + RadioMenuItem* i = dynamic_cast (&layers_items.back ()); + i->set_active (overlaid != 0 && stacked == 0); + i->set_inconsistent (overlaid != 0 && stacked != 0); + i->signal_activate().connect (sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::set_layer_display), Overlaid, true)); + + layers_items.push_back ( + RadioMenuElem (layers_group, _("Stacked"), + sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::set_layer_display), Stacked, true)) + ); + + i = dynamic_cast (&layers_items.back ()); + i->signal_activate().connect (sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::set_layer_display), Stacked, true)); + i->set_active (overlaid == 0 && stacked != 0); + i->set_inconsistent (overlaid != 0 && stacked != 0); + + items.push_back (MenuElem (_("Layers"), *layers_menu)); - alignment_items.push_back (RadioMenuElem (align_group, _("Align with existing material"), - sigc::bind (sigc::mem_fun(*this, &RouteTimeAxisView::set_align_style), ExistingMaterial))); - align_existing_item = dynamic_cast(&alignment_items.back()); - if (get_diskstream()->alignment_style() == ExistingMaterial) - align_existing_item->set_active(); + if (!Profile->get_sae()) { - alignment_items.push_back (RadioMenuElem (align_group, _("Align with capture time"), - sigc::bind (sigc::mem_fun(*this, &RouteTimeAxisView::set_align_style), CaptureTime))); - align_capture_item = dynamic_cast(&alignment_items.back()); - if (get_diskstream()->alignment_style() == CaptureTime) - align_capture_item->set_active(); + Menu* alignment_menu = manage (new Menu); + MenuList& alignment_items = alignment_menu->items(); + alignment_menu->set_name ("ArdourContextMenu"); + + RadioMenuItem::Group align_group; - if (!Profile->get_sae()) { - items.push_back (MenuElem (_("Alignment"), *alignment_menu)); - get_diskstream()->AlignmentStyleChanged.connect (route_connections, boost::bind (&RouteTimeAxisView::align_style_changed, this), gui_context()); + /* Same verbose hacks as for the layering options above */ - RadioMenuItem::Group mode_group; - items.push_back (RadioMenuElem (mode_group, _("Normal mode"), sigc::bind ( - sigc::mem_fun (*this, &RouteTimeAxisView::set_track_mode), - ARDOUR::Normal))); - normal_track_mode_item = dynamic_cast(&items.back()); + int existing = 0; + int capture = 0; + int automatic = 0; + int styles = 0; + boost::shared_ptr first_track; - items.push_back (RadioMenuElem (mode_group, _("Tape mode"), sigc::bind ( - sigc::mem_fun (*this, &RouteTimeAxisView::set_track_mode), - ARDOUR::Destructive))); - destructive_track_mode_item = dynamic_cast(&items.back()); + TrackSelection const & s = _editor.get_selection().tracks; + for (TrackSelection::const_iterator i = s.begin(); i != s.end(); ++i) { + RouteTimeAxisView* r = dynamic_cast (*i); + if (!r || !r->is_track ()) { + continue; + } - items.push_back (RadioMenuElem (mode_group, _("No layering mode"), - sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::set_track_mode), ARDOUR::NonLayered))); - non_layered_track_mode_item = dynamic_cast(&items.back()); + if (!first_track) { + first_track = r->track(); + } + + switch (r->track()->alignment_choice()) { + case Automatic: + ++automatic; + styles |= 0x1; + switch (r->track()->alignment_style()) { + case ExistingMaterial: + ++existing; + break; + case CaptureTime: + ++capture; + break; + } + break; + case UseExistingMaterial: + ++existing; + styles |= 0x2; + break; + case UseCaptureTime: + ++capture; + styles |= 0x4; + break; + } + } + bool inconsistent; + switch (styles) { + case 1: + case 2: + case 4: + inconsistent = false; + break; + default: + inconsistent = true; + break; + } + + RadioMenuItem* i; + + if (!inconsistent && first_track) { + + alignment_items.push_back (RadioMenuElem (align_group, _("Automatic (based on I/O connections)"))); + i = dynamic_cast (&alignment_items.back()); + i->set_active (automatic != 0 && existing == 0 && capture == 0); + i->signal_activate().connect (sigc::bind (sigc::mem_fun(*this, &RouteTimeAxisView::set_align_choice), i, Automatic, true)); + + switch (first_track->alignment_choice()) { + case Automatic: + switch (first_track->alignment_style()) { + case ExistingMaterial: + alignment_items.push_back (MenuElem (_("(Currently: Existing Material)"))); + break; + case CaptureTime: + alignment_items.push_back (MenuElem (_("(Currently: Capture Time)"))); + break; + } + break; + default: + break; + } + + alignment_items.push_back (RadioMenuElem (align_group, _("Align With Existing Material"))); + i = dynamic_cast (&alignment_items.back()); + i->set_active (existing != 0 && capture == 0 && automatic == 0); + i->signal_activate().connect (sigc::bind (sigc::mem_fun(*this, &RouteTimeAxisView::set_align_choice), i, UseExistingMaterial, true)); + + alignment_items.push_back (RadioMenuElem (align_group, _("Align With Capture Time"))); + i = dynamic_cast (&alignment_items.back()); + i->set_active (existing == 0 && capture != 0 && automatic == 0); + i->signal_activate().connect (sigc::bind (sigc::mem_fun(*this, &RouteTimeAxisView::set_align_choice), i, UseCaptureTime, true)); + + items.push_back (MenuElem (_("Alignment"), *alignment_menu)); + + } else { + /* show nothing */ + } + + Menu* mode_menu = manage (new Menu); + MenuList& mode_items = mode_menu->items (); + mode_menu->set_name ("ArdourContextMenu"); + RadioMenuItem::Group mode_group; - switch (track()->mode()) { - case ARDOUR::Destructive: - destructive_track_mode_item->set_active (); - break; - case ARDOUR::Normal: - normal_track_mode_item->set_active (); - break; - case ARDOUR::NonLayered: - non_layered_track_mode_item->set_active (); - break; + int normal = 0; + int tape = 0; + int non_layered = 0; + + for (TrackSelection::const_iterator i = s.begin(); i != s.end(); ++i) { + RouteTimeAxisView* r = dynamic_cast (*i); + if (!r || !r->is_track ()) { + continue; + } + + switch (r->track()->mode()) { + case Normal: + ++normal; + break; + case Destructive: + ++tape; + break; + case NonLayered: + ++non_layered; + break; + } } - } - get_diskstream()->AlignmentStyleChanged.connect (route_connections, boost::bind (&RouteTimeAxisView::align_style_changed, this), gui_context()); + mode_items.push_back (RadioMenuElem (mode_group, _("Normal Mode"))); + i = dynamic_cast (&mode_items.back ()); + i->signal_activate().connect (sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::set_track_mode), ARDOUR::Normal, true)); + i->set_active (normal != 0 && tape == 0 && non_layered == 0); + i->set_inconsistent (normal != 0 && (tape != 0 || non_layered != 0)); + + mode_items.push_back (RadioMenuElem (mode_group, _("Tape Mode"))); + i = dynamic_cast (&mode_items.back ()); + i->signal_activate().connect (sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::set_track_mode), ARDOUR::Destructive, true)); + i->set_active (normal == 0 && tape != 0 && non_layered == 0); + i->set_inconsistent (tape != 0 && (normal != 0 || non_layered != 0)); + + mode_items.push_back (RadioMenuElem (mode_group, _("Non-Layered Mode"))); + i = dynamic_cast (&mode_items.back ()); + i->signal_activate().connect (sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::set_track_mode), ARDOUR::NonLayered, true)); + i->set_active (normal == 0 && tape == 0 && non_layered != 0); + i->set_inconsistent (non_layered != 0 && (normal != 0 || tape != 0)); - mode_menu = build_mode_menu(); - if (mode_menu) items.push_back (MenuElem (_("Mode"), *mode_menu)); + } color_mode_menu = build_color_mode_menu(); - if (color_mode_menu) + if (color_mode_menu) { items.push_back (MenuElem (_("Color Mode"), *color_mode_menu)); + } items.push_back (SeparatorElem()); - } - items.push_back (CheckMenuElem (_("Active"), sigc::mem_fun(*this, &RouteUI::toggle_route_active))); - route_active_menu_item = dynamic_cast (&items.back()); - route_active_menu_item->set_active (_route->active()); + build_playlist_menu (); + items.push_back (MenuElem (_("Playlist"), *playlist_action_menu)); + items.back().set_sensitive (_editor.get_selection().tracks.size() <= 1); - items.push_back (SeparatorElem()); - items.push_back (MenuElem (_("Hide"), sigc::mem_fun(*this, &RouteTimeAxisView::hide_click))); - if (!Profile->get_sae()) { - items.push_back (MenuElem (_("Remove"), sigc::mem_fun(*this, &RouteUI::remove_this_route))); - } else { - items.push_front (SeparatorElem()); - items.push_front (MenuElem (_("Delete"), sigc::mem_fun(*this, &RouteUI::remove_this_route))); - } -} + route_group_menu->detach (); -static bool __reset_item (RadioMenuItem* item, RadioMenuItem* item_2) -{ - item->set_active (); - item_2->set_active (); - return false; -} + WeakRouteList r; + for (TrackSelection::iterator i = _editor.get_selection().tracks.begin(); i != _editor.get_selection().tracks.end(); ++i) { + RouteTimeAxisView* rtv = dynamic_cast (*i); + if (rtv) { + r.push_back (rtv->route ()); + } + } -void -RouteTimeAxisView::set_track_mode (TrackMode mode) -{ - RadioMenuItem* item; - RadioMenuItem* other_item; - RadioMenuItem* other_item_2; + if (r.empty ()) { + r.push_back (route ()); + } + + route_group_menu->build (r); + items.push_back (MenuElem (_("Route Group"), *route_group_menu->menu ())); - switch (mode) { - case ARDOUR::Normal: - item = normal_track_mode_item; - other_item = non_layered_track_mode_item; - other_item_2 = destructive_track_mode_item; - break; - case ARDOUR::NonLayered: - item = non_layered_track_mode_item; - other_item = normal_track_mode_item; - other_item_2 = destructive_track_mode_item; - break; - case ARDOUR::Destructive: - item = destructive_track_mode_item; - other_item = normal_track_mode_item; - other_item_2 = non_layered_track_mode_item; - break; - default: - fatal << string_compose (_("programming error: %1 %2"), "illegal track mode in RouteTimeAxisView::set_track_mode", mode) << endmsg; - /*NOTREACHED*/ - return; - } + build_automation_action_menu (true); + items.push_back (MenuElem (_("Automation"), *automation_action_menu)); - if (item && other_item && other_item_2 && item->get_active() && track()->mode() != mode) { - _set_track_mode (track().get(), mode, other_item, other_item_2); + items.push_back (SeparatorElem()); } -} - -void -RouteTimeAxisView::_set_track_mode (Track* track, TrackMode mode, RadioMenuItem* reset_item, RadioMenuItem* reset_item_2) -{ - bool needs_bounce; - if (!track->can_use_mode (mode, needs_bounce)) { + int active = 0; + int inactive = 0; + TrackSelection const & s = _editor.get_selection().tracks; + for (TrackSelection::const_iterator i = s.begin(); i != s.end(); ++i) { + RouteTimeAxisView* r = dynamic_cast (*i); + if (!r) { + continue; + } - if (!needs_bounce) { - /* cannot be done */ - Glib::signal_idle().connect (sigc::bind (sigc::ptr_fun (__reset_item), reset_item, reset_item_2)); - return; + if (r->route()->active()) { + ++active; } else { - cerr << "would bounce this one\n"; - return; + ++inactive; } } - track->set_mode (mode); - - rec_enable_button->remove (); - - switch (mode) { - case ARDOUR::NonLayered: - case ARDOUR::Normal: - rec_enable_button->add (*(manage (new Image (::get_icon (X_("record_normal_red")))))); - break; - case ARDOUR::Destructive: - rec_enable_button->add (*(manage (new Image (::get_icon (X_("record_tape_red")))))); - break; + items.push_back (CheckMenuElem (_("Active"))); + CheckMenuItem* i = dynamic_cast (&items.back()); + bool click_sets_active = true; + if (active > 0 && inactive == 0) { + i->set_active (true); + click_sets_active = false; + } else if (active > 0 && inactive > 0) { + i->set_inconsistent (true); } + i->signal_activate().connect (sigc::bind (sigc::mem_fun (*this, &RouteUI::set_route_active), click_sets_active, true)); - rec_enable_button->show_all (); + items.push_back (SeparatorElem()); + items.push_back (MenuElem (_("Hide"), sigc::bind (sigc::mem_fun(_editor, &PublicEditor::hide_track_in_display), this, true))); + if (!Profile->get_sae()) { + items.push_back (MenuElem (_("Remove"), sigc::bind (sigc::mem_fun(*this, &RouteUI::remove_this_route), true))); + } else { + items.push_front (SeparatorElem()); + items.push_front (MenuElem (_("Delete"), sigc::bind (sigc::mem_fun(*this, &RouteUI::remove_this_route), true))); + } } void -RouteTimeAxisView::track_mode_changed () +RouteTimeAxisView::set_track_mode (TrackMode mode, bool apply_to_selection) { - RadioMenuItem* item; + if (apply_to_selection) { + _editor.get_selection().tracks.foreach_route_time_axis (boost::bind (&RouteTimeAxisView::set_track_mode, _1, mode, false)); + } else { - switch (track()->mode()) { - case ARDOUR::Normal: - item = normal_track_mode_item; - break; - case ARDOUR::NonLayered: - item = non_layered_track_mode_item; - break; - case ARDOUR::Destructive: - item = destructive_track_mode_item; - break; - default: - fatal << string_compose (_("programming error: %1 %2"), "illegal track mode in RouteTimeAxisView::set_track_mode", track()->mode()) << endmsg; - /*NOTREACHED*/ - return; - } + bool needs_bounce; - item->set_active (); + if (!track()->can_use_mode (mode, needs_bounce)) { + + if (!needs_bounce) { + /* cannot be done */ + return; + } else { + cerr << "would bounce this one\n"; + return; + } + } + + track()->set_mode (mode); + + rec_enable_button->remove (); + + switch (mode) { + case ARDOUR::NonLayered: + case ARDOUR::Normal: + rec_enable_button->add (*(manage (new Image (::get_icon (X_("record_normal_red")))))); + break; + case ARDOUR::Destructive: + rec_enable_button->add (*(manage (new Image (::get_icon (X_("record_tape_red")))))); + break; + } + + rec_enable_button->show_all (); + } } void -RouteTimeAxisView::show_timestretch (nframes_t start, nframes_t end) +RouteTimeAxisView::show_timestretch (framepos_t start, framepos_t end) { double x1; double x2; @@ -795,14 +864,15 @@ RouteTimeAxisView::set_height (uint32_t h) snprintf (buf, sizeof (buf), "%u", height); xml_node->add_property ("height", buf); - if (height >= hNormal) { + if (height >= preset_height (HeightNormal)) { + + _controls_padding_table.set_row_spacings (2); + reset_meter(); - show_name_entry (); - hide_name_label (); gm.get_gain_slider().show(); mute_button->show(); - if (!_route || _route->is_control()) { + if (!_route || _route->is_monitor()) { solo_button->hide(); } else { solo_button->show(); @@ -811,24 +881,21 @@ RouteTimeAxisView::set_height (uint32_t h) rec_enable_button->show(); route_group_button.show(); - hide_button.show(); - visual_button.show(); - size_button.show(); automation_button.show(); if (is_track() && track()->mode() == ARDOUR::Normal) { playlist_button.show(); } - } else if (height >= hSmaller) { + } else if (height >= preset_height (HeightSmaller)) { + + _controls_padding_table.set_row_spacings (2); reset_meter(); - show_name_entry (); - hide_name_label (); gm.get_gain_slider().hide(); mute_button->show(); - if (!_route || _route->is_control()) { + if (!_route || _route->is_monitor()) { solo_button->hide(); } else { solo_button->show(); @@ -837,9 +904,6 @@ RouteTimeAxisView::set_height (uint32_t h) rec_enable_button->show(); route_group_button.hide (); - hide_button.hide (); - visual_button.hide (); - size_button.hide (); automation_button.hide (); if (is_track() && track()->mode() == ARDOUR::Normal) { @@ -848,50 +912,23 @@ RouteTimeAxisView::set_height (uint32_t h) } else { - - /* don't allow name_entry to be hidden while - it has focus, otherwise the GUI becomes unusable. - */ - - if (name_entry.has_focus()) { - if (name_entry.get_text() != _route->name()) { - name_entry_changed (); - } - controls_ebox.grab_focus (); - } - - hide_name_entry (); - show_name_label (); - - gm.get_gain_slider().hide(); - mute_button->hide(); - solo_button->hide(); - if (rec_enable_button) - rec_enable_button->hide(); - - route_group_button.hide (); - hide_button.hide (); - visual_button.hide (); - size_button.hide (); - automation_button.hide (); - playlist_button.hide (); - name_label.set_text (_route->name()); + _controls_padding_table.set_row_spacings (0); + } - if (height_changed) { + if (height_changed && !no_redraw) { /* only emit the signal if the height really changed */ _route->gui_changed ("track_height", (void *) 0); /* EMIT_SIGNAL */ } } void -RouteTimeAxisView::select_track_color () +RouteTimeAxisView::set_color (Gdk::Color const & c) { - if (RouteUI::choose_color ()) { - - if (_view) { - _view->apply_color (_color, StreamView::RegionColor); - } + RouteUI::set_color (c); + + if (_view) { + _view->apply_color (_color, StreamView::RegionColor); } } @@ -901,13 +938,21 @@ RouteTimeAxisView::reset_samples_per_unit () set_samples_per_unit (_editor.get_current_zoom()); } +void +RouteTimeAxisView::horizontal_position_changed () +{ + if (_view) { + _view->horizontal_position_changed (); + } +} + void RouteTimeAxisView::set_samples_per_unit (double spu) { double speed = 1.0; - if (get_diskstream() != 0) { - speed = get_diskstream()->speed(); + if (track()) { + speed = track()->speed(); } if (_view) { @@ -918,42 +963,21 @@ RouteTimeAxisView::set_samples_per_unit (double spu) } void -RouteTimeAxisView::align_style_changed () +RouteTimeAxisView::set_align_choice (RadioMenuItem* mitem, AlignChoice choice, bool apply_to_selection) { - switch (get_diskstream()->alignment_style()) { - case ExistingMaterial: - if (!align_existing_item->get_active()) { - align_existing_item->set_active(); - } - break; - case CaptureTime: - if (!align_capture_item->get_active()) { - align_capture_item->set_active(); - } - break; - } -} + if (!mitem->get_active()) { + /* this is one of the two calls made when these radio menu items change status. this one + is for the item that became inactive, and we want to ignore it. + */ + return; + } -void -RouteTimeAxisView::set_align_style (AlignStyle style) -{ - RadioMenuItem* item; - - switch (style) { - case ExistingMaterial: - item = align_existing_item; - break; - case CaptureTime: - item = align_capture_item; - break; - default: - fatal << string_compose (_("programming error: %1 %2"), "illegal align style in RouteTimeAxisView::set_align_style", style) << endmsg; - /*NOTREACHED*/ - return; - } - - if (item->get_active()) { - get_diskstream()->set_align_style (style); + if (apply_to_selection) { + _editor.get_selection().tracks.foreach_route_time_axis (boost::bind (&RouteTimeAxisView::set_align_choice, _1, mitem, choice, false)); + } else { + if (track ()) { + track()->set_align_choice (choice); + } } } @@ -963,15 +987,18 @@ RouteTimeAxisView::rename_current_playlist () ArdourPrompter prompter (true); string name; - boost::shared_ptr ds = get_diskstream(); - if (!ds || ds->destructive()) + boost::shared_ptr tr = track(); + if (!tr || tr->destructive()) { return; + } - boost::shared_ptr pl = ds->playlist(); - if (!pl) + boost::shared_ptr pl = tr->playlist(); + if (!pl) { return; + } - prompter.set_prompt (_("Name for playlist")); + prompter.set_title (_("Rename Playlist")); + prompter.set_prompt (_("New name for playlist:")); prompter.set_initial_text (pl->name()); prompter.add_button (_("Rename"), Gtk::RESPONSE_ACCEPT); prompter.set_response_sensitive (Gtk::RESPONSE_ACCEPT, false); @@ -1029,17 +1056,19 @@ RouteTimeAxisView::use_copy_playlist (bool prompt, vector ds = get_diskstream(); - if (!ds || ds->destructive()) + boost::shared_ptr tr = track (); + if (!tr || tr->destructive()) { return; + } - boost::shared_ptr pl = ds->playlist(); - if (!pl) + boost::shared_ptr pl = tr->playlist(); + if (!pl) { return; + } name = pl->name(); - if (route_group() && route_group()->is_active()) { + if (route_group() && route_group()->is_active() && route_group()->enabled_property (ARDOUR::Properties::edit.property_id)) { name = resolve_new_group_playlist_name(name, playlists_before_op); } @@ -1054,7 +1083,8 @@ RouteTimeAxisView::use_copy_playlist (bool prompt, vectoruse_copy_playlist (); - ds->playlist()->set_name (name); + tr->use_copy_playlist (); + tr->playlist()->set_name (name); } } @@ -1081,17 +1111,19 @@ RouteTimeAxisView::use_new_playlist (bool prompt, vector ds = get_diskstream(); - if (!ds || ds->destructive()) + boost::shared_ptr tr = track (); + if (!tr || tr->destructive()) { return; + } - boost::shared_ptr pl = ds->playlist(); - if (!pl) + boost::shared_ptr pl = tr->playlist(); + if (!pl) { return; + } name = pl->name(); - if (route_group() && route_group()->is_active()) { + if (route_group() && route_group()->is_active() && route_group()->enabled_property (ARDOUR::Properties::edit.property_id)) { name = resolve_new_group_playlist_name(name,playlists_before_op); } @@ -1104,7 +1136,8 @@ RouteTimeAxisView::use_new_playlist (bool prompt, vectoruse_new_playlist (); - ds->playlist()->set_name (name); + tr->use_new_playlist (); + tr->playlist()->set_name (name); } } void RouteTimeAxisView::clear_playlist () { - boost::shared_ptr ds = get_diskstream(); - if (!ds || ds->destructive()) + boost::shared_ptr tr = track (); + if (!tr || tr->destructive()) { return; + } - boost::shared_ptr pl = ds->playlist(); - if (!pl) + boost::shared_ptr pl = tr->playlist(); + if (!pl) { return; + } _editor.clear_playlist (pl); } @@ -1142,20 +1177,15 @@ RouteTimeAxisView::clear_playlist () void RouteTimeAxisView::speed_changed () { - Gtkmm2ext::UI::instance()->call_slot (boost::bind (&RouteTimeAxisView::reset_samples_per_unit, this)); -} - -void -RouteTimeAxisView::diskstream_changed () -{ - Gtkmm2ext::UI::instance()->call_slot (boost::bind (&RouteTimeAxisView::update_diskstream_display, this)); + Gtkmm2ext::UI::instance()->call_slot (invalidator (*this), boost::bind (&RouteTimeAxisView::reset_samples_per_unit, this)); } void RouteTimeAxisView::update_diskstream_display () { - if (!get_diskstream()) // bus + if (!track()) { return; + } map_frozen (); } @@ -1214,16 +1244,16 @@ RouteTimeAxisView::set_selected_regionviews (RegionSelection& regions) * @param results List to add things to. */ void -RouteTimeAxisView::get_selectables (nframes_t start, nframes_t end, double top, double bot, list& results) +RouteTimeAxisView::get_selectables (framepos_t start, framepos_t end, double top, double bot, list& results) { double speed = 1.0; - if (get_diskstream() != 0) { - speed = get_diskstream()->speed(); + if (track() != 0) { + speed = track()->speed(); } - nframes_t start_adjusted = session_frame_to_track_frame(start, speed); - nframes_t end_adjusted = session_frame_to_track_frame(end, speed); + framepos_t const start_adjusted = session_frame_to_track_frame(start, speed); + framepos_t const end_adjusted = session_frame_to_track_frame(end, speed); if ((_view && ((top < 0.0 && bot < 0.0))) || touched (top, bot)) { _view->get_selectables (start_adjusted, end_adjusted, top, bot, results); @@ -1254,34 +1284,6 @@ RouteTimeAxisView::get_inverted_selectables (Selection& sel, list& return; } -bool -RouteTimeAxisView::show_automation(Evoral::Parameter param) -{ - return (_show_automation.find(param) != _show_automation.end()); -} - -/** Retuns 0 if track for \a param doesn't exist. - */ -RouteTimeAxisView::RouteAutomationNode* -RouteTimeAxisView::automation_track (Evoral::Parameter param) -{ - map::iterator i = _automation_tracks.find (param); - - if (i != _automation_tracks.end()) { - return i->second; - } else { - return 0; - } -} - -/** Shorthand for GainAutomation, etc. - */ -RouteTimeAxisView::RouteAutomationNode* -RouteTimeAxisView::automation_track (AutomationType type) -{ - return automation_track (Evoral::Parameter(type)); -} - RouteGroup* RouteTimeAxisView::route_group () const { @@ -1297,10 +1299,10 @@ RouteTimeAxisView::name() const boost::shared_ptr RouteTimeAxisView::playlist () const { - boost::shared_ptr ds; + boost::shared_ptr tr; - if ((ds = get_diskstream()) != 0) { - return ds->playlist(); + if ((tr = track()) != 0) { + return tr->playlist(); } else { return boost::shared_ptr (); } @@ -1328,73 +1330,54 @@ RouteTimeAxisView::name_entry_changed () ARDOUR_UI::instance()->popup_error (_("A track already exists with that name")); name_entry.set_text (_route->name()); } else if (_session->route_name_internal (x)) { - ARDOUR_UI::instance()->popup_error (_("You cannot create a track with that name as it is reserved for Ardour")); + ARDOUR_UI::instance()->popup_error (string_compose (_("You cannot create a track with that name as it is reserved for %1"), + PROGRAM_NAME)); name_entry.set_text (_route->name()); } else { _route->set_name (x); } } -void -RouteTimeAxisView::visual_click () -{ - popup_display_menu (0); -} - -void -RouteTimeAxisView::hide_click () -{ - // LAME fix for hide_button refresh fix - hide_button.set_sensitive(false); - - _editor.hide_track_in_display (*this); - - hide_button.set_sensitive(true); -} - boost::shared_ptr -RouteTimeAxisView::find_next_region (nframes_t pos, RegionPoint point, int32_t dir) +RouteTimeAxisView::find_next_region (framepos_t pos, RegionPoint point, int32_t dir) { - boost::shared_ptr stream; - boost::shared_ptr playlist; + boost::shared_ptr pl = playlist (); - if ((stream = get_diskstream()) != 0 && (playlist = stream->playlist()) != 0) { - return playlist->find_next_region (pos, point, dir); + if (pl) { + return pl->find_next_region (pos, point, dir); } return boost::shared_ptr (); } -nframes64_t -RouteTimeAxisView::find_next_region_boundary (nframes64_t pos, int32_t dir) +framepos_t +RouteTimeAxisView::find_next_region_boundary (framepos_t pos, int32_t dir) { - boost::shared_ptr stream; - boost::shared_ptr playlist; + boost::shared_ptr pl = playlist (); - if ((stream = get_diskstream()) != 0 && (playlist = stream->playlist()) != 0) { - return playlist->find_next_region_boundary (pos, dir); + if (pl) { + return pl->find_next_region_boundary (pos, dir); } return -1; } -bool +void RouteTimeAxisView::cut_copy_clear (Selection& selection, CutCopyOp op) { boost::shared_ptr what_we_got; - boost::shared_ptr ds = get_diskstream(); + boost::shared_ptr tr = track (); boost::shared_ptr playlist; - bool ret = false; - if (ds == 0) { + if (tr == 0) { /* route is a bus, not a track */ - return false; + return; } - playlist = ds->playlist(); + playlist = tr->playlist(); TimeSelection time (selection.time); - float speed = ds->speed(); + float const speed = tr->speed(); if (speed != 1.0f) { for (TimeSelection::iterator i = time.begin(); i != time.end(); ++i) { (*i).start = session_frame_to_track_frame((*i).start, speed); @@ -1402,13 +1385,19 @@ RouteTimeAxisView::cut_copy_clear (Selection& selection, CutCopyOp op) } } - XMLNode &before = playlist->get_state(); + playlist->clear_changes (); + playlist->clear_owned_changes (); + switch (op) { case Cut: if ((what_we_got = playlist->cut (time)) != 0) { _editor.get_cut_buffer().add (what_we_got); - _session->add_command( new MementoCommand(*playlist.get(), &before, &playlist->get_state())); - ret = true; + + vector cmds; + playlist->rdiff (cmds); + _session->add_commands (cmds); + + _session->add_command (new StatefulDiffCommand (playlist)); } break; case Copy: @@ -1419,24 +1408,25 @@ RouteTimeAxisView::cut_copy_clear (Selection& selection, CutCopyOp op) case Clear: if ((what_we_got = playlist->cut (time)) != 0) { - _session->add_command( new MementoCommand(*playlist, &before, &playlist->get_state())); + + vector cmds; + playlist->rdiff (cmds); + _session->add_commands (cmds); + _session->add_command (new StatefulDiffCommand (playlist)); what_we_got->release (); - ret = true; } break; } - - return ret; } bool -RouteTimeAxisView::paste (nframes_t pos, float times, Selection& selection, size_t nth) +RouteTimeAxisView::paste (framepos_t pos, float times, Selection& selection, size_t nth) { if (!is_track()) { return false; } - boost::shared_ptr playlist = get_diskstream()->playlist(); + boost::shared_ptr pl = playlist (); PlaylistSelection::iterator p; for (p = selection.playlists.begin(); p != selection.playlists.end() && nth; ++p, --nth) {} @@ -1445,80 +1435,80 @@ RouteTimeAxisView::paste (nframes_t pos, float times, Selection& selection, size return false; } - if (get_diskstream()->speed() != 1.0f) { - pos = session_frame_to_track_frame(pos, get_diskstream()->speed() ); + DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("paste to %1\n", pos)); + + if (track()->speed() != 1.0f) { + pos = session_frame_to_track_frame (pos, track()->speed()); + DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("modified paste to %1\n", pos)); } - XMLNode &before = playlist->get_state(); - playlist->paste (*p, pos, times); - _session->add_command( new MementoCommand(*playlist, &before, &playlist->get_state())); + pl->clear_changes (); + pl->paste (*p, pos, times); + _session->add_command (new StatefulDiffCommand (pl)); return true; } -TimeAxisView::Children -RouteTimeAxisView::get_child_list() -{ - TimeAxisView::Children redirect_children; - - for (Children::iterator i = children.begin(); i != children.end(); ++i) { - if (!(*i)->hidden()) { - redirect_children.push_back(*i); - } - } - return redirect_children; -} - +struct PlaylistSorter { + bool operator() (boost::shared_ptr a, boost::shared_ptr b) const { + return a->sort_id() < b->sort_id(); + } +}; void -RouteTimeAxisView::build_playlist_menu (Gtk::Menu * menu) +RouteTimeAxisView::build_playlist_menu () { using namespace Menu_Helpers; - if (!menu || !is_track()) { + if (!is_track()) { return; } - MenuList& playlist_items = menu->items(); - menu->set_name ("ArdourContextMenu"); - playlist_items.clear(); - - delete playlist_menu; + delete playlist_action_menu; + playlist_action_menu = new Menu; + playlist_action_menu->set_name ("ArdourContextMenu"); - playlist_menu = new Menu; - playlist_menu->set_name ("ArdourContextMenu"); + MenuList& playlist_items = playlist_action_menu->items(); + playlist_action_menu->set_name ("ArdourContextMenu"); + playlist_items.clear(); - vector > playlists; - boost::shared_ptr ds = get_diskstream(); + vector > playlists, playlists_tr; + boost::shared_ptr tr = track(); RadioMenuItem::Group playlist_group; _session->playlists->get (playlists); - for (vector >::iterator i = playlists.begin(); i != playlists.end(); ++i) { - - if ((*i)->get_orig_diskstream_id() == ds->id()) { - playlist_items.push_back (RadioMenuElem (playlist_group, (*i)->name(), sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::use_playlist), - boost::weak_ptr (*i)))); - - if (ds->playlist()->id() == (*i)->id()) { - static_cast(&playlist_items.back())->set_active(); - } - } else if (ds->playlist()->id() == (*i)->id()) { - playlist_items.push_back (RadioMenuElem (playlist_group, (*i)->name(), sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::use_playlist), - boost::weak_ptr(*i)))); - static_cast(&playlist_items.back())->set_active(); - + /* find the playlists for this diskstream */ + for (vector >::iterator i = playlists.begin(); i != playlists.end(); ++i) { + if (((*i)->get_orig_diskstream_id() == tr->diskstream_id()) || (tr->playlist()->id() == (*i)->id())) { + playlists_tr.push_back(*i); + } + } + + /* sort the playlists */ + PlaylistSorter cmp; + sort (playlists_tr.begin(), playlists_tr.end(), cmp); + + /* add the playlists to the menu */ + for (vector >::iterator i = playlists_tr.begin(); i != playlists_tr.end(); ++i) { + playlist_items.push_back (RadioMenuElem (playlist_group, (*i)->name())); + RadioMenuItem *item = static_cast(&playlist_items.back()); + item->signal_toggled().connect(sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::use_playlist), item, boost::weak_ptr (*i))); + + if (tr->playlist()->id() == (*i)->id()) { + item->set_active(); + } } - + playlist_items.push_back (SeparatorElem()); - playlist_items.push_back (MenuElem (_("Rename"), sigc::mem_fun(*this, &RouteTimeAxisView::rename_current_playlist))); + playlist_items.push_back (MenuElem (_("Rename..."), sigc::mem_fun(*this, &RouteTimeAxisView::rename_current_playlist))); playlist_items.push_back (SeparatorElem()); - if (!route_group() || !route_group()->is_active()) { - playlist_items.push_back (MenuElem (_("New"), sigc::bind(sigc::mem_fun(_editor, &PublicEditor::new_playlists), this))); - playlist_items.push_back (MenuElem (_("New Copy"), sigc::bind(sigc::mem_fun(_editor, &PublicEditor::copy_playlists), this))); + if (!route_group() || !route_group()->is_active() || !route_group()->enabled_property (ARDOUR::Properties::edit.property_id)) { + playlist_items.push_back (MenuElem (_("New..."), sigc::bind(sigc::mem_fun(_editor, &PublicEditor::new_playlists), this))); + playlist_items.push_back (MenuElem (_("New Copy..."), sigc::bind(sigc::mem_fun(_editor, &PublicEditor::copy_playlists), this))); } else { // Use a label which tells the user what is happening @@ -1531,14 +1521,19 @@ RouteTimeAxisView::build_playlist_menu (Gtk::Menu * menu) playlist_items.push_back (MenuElem (_("Clear Current"), sigc::bind(sigc::mem_fun(_editor, &PublicEditor::clear_playlists), this))); playlist_items.push_back (SeparatorElem()); - playlist_items.push_back (MenuElem(_("Select from all ..."), sigc::mem_fun(*this, &RouteTimeAxisView::show_playlist_selector))); + playlist_items.push_back (MenuElem(_("Select from all..."), sigc::mem_fun(*this, &RouteTimeAxisView::show_playlist_selector))); } void -RouteTimeAxisView::use_playlist (boost::weak_ptr wpl) +RouteTimeAxisView::use_playlist (RadioMenuItem *item, boost::weak_ptr wpl) { assert (is_track()); + // exit if we were triggered by deactivating the old playlist + if (!item->get_active()) { + return; + } + boost::shared_ptr pl (wpl.lock()); if (!pl) { @@ -1548,17 +1543,17 @@ RouteTimeAxisView::use_playlist (boost::weak_ptr wpl) boost::shared_ptr apl = boost::dynamic_pointer_cast (pl); if (apl) { - if (get_diskstream()->playlist() == apl) { - // radio button cotnrols mean this function is called for both the - // old and new playlist + if (track()->playlist() == apl) { + // exit when use_playlist is called by the creation of the playlist menu + // or the playlist choice is unchanged return; } - get_diskstream()->use_playlist (apl); + track()->use_playlist (apl); + RouteGroup* rg = route_group(); - if (route_group() && route_group()->is_active()) { - //PBD::stacktrace(cerr, 20); - std::string group_string = "."+route_group()->name()+"."; + if (rg && rg->is_active() && rg->enabled_property (ARDOUR::Properties::edit.property_id)) { + std::string group_string = "." + rg->name() + "."; std::string take_name = apl->name(); std::string::size_type idx = take_name.find(group_string); @@ -1568,7 +1563,7 @@ RouteTimeAxisView::use_playlist (boost::weak_ptr wpl) take_name = take_name.substr(idx + group_string.length()); // find the bit containing the take number / name - boost::shared_ptr rl (route_group()->route_list()); + boost::shared_ptr rl (rg->route_list()); for (RouteList::const_iterator i = rl->begin(); i != rl->end(); ++i) { if ( (*i) == this->route()) { @@ -1579,17 +1574,16 @@ RouteTimeAxisView::use_playlist (boost::weak_ptr wpl) boost::shared_ptr track = boost::dynamic_pointer_cast(*i); if (!track) { - std::cerr << "route " << (*i)->name() << " is not a Track" << std::endl; continue; } boost::shared_ptr ipl = session()->playlists->by_name(playlist_name); if (!ipl) { // No playlist for this track for this take yet, make it - track->diskstream()->use_new_playlist(); - track->diskstream()->playlist()->set_name(playlist_name); + track->use_new_playlist(); + track->playlist()->set_name(playlist_name); } else { - track->diskstream()->use_playlist(ipl); + track->use_playlist(ipl); } } } @@ -1638,31 +1632,30 @@ RouteTimeAxisView::color_handler () reset_meter(); } +/** Toggle an automation track for a fully-specified Parameter (type,channel,id) + * Will add track if necessary. + */ void -RouteTimeAxisView::toggle_automation_track (Evoral::Parameter param) +RouteTimeAxisView::toggle_automation_track (const Evoral::Parameter& param) { - RouteAutomationNode* node = automation_track(param); - - if (!node) - return; - - bool showit = node->menu_item->get_active(); - - if (showit != node->track->marked_for_display()) { - if (showit) { - node->track->set_marked_for_display (true); - node->track->canvas_display()->show(); - node->track->get_state_node()->add_property ("shown", X_("yes")); - } else { - node->track->set_marked_for_display (false); - node->track->hide (); - node->track->get_state_node()->add_property ("shown", X_("no")); - } - - /* now trigger a redisplay */ - - if (!no_redraw) { - _route->gui_changed (X_("track_height"), (void *) 0); /* EMIT_SIGNAL */ + boost::shared_ptr track = automation_child (param); + Gtk::CheckMenuItem* menu = automation_child_menu_item (param); + + if (!track) { + /* it doesn't exist yet, so we don't care about the button state: just add it */ + create_automation_child (param, true); + } else { + assert (menu); + bool yn = menu->get_active(); + if (track->set_visibility (menu->get_active()) && yn) { + + /* we made it visible, now trigger a redisplay. if it was hidden, then automation_track_hidden() + will have done that for us. + */ + + if (!no_redraw) { + _route->gui_changed (X_("track_height"), (void *) 0); /* EMIT_SIGNAL */ + } } } } @@ -1670,117 +1663,145 @@ RouteTimeAxisView::toggle_automation_track (Evoral::Parameter param) void RouteTimeAxisView::automation_track_hidden (Evoral::Parameter param) { - RouteAutomationNode* ran = automation_track(param); - if (!ran) { + boost::shared_ptr track = automation_child (param); + + if (!track) { return; } + Gtk::CheckMenuItem* menu = automation_child_menu_item (param); + // if Evoral::Parameter::operator< doesn't obey strict weak ordering, we may crash here.... - _show_automation.erase(param); - ran->track->get_state_node()->add_property (X_("shown"), X_("no")); + track->get_state_node()->add_property (X_("shown"), X_("no")); - if (ran->menu_item && !_hidden) { - ran->menu_item->set_active (false); + if (menu && !_hidden) { + ignore_toggle = true; + menu->set_active (false); + ignore_toggle = false; } - _route->gui_changed ("visible_tracks", (void *) 0); /* EMIT_SIGNAL */ + if (_route && !no_redraw) { + _route->gui_changed ("track_height", (void *) 0); /* EMIT_SIGNAL */ + } } void -RouteTimeAxisView::show_all_automation () +RouteTimeAxisView::show_all_automation (bool apply_to_selection) { - no_redraw = true; - - /* Show our automation */ - - map::iterator i; - for (i = _automation_tracks.begin(); i != _automation_tracks.end(); ++i) { - i->second->track->set_marked_for_display (true); - i->second->track->canvas_display()->show(); - i->second->track->get_state_node()->add_property ("shown", X_("yes")); - i->second->menu_item->set_active(true); - } - - - /* Show processor automation */ - - for (list::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) { - for (vector::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) { - if ((*ii)->view == 0) { - add_processor_automation_curve ((*i)->processor, (*ii)->what); + if (apply_to_selection) { + _editor.get_selection().tracks.foreach_route_time_axis (boost::bind (&RouteTimeAxisView::show_all_automation, _1, false)); + } else { + no_redraw = true; + + /* Show our automation */ + + for (AutomationTracks::iterator i = _automation_tracks.begin(); i != _automation_tracks.end(); ++i) { + i->second->set_marked_for_display (true); + i->second->canvas_display()->show(); + i->second->get_state_node()->add_property ("shown", X_("yes")); + + Gtk::CheckMenuItem* menu = automation_child_menu_item (i->first); + + if (menu) { + menu->set_active(true); } - - (*ii)->menu_item->set_active (true); } + + + /* Show processor automation */ + + for (list::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) { + for (vector::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) { + if ((*ii)->view == 0) { + add_processor_automation_curve ((*i)->processor, (*ii)->what); + } + + (*ii)->menu_item->set_active (true); + } + } + + no_redraw = false; + + /* Redraw */ + + _route->gui_changed ("track_height", (void *) 0); /* EMIT_SIGNAL */ } - - no_redraw = false; - - /* Redraw */ - - _route->gui_changed ("visible_tracks", (void *) 0); /* EMIT_SIGNAL */ } - + void -RouteTimeAxisView::show_existing_automation () +RouteTimeAxisView::show_existing_automation (bool apply_to_selection) { - no_redraw = true; - - /* Show our automation */ - - map::iterator i; - for (i = _automation_tracks.begin(); i != _automation_tracks.end(); ++i) { - if (i->second->track->line() && i->second->track->line()->npoints() > 0) { - i->second->track->set_marked_for_display (true); - i->second->track->canvas_display()->show(); - i->second->track->get_state_node()->add_property ("shown", X_("yes")); - i->second->menu_item->set_active(true); + if (apply_to_selection) { + _editor.get_selection().tracks.foreach_route_time_axis (boost::bind (&RouteTimeAxisView::show_existing_automation, _1, false)); + } else { + no_redraw = true; + + /* Show our automation */ + + for (AutomationTracks::iterator i = _automation_tracks.begin(); i != _automation_tracks.end(); ++i) { + if (i->second->has_automation()) { + i->second->set_marked_for_display (true); + i->second->canvas_display()->show(); + i->second->get_state_node()->add_property ("shown", X_("yes")); + + Gtk::CheckMenuItem* menu = automation_child_menu_item (i->first); + if (menu) { + menu->set_active(true); + } + } } - } - - - /* Show processor automation */ - - for (list::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) { - for (vector::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) { - if ((*ii)->view != 0 && (*i)->processor->data().control((*ii)->what)->list()->size() > 0) { - (*ii)->menu_item->set_active (true); + + + /* Show processor automation */ + + for (list::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) { + for (vector::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) { + if ((*ii)->view != 0 && (*i)->processor->control((*ii)->what)->list()->size() > 0) { + (*ii)->menu_item->set_active (true); + } } } + + no_redraw = false; + + _route->gui_changed ("track_height", (void *) 0); /* EMIT_SIGNAL */ } - - no_redraw = false; - - _route->gui_changed ("visible_tracks", (void *) 0); /* EMIT_SIGNAL */ } void -RouteTimeAxisView::hide_all_automation () +RouteTimeAxisView::hide_all_automation (bool apply_to_selection) { - no_redraw = true; - - /* Hide our automation */ - - for (map::iterator i = _automation_tracks.begin(); i != _automation_tracks.end(); ++i) { - i->second->track->set_marked_for_display (false); - i->second->track->hide (); - i->second->track->get_state_node()->add_property ("shown", X_("no")); - i->second->menu_item->set_active (false); - } - - /* Hide processor automation */ - - for (list::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) { - for (vector::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) { - (*ii)->menu_item->set_active (false); + if (apply_to_selection) { + _editor.get_selection().tracks.foreach_route_time_axis (boost::bind (&RouteTimeAxisView::hide_all_automation, _1, false)); + } else { + no_redraw = true; + + /* Hide our automation */ + + for (AutomationTracks::iterator i = _automation_tracks.begin(); i != _automation_tracks.end(); ++i) { + i->second->set_marked_for_display (false); + i->second->hide (); + i->second->get_state_node()->add_property ("shown", X_("no")); + + Gtk::CheckMenuItem* menu = automation_child_menu_item (i->first); + + if (menu) { + menu->set_active (false); + } } + + /* Hide processor automation */ + + for (list::iterator i = processor_automation.begin(); i != processor_automation.end(); ++i) { + for (vector::iterator ii = (*i)->lines.begin(); ii != (*i)->lines.end(); ++ii) { + (*ii)->menu_item->set_active (false); + } + } + + no_redraw = false; + _route->gui_changed ("track_height", (void *) 0); /* EMIT_SIGNAL */ } - - _show_automation.clear(); - - no_redraw = false; - _route->gui_changed ("visible_tracks", (void *) 0); /* EMIT_SIGNAL */ } @@ -1788,13 +1809,11 @@ void RouteTimeAxisView::region_view_added (RegionView* rv) { /* XXX need to find out if automation children have automationstreamviews. If yes, no ghosts */ - if(is_audio_track()) { - for (Children::iterator i = children.begin(); i != children.end(); ++i) { - boost::shared_ptr atv; - - if ((atv = boost::dynamic_pointer_cast (*i)) != 0) { - atv->add_ghost(rv); - } + for (Children::iterator i = children.begin(); i != children.end(); ++i) { + boost::shared_ptr atv; + + if ((atv = boost::dynamic_pointer_cast (*i)) != 0) { + atv->add_ghost(rv); } } @@ -1868,9 +1887,10 @@ RouteTimeAxisView::add_processor_automation_curve (boost::shared_ptr ProcessorAutomationNode* pan; if ((pan = find_processor_automation_node (processor, what)) == 0) { - error << _("programming error: ") - << string_compose (X_("processor automation curve for %1:%2 not registered with track!"), - processor->name(), what) + /* session state may never have been saved with new plugin */ + error << _("programming error: ") + << string_compose (X_("processor automation curve for %1:%2/%3/%4 not registered with track!"), + processor->name(), what.type(), (int) what.channel(), what.id() ) << endmsg; /*NOTREACHED*/ return; @@ -1887,14 +1907,14 @@ RouteTimeAxisView::add_processor_automation_curve (boost::shared_ptr /* FIXME: ew */ char state_name[256]; - snprintf (state_name, sizeof (state_name), "Redirect-%s-%" PRIu32, legalize_for_xml_node (processor->name()).c_str(), what.id()); + snprintf (state_name, sizeof (state_name), "%s-%" PRIu32, legalize_for_xml_node (processor->name()).c_str(), what.id()); boost::shared_ptr control - = boost::dynamic_pointer_cast(processor->data().control(what, true)); + = boost::dynamic_pointer_cast(processor->control(what, true)); pan->view = boost::shared_ptr( - new AutomationTimeAxisView (_session, _route, processor, control, - _editor, *this, false, parent_canvas, name, state_name)); + new AutomationTimeAxisView (_session, _route, processor, control, control->parameter (), + _editor, *this, false, parent_canvas, name, state_name)); pan->view->Hiding.connect (sigc::bind (sigc::mem_fun(*this, &RouteTimeAxisView::processor_automation_track_hidden), pan, processor)); @@ -1922,7 +1942,9 @@ RouteTimeAxisView::processor_automation_track_hidden (RouteTimeAxisView::Process i->mark_automation_visible (pan->what, false); - _route->gui_changed ("visible_tracks", (void *) 0); /* EMIT_SIGNAL */ + if (!no_redraw) { + _route->gui_changed ("track_height", (void *) 0); /* EMIT_SIGNAL */ + } } void @@ -1949,7 +1971,7 @@ RouteTimeAxisView::add_existing_processor_automation_curves (boost::weak_ptr track, bool show) +RouteTimeAxisView::add_automation_child (Evoral::Parameter param, boost::shared_ptr track, bool show) { using namespace Menu_Helpers; @@ -1970,23 +1992,25 @@ RouteTimeAxisView::add_automation_child(Evoral::Parameter param, boost::shared_p } } - _automation_tracks.insert(std::make_pair(param, new RouteAutomationNode(param, NULL, track))); - - if (hideit) { - track->hide (); - } else { - _show_automation.insert (param); + _automation_tracks[param] = track; + track->set_visibility (!hideit); - if (!no_redraw) { - _route->gui_changed ("visible_tracks", (void *) 0); /* EMIT_SIGNAL */ - } + if (!no_redraw) { + _route->gui_changed ("track_height", (void *) 0); /* EMIT_SIGNAL */ } - build_display_menu(); + if (!EventTypeMap::instance().is_midi_parameter(param)) { + /* MIDI-related parameters are always in the menu, there's no + reason to rebuild the menu just because we added a automation + lane for one of them. But if we add a non-MIDI automation + lane, then we need to invalidate the display menu. + */ + delete display_menu; + display_menu = 0; + } } - void RouteTimeAxisView::add_processor_to_subplugin_menu (boost::weak_ptr p) { @@ -2046,6 +2070,8 @@ RouteTimeAxisView::add_processor_to_subplugin_menu (boost::weak_ptr p items.push_back (CheckMenuElem (name)); mitem = dynamic_cast (&items.back()); + _subplugin_menu_map[*i] = mitem; + if (has_visible_automation.find((*i)) != has_visible_automation.end()) { mitem->set_active(true); } @@ -2106,10 +2132,7 @@ RouteTimeAxisView::processor_menu_item_toggled (RouteTimeAxisView::ProcessorAuto } if (redraw && !no_redraw) { - - /* now trigger a redisplay */ - - _route->gui_changed ("visible_tracks", (void *) 0); /* EMIT_SIGNAL */ + _route->gui_changed ("track_height", (void *) 0); /* EMIT_SIGNAL */ } } @@ -2128,6 +2151,7 @@ RouteTimeAxisView::processors_changed (RouteProcessorChange c) (*i)->valid = false; } + _subplugin_menu_map.clear (); subplugin_menu.items().clear (); _route->foreach_processor (sigc::mem_fun (*this, &RouteTimeAxisView::add_processor_to_subplugin_menu)); @@ -2153,8 +2177,8 @@ RouteTimeAxisView::processors_changed (RouteProcessorChange c) i = tmp; } - if (deleted_processor_automation) { - _route->gui_changed ("visible_tracks", this); + if (deleted_processor_automation && !no_redraw) { + _route->gui_changed ("track_height", this); } } @@ -2188,14 +2212,19 @@ RouteTimeAxisView::update_rec_display () } void -RouteTimeAxisView::set_layer_display (LayerDisplay d) +RouteTimeAxisView::set_layer_display (LayerDisplay d, bool apply_to_selection) { - if (_view) { - _view->set_layer_display (d); + if (apply_to_selection) { + _editor.get_selection().tracks.foreach_route_time_axis (boost::bind (&RouteTimeAxisView::set_layer_display, _1, d, false)); + } else { + + if (_view) { + _view->set_layer_display (d); + } + + ensure_xml_node (); + xml_node->add_property (N_("layer-display"), enum_2_string (d)); } - - ensure_xml_node (); - xml_node->add_property (N_("layer-display"), enum_2_string (d)); } LayerDisplay @@ -2215,10 +2244,11 @@ boost::shared_ptr RouteTimeAxisView::automation_child(Evoral::Parameter param) { AutomationTracks::iterator i = _automation_tracks.find(param); - if (i != _automation_tracks.end()) - return i->second->track; - else + if (i != _automation_tracks.end()) { + return i->second; + } else { return boost::shared_ptr(); + } } void @@ -2257,9 +2287,9 @@ RouteTimeAxisView::clear_meter () } void -RouteTimeAxisView::meter_changed (void *src) +RouteTimeAxisView::meter_changed () { - ENSURE_GUI_THREAD (*this, &RouteTimeAxisView::meter_changed, src) + ENSURE_GUI_THREAD (*this, &RouteTimeAxisView::meter_changed) reset_meter(); } @@ -2270,10 +2300,11 @@ RouteTimeAxisView::io_changed (IOChange /*change*/, void */*src*/) } void -RouteTimeAxisView::build_underlay_menu(Gtk::Menu* parent_menu) { +RouteTimeAxisView::build_underlay_menu(Gtk::Menu* parent_menu) +{ using namespace Menu_Helpers; - if(!_underlay_streams.empty()) { + if (!_underlay_streams.empty()) { MenuList& parent_items = parent_menu->items(); Menu* gs_menu = manage (new Menu); gs_menu->set_name ("ArdourContextMenu"); @@ -2291,7 +2322,7 @@ RouteTimeAxisView::build_underlay_menu(Gtk::Menu* parent_menu) { bool RouteTimeAxisView::set_underlay_state() { - if(!underlay_xml_node) { + if (!underlay_xml_node) { return false; } @@ -2302,7 +2333,7 @@ RouteTimeAxisView::set_underlay_state() for (niter = nlist.begin(); niter != nlist.end(); ++niter) { child_node = *niter; - if(child_node->name() != "Underlay") { + if (child_node->name() != "Underlay") { continue; } @@ -2310,7 +2341,7 @@ RouteTimeAxisView::set_underlay_state() if (prop) { PBD::ID id (prop->value()); - RouteTimeAxisView* v = _editor.get_route_view_by_id (id); + RouteTimeAxisView* v = _editor.get_route_view_by_route_id (id); if (v) { add_underlay(v->view(), false); @@ -2322,16 +2353,16 @@ RouteTimeAxisView::set_underlay_state() } void -RouteTimeAxisView::add_underlay(StreamView* v, bool update_xml) +RouteTimeAxisView::add_underlay (StreamView* v, bool update_xml) { - if(!v) { + if (!v) { return; } RouteTimeAxisView& other = v->trackview(); - if(find(_underlay_streams.begin(), _underlay_streams.end(), v) == _underlay_streams.end()) { - if(find(other._underlay_mirrors.begin(), other._underlay_mirrors.end(), this) != other._underlay_mirrors.end()) { + if (find(_underlay_streams.begin(), _underlay_streams.end(), v) == _underlay_streams.end()) { + if (find(other._underlay_mirrors.begin(), other._underlay_mirrors.end(), this) != other._underlay_mirrors.end()) { fatal << _("programming error: underlay reference pointer pairs are inconsistent!") << endmsg; /*NOTREACHED*/ } @@ -2341,8 +2372,8 @@ RouteTimeAxisView::add_underlay(StreamView* v, bool update_xml) v->foreach_regionview(sigc::mem_fun(*this, &RouteTimeAxisView::add_ghost)); - if(update_xml) { - if(!underlay_xml_node) { + if (update_xml) { + if (!underlay_xml_node) { ensure_xml_node(); underlay_xml_node = xml_node->add_child("Underlays"); } @@ -2355,19 +2386,19 @@ RouteTimeAxisView::add_underlay(StreamView* v, bool update_xml) } void -RouteTimeAxisView::remove_underlay(StreamView* v) +RouteTimeAxisView::remove_underlay (StreamView* v) { - if(!v) { + if (!v) { return; } UnderlayList::iterator it = find(_underlay_streams.begin(), _underlay_streams.end(), v); RouteTimeAxisView& other = v->trackview(); - if(it != _underlay_streams.end()) { + if (it != _underlay_streams.end()) { UnderlayMirrorList::iterator gm = find(other._underlay_mirrors.begin(), other._underlay_mirrors.end(), this); - if(gm == other._underlay_mirrors.end()) { + if (gm == other._underlay_mirrors.end()) { fatal << _("programming error: underlay reference pointer pairs are inconsistent!") << endmsg; /*NOTREACHED*/ } @@ -2377,7 +2408,7 @@ RouteTimeAxisView::remove_underlay(StreamView* v) _underlay_streams.erase(it); other._underlay_mirrors.erase(gm); - if(underlay_xml_node) { + if (underlay_xml_node) { underlay_xml_node->remove_nodes_and_delete("id", v->trackview().route()->id().to_s()); } } @@ -2388,18 +2419,61 @@ RouteTimeAxisView::set_button_names () { rec_enable_button_label.set_text (_("r")); - if (Config->get_solo_control_is_listen_control()) { - switch (Config->get_listen_position()) { - case AfterFaderListen: - solo_button_label.set_text (_("A")); - break; - case PreFaderListen: - solo_button_label.set_text (_("P")); - break; - } - } else { - solo_button_label.set_text (_("s")); + if (_route && _route->solo_safe()) { + solo_button_label.set_text (X_("!")); + } else { + if (Config->get_solo_control_is_listen_control()) { + switch (Config->get_listen_position()) { + case AfterFaderListen: + solo_button_label.set_text (_("A")); + break; + case PreFaderListen: + solo_button_label.set_text (_("P")); + break; + } + } else { + solo_button_label.set_text (_("s")); + } + } + mute_button_label.set_text (_("m")); +} + +Gtk::CheckMenuItem* +RouteTimeAxisView::automation_child_menu_item (Evoral::Parameter param) +{ + ParameterMenuMap::iterator i = _main_automation_menu_map.find (param); + if (i != _main_automation_menu_map.end()) { + return i->second; + } + + i = _subplugin_menu_map.find (param); + if (i != _subplugin_menu_map.end()) { + return i->second; } - mute_button_label.set_text (_("m")); + return 0; +} + +void +RouteTimeAxisView::create_gain_automation_child (const Evoral::Parameter& param, bool show) +{ + boost::shared_ptr c = _route->gain_control(); + if (!c) { + error << "Route has no gain automation, unable to add automation track view." << endmsg; + return; + } + + gain_track.reset (new AutomationTimeAxisView (_session, + _route, _route->amp(), c, param, + _editor, + *this, + false, + parent_canvas, + _route->amp()->describe_parameter(param))); + + if (_view) { + _view->foreach_regionview (sigc::mem_fun (*gain_track.get(), &TimeAxisView::add_ghost)); + } + + add_automation_child (Evoral::Parameter(GainAutomation), gain_track, show); }