X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Feditor_routes.cc;h=809dfd267f962aa719f59c0acdb70ed699d503f1;hb=735d791e420c3e4944fdbc8ac7f6a26251d90d87;hp=1c78d5ca549b3170e1171f61add8525b98eb1a06;hpb=6d531b82e03c309d740b253f9ef559fae664825b;p=ardour.git diff --git a/gtk2_ardour/editor_routes.cc b/gtk2_ardour/editor_routes.cc index 1c78d5ca54..809dfd267f 100644 --- a/gtk2_ardour/editor_routes.cc +++ b/gtk2_ardour/editor_routes.cc @@ -28,14 +28,22 @@ #include "pbd/unwind.h" #include "ardour/debug.h" +#include "ardour/audio_track.h" #include "ardour/midi_track.h" #include "ardour/route.h" +#include "ardour/selection.h" #include "ardour/session.h" +#include "ardour/solo_isolate_control.h" +#include "ardour/utils.h" +#include "ardour/vca.h" +#include "ardour/vca_manager.h" #include "gtkmm2ext/cell_renderer_pixbuf_multi.h" #include "gtkmm2ext/cell_renderer_pixbuf_toggle.h" #include "gtkmm2ext/treeutils.h" +#include "widgets/tooltips.h" + #include "actions.h" #include "ardour_ui.h" #include "audio_time_axis.h" @@ -46,13 +54,16 @@ #include "keyboard.h" #include "midi_time_axis.h" #include "mixer_strip.h" +#include "plugin_setup_dialog.h" #include "route_sorter.h" +#include "vca_time_axis.h" #include "utils.h" -#include "i18n.h" +#include "pbd/i18n.h" using namespace std; using namespace ARDOUR; +using namespace ArdourWidgets; using namespace ARDOUR_UI_UTILS; using namespace PBD; using namespace Gtk; @@ -69,15 +80,16 @@ struct ColumnInfo { EditorRoutes::EditorRoutes (Editor* e) : EditorComponent (e) , _ignore_reorder (false) + , _ignore_selection_change (false) , _no_redisplay (false) , _adding_routes (false) , _route_deletion_in_progress (false) + , _redisplay_on_resume (false) , _redisplay_active (0) , _queue_tv_update (0) , _menu (0) , old_focus (0) - , selection_countdown (0) - , name_editable (0) + , name_editable (0) { static const int column_width = 22; @@ -106,6 +118,23 @@ EditorRoutes::EditorRoutes (Editor* e) rec_state_column->set_expand(false); rec_state_column->set_fixed_width(column_width); + + // Record safe toggle + CellRendererPixbufMulti* rec_safe_renderer = manage (new CellRendererPixbufMulti ()); + + rec_safe_renderer->set_pixbuf (0, ::get_icon("rec-safe-disabled")); + rec_safe_renderer->set_pixbuf (1, ::get_icon("rec-safe-enabled")); + rec_safe_renderer->signal_changed().connect (sigc::mem_fun (*this, &EditorRoutes::on_tv_rec_safe_toggled)); + + TreeViewColumn* rec_safe_column = manage (new TreeViewColumn(_("RS"), *rec_safe_renderer)); + rec_safe_column->add_attribute(rec_safe_renderer->property_state(), _columns.rec_safe); + rec_safe_column->add_attribute(rec_safe_renderer->property_visible(), _columns.is_track); + rec_safe_column->set_sizing(TREE_VIEW_COLUMN_FIXED); + rec_safe_column->set_alignment(ALIGN_CENTER); + rec_safe_column->set_expand(false); + rec_safe_column->set_fixed_width(column_width); + + // MIDI Input Active CellRendererPixbufMulti* input_active_col_renderer = manage (new CellRendererPixbufMulti()); @@ -166,7 +195,7 @@ EditorRoutes::EditorRoutes (Editor* e) TreeViewColumn* solo_isolate_state_column = manage (new TreeViewColumn("SI", *solo_iso_renderer)); solo_isolate_state_column->add_attribute(solo_iso_renderer->property_state(), _columns.solo_isolate_state); - solo_isolate_state_column->add_attribute(solo_iso_renderer->property_visible(), _columns.solo_visible); + solo_isolate_state_column->add_attribute(solo_iso_renderer->property_visible(), _columns.solo_lock_iso_visible); solo_isolate_state_column->set_sizing(TREE_VIEW_COLUMN_FIXED); solo_isolate_state_column->set_alignment(ALIGN_CENTER); solo_isolate_state_column->set_expand(false); @@ -181,7 +210,7 @@ EditorRoutes::EditorRoutes (Editor* e) TreeViewColumn* solo_safe_state_column = manage (new TreeViewColumn(_("SS"), *solo_safe_renderer)); solo_safe_state_column->add_attribute(solo_safe_renderer->property_state(), _columns.solo_safe_state); - solo_safe_state_column->add_attribute(solo_safe_renderer->property_visible(), _columns.solo_visible); + solo_safe_state_column->add_attribute(solo_safe_renderer->property_visible(), _columns.solo_lock_iso_visible); solo_safe_state_column->set_sizing(TREE_VIEW_COLUMN_FIXED); solo_safe_state_column->set_alignment(ALIGN_CENTER); solo_safe_state_column->set_expand(false); @@ -193,6 +222,7 @@ EditorRoutes::EditorRoutes (Editor* e) _display.append_column (*input_active_column); _display.append_column (*rec_state_column); + _display.append_column (*rec_safe_column); _display.append_column (*mute_state_column); _display.append_column (*solo_state_column); _display.append_column (*solo_isolate_state_column); @@ -203,35 +233,35 @@ EditorRoutes::EditorRoutes (Editor* e) Gtk::Label* l; ColumnInfo ci[] = { - { 0, _("Name"), _("Track/Bus Name") }, - { 1, S_("TrackVisible|V"), _("Track/Bus visible ?") }, - { 2, S_("TrackActive|A"), _("Track/Bus active ?") }, - { 3, S_("MidiInput|I"), _("MIDI input enabled") }, - { 4, S_("Rec|R"), _("Record enabled") }, - { 5, S_("Mute|M"), _("Muted") }, - { 6, S_("Solo|S"), _("Soloed") }, - { 7, S_("SoloIso|SI"), _("Solo Isolated") }, - { 8, S_("SoloLock|SS"), _("Solo Safe (Locked)") }, + { 0, _("Name"), _("Track/Bus Name") }, + { 1, S_("Visible|V"), _("Track/Bus visible ?") }, + { 2, S_("Active|A"), _("Track/Bus active ?") }, + { 3, S_("MidiInput|I"), _("MIDI input enabled") }, + { 4, S_("Rec|R"), _("Record enabled") }, + { 5, S_("Rec|RS"), _("Record Safe") }, + { 6, S_("Mute|M"), _("Muted") }, + { 7, S_("Solo|S"), _("Soloed") }, + { 8, S_("SoloIso|SI"), _("Solo Isolated") }, + { 9, S_("SoloLock|SS"), _("Solo Safe (Locked)") }, { -1, 0, 0 } }; for (int i = 0; ci[i].index >= 0; ++i) { col = _display.get_column (ci[i].index); l = manage (new Label (ci[i].label)); - ARDOUR_UI::instance()->set_tip (*l, ci[i].tooltip); + set_tooltip (*l, ci[i].tooltip); col->set_widget (*l); l->show (); } _display.set_headers_visible (true); - _display.get_selection()->set_mode (SELECTION_SINGLE); + _display.get_selection()->set_mode (SELECTION_MULTIPLE); _display.get_selection()->set_select_function (sigc::mem_fun (*this, &EditorRoutes::selection_filter)); _display.get_selection()->signal_changed().connect (sigc::mem_fun (*this, &EditorRoutes::selection_changed)); _display.set_reorderable (true); _display.set_name (X_("EditGroupList")); _display.set_rules_hint (true); _display.set_size_request (100, -1); - _display.add_object_drag (_columns.route.index(), "routes"); CellRendererText* name_cell = dynamic_cast (_display.get_column_cell_renderer (_name_column)); @@ -274,6 +304,7 @@ EditorRoutes::EditorRoutes (Editor* e) active_col->set_sizing (TREE_VIEW_COLUMN_FIXED); active_col->set_fixed_width (30); active_col->set_alignment (ALIGN_CENTER); + active_col->add_attribute (active_cell->property_visible(), _columns.no_vca); _model->signal_row_deleted().connect (sigc::mem_fun (*this, &EditorRoutes::row_deleted)); _model->signal_rows_reordered().connect (sigc::mem_fun (*this, &EditorRoutes::reordered)); @@ -289,7 +320,7 @@ EditorRoutes::EditorRoutes (Editor* e) _display.set_enable_search (false); - Route::SyncOrderKeys.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::sync_treeview_from_order_keys, this), gui_context()); + Route::PluginSetup.connect_same_thread (*this, boost::bind (&EditorRoutes::plugin_setup, this, _1, _2, _3)); } bool @@ -330,7 +361,6 @@ EditorRoutes::enter_notify (GdkEventCrossing*) /* arm counter so that ::selection_filter() will deny selecting anything for the * next two attempts to change selection status. */ - selection_countdown = 2; _scroller.grab_focus (); Keyboard::magic_widget_grab_focus (); return false; @@ -339,8 +369,6 @@ EditorRoutes::enter_notify (GdkEventCrossing*) bool EditorRoutes::leave_notify (GdkEventCrossing*) { - selection_countdown = 0; - if (old_focus) { old_focus->grab_focus (); old_focus = 0; @@ -360,6 +388,13 @@ EditorRoutes::set_session (Session* s) if (_session) { _session->SoloChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::solo_changed_so_update_mute, this), gui_context()); _session->RecordStateChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_rec_display, this), gui_context()); + + /* TODO: check if these needs to be tied in with DisplaySuspender + * Given that the UI is single-threaded and DisplaySuspender is only used + * in loops in the UI thread all should be fine. + */ + _session->BatchUpdateStart.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::suspend_redisplay, this), gui_context()); + _session->BatchUpdateEnd.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::resume_redisplay, this), gui_context()); } } @@ -384,17 +419,38 @@ EditorRoutes::on_input_active_changed (std::string const & path_string) void EditorRoutes::on_tv_rec_enable_changed (std::string const & path_string) { - DisplaySuspender ds; // Get the model row that has been toggled. Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string)); TimeAxisView* tv = row[_columns.tv]; - RouteTimeAxisView *rtv = dynamic_cast (tv); + StripableTimeAxisView* stv = dynamic_cast (tv); + + if (!stv || !stv->stripable()) { + return; + } + + boost::shared_ptr ac = stv->stripable()->rec_enable_control(); - if (rtv && rtv->track()) { - boost::shared_ptr rl (new RouteList); - rl->push_back (rtv->route()); - _session->set_record_enabled (rl, !rtv->track()->record_enabled(), Session::rt_cleanup); + if (ac) { + ac->set_value (!ac->get_value(), Controllable::UseGroup); + } +} + +void +EditorRoutes::on_tv_rec_safe_toggled (std::string const & path_string) +{ + Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string)); + TimeAxisView* tv = row[_columns.tv]; + StripableTimeAxisView* stv = dynamic_cast (tv); + + if (!stv || !stv->stripable()) { + return; + } + + boost::shared_ptr ac (stv->stripable()->rec_safe_control()); + + if (ac) { + ac->set_value (!ac->get_value(), Controllable::UseGroup); } } @@ -405,12 +461,16 @@ EditorRoutes::on_tv_mute_enable_toggled (std::string const & path_string) Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string)); TimeAxisView *tv = row[_columns.tv]; - RouteTimeAxisView *rtv = dynamic_cast (tv); + StripableTimeAxisView* stv = dynamic_cast (tv); + + if (!stv || !stv->stripable()) { + return; + } - if (rtv != 0) { - boost::shared_ptr rl (new RouteList); - rl->push_back (rtv->route()); - _session->set_mute (rl, !rtv->route()->muted(), Session::rt_cleanup); + boost::shared_ptr ac (stv->stripable()->mute_control()); + + if (ac) { + ac->set_value (!ac->get_value(), Controllable::UseGroup); } } @@ -421,16 +481,16 @@ EditorRoutes::on_tv_solo_enable_toggled (std::string const & path_string) Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string)); TimeAxisView *tv = row[_columns.tv]; - RouteTimeAxisView* rtv = dynamic_cast (tv); + StripableTimeAxisView* stv = dynamic_cast (tv); - if (rtv != 0) { - boost::shared_ptr rl (new RouteList); - rl->push_back (rtv->route()); - if (Config->get_solo_control_is_listen_control()) { - _session->set_listen (rl, !rtv->route()->listening_via_monitor(), Session::rt_cleanup); - } else { - _session->set_solo (rl, !rtv->route()->self_soloed(), Session::rt_cleanup); - } + if (!stv || !stv->stripable()) { + return; + } + + boost::shared_ptr ac (stv->stripable()->solo_control()); + + if (ac) { + ac->set_value (!ac->get_value(), Controllable::UseGroup); } } @@ -441,10 +501,16 @@ EditorRoutes::on_tv_solo_isolate_toggled (std::string const & path_string) Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string)); TimeAxisView *tv = row[_columns.tv]; - RouteTimeAxisView* rtv = dynamic_cast (tv); + StripableTimeAxisView* stv = dynamic_cast (tv); - if (rtv) { - rtv->route()->set_solo_isolated (!rtv->route()->solo_isolated(), this); + if (!stv || !stv->stripable()) { + return; + } + + boost::shared_ptr ac (stv->stripable()->solo_isolate_control()); + + if (ac) { + ac->set_value (!ac->get_value(), Controllable::UseGroup); } } @@ -455,10 +521,16 @@ EditorRoutes::on_tv_solo_safe_toggled (std::string const & path_string) Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string)); TimeAxisView *tv = row[_columns.tv]; - RouteTimeAxisView* rtv = dynamic_cast (tv); + StripableTimeAxisView* stv = dynamic_cast (tv); - if (rtv) { - rtv->route()->set_solo_safe (!rtv->route()->solo_safe(), this); + if (!stv || !stv->stripable()) { + return; + } + + boost::shared_ptr ac (stv->stripable()->solo_safe_control()); + + if (ac) { + ac->set_value (!ac->get_value(), Controllable::UseGroup); } } @@ -481,17 +553,7 @@ EditorRoutes::build_menu () items.push_back (MenuElem (_("Hide All Audio Busses"), sigc::mem_fun (*this, &EditorRoutes::hide_all_audiobus))); items.push_back (MenuElem (_("Show All Midi Tracks"), sigc::mem_fun (*this, &EditorRoutes::show_all_miditracks))); items.push_back (MenuElem (_("Hide All Midi Tracks"), sigc::mem_fun (*this, &EditorRoutes::hide_all_miditracks))); - items.push_back (MenuElem (_("Show Tracks With Regions Under Playhead"), sigc::mem_fun (*this, &EditorRoutes::show_tracks_with_regions_at_playhead))); -} - -void -EditorRoutes::show_menu () -{ - if (_menu == 0) { - build_menu (); - } - - _menu->popup (1, gtk_get_current_event_time()); + items.push_back (MenuElem (_("Only Show Tracks with Regions Under Playhead"), sigc::mem_fun (*this, &EditorRoutes::show_tracks_with_regions_at_playhead))); } void @@ -508,7 +570,6 @@ EditorRoutes::redisplay_real () for (n = 0, position = 0, i = rows.begin(); i != rows.end(); ++i) { TimeAxisView *tv = (*i)[_columns.tv]; - boost::shared_ptr route = (*i)[_columns.route]; if (tv == 0) { // just a "title" row @@ -516,7 +577,7 @@ EditorRoutes::redisplay_real () } bool visible = tv->marked_for_display (); - + /* show or hide the TimeAxisView */ if (visible) { position += tv->show_at (position, n, &_editor->edit_controls_vbox); @@ -549,20 +610,28 @@ EditorRoutes::redisplay_real () void EditorRoutes::redisplay () { - if (_no_redisplay || !_session || _session->deletion_in_progress()) { + if (!_session || _session->deletion_in_progress()) { + return; + } + + if (_no_redisplay) { + _redisplay_on_resume = true; return; } // model deprecated g_atomic_int_exchange_and_add(, 1) - g_atomic_int_inc(&_redisplay_active); - if (!g_atomic_int_compare_and_exchange (&_redisplay_active, 1, 1)) { + g_atomic_int_inc(const_cast(&_redisplay_active)); + if (!g_atomic_int_compare_and_exchange (const_cast(&_redisplay_active), 1, 1)) { + /* recursive re-display can happen if redisplay shows/hides a TrackView + * which has children and their display status changes as result. + */ return; } redisplay_real (); - while (!g_atomic_int_compare_and_exchange (&_redisplay_active, 1, 0)) { - g_atomic_int_set(&_redisplay_active, 1); + while (!g_atomic_int_compare_and_exchange (const_cast(&_redisplay_active), 1, 0)) { + g_atomic_int_set(const_cast(&_redisplay_active), 1); redisplay_real (); } } @@ -570,31 +639,35 @@ EditorRoutes::redisplay () void EditorRoutes::row_deleted (Gtk::TreeModel::Path const &) { + if (!_session || _session->deletion_in_progress()) { + return; + } /* this happens as the second step of a DnD within the treeview, and * when a route is actually removed. we don't differentiate between * the two cases. * - * note that the sync_orders_keys() step may not actually change any - * RID's (e.g. the last track may be removed, so all other tracks keep - * the same RID), which means that no redisplay would happen. so we - * have to force a redisplay. + * note that the sync_presentation_info_from_treeview() step may not + * actually change any presentation info (e.g. the last track may be + * removed, so all other tracks keep the same presentation info), which + * means that no redisplay would happen. so we have to force a + * redisplay. */ DEBUG_TRACE (DEBUG::OrderKeys, "editor routes treeview row deleted\n"); DisplaySuspender ds; - sync_order_keys_from_treeview (); + sync_presentation_info_from_treeview (); } void EditorRoutes::reordered (TreeModel::Path const &, TreeModel::iterator const &, int* /*what*/) { - /* reordering implies that RID's will change, so sync_order_keys() will - cause a redisplay. + /* reordering implies that RID's will change, so + sync_presentation_info_from_treeview() will cause a redisplay. */ DEBUG_TRACE (DEBUG::OrderKeys, "editor routes treeview reordered\n"); - sync_order_keys_from_treeview (); + sync_presentation_info_from_treeview (); } void @@ -627,98 +700,153 @@ EditorRoutes::active_changed (std::string const & path) } Gtk::TreeModel::Row row = *_model->get_iter (path); - boost::shared_ptr route = row[_columns.route]; - bool const active = row[_columns.active]; - route->set_active (!active, this); + boost::shared_ptr stripable = row[_columns.stripable]; + boost::shared_ptr route = boost::dynamic_pointer_cast (stripable); + if (route) { + bool const active = row[_columns.active]; + route->set_active (!active, this); + } } void -EditorRoutes::routes_added (list routes) +EditorRoutes::time_axis_views_added (list tavs) { PBD::Unwinder at (_adding_routes, true); bool from_scratch = (_model->children().size() == 0); Gtk::TreeModel::Children::iterator insert_iter = _model->children().end(); for (Gtk::TreeModel::Children::iterator it = _model->children().begin(); it != _model->children().end(); ++it) { - boost::shared_ptr r = (*it)[_columns.route]; - if (r->order_key() == (routes.front()->route()->order_key() + routes.size())) { + boost::shared_ptr r = (*it)[_columns.stripable]; + + if (r->presentation_info().order() == (tavs.front()->stripable()->presentation_info().order() + tavs.size())) { insert_iter = it; break; } } - DisplaySuspender ds; - - _display.set_model (Glib::RefPtr()); + { + PBD::Unwinder uw (_ignore_selection_change, true); + _display.set_model (Glib::RefPtr()); + } - for (list::iterator x = routes.begin(); x != routes.end(); ++x) { + for (list::iterator x = tavs.begin(); x != tavs.end(); ++x) { - boost::shared_ptr midi_trk = boost::dynamic_pointer_cast ((*x)->route()); + VCATimeAxisView* vtav = dynamic_cast (*x); + RouteTimeAxisView* rtav = dynamic_cast (*x); TreeModel::Row row = *(_model->insert (insert_iter)); - row[_columns.text] = (*x)->route()->name(); - row[_columns.visible] = (*x)->marked_for_display(); - row[_columns.active] = (*x)->route()->active (); - row[_columns.tv] = *x; - row[_columns.route] = (*x)->route (); - row[_columns.is_track] = (boost::dynamic_pointer_cast ((*x)->route()) != 0); + boost::shared_ptr stripable; + boost::shared_ptr midi_trk; - if (midi_trk) { - row[_columns.is_input_active] = midi_trk->input_active (); - row[_columns.is_midi] = true; - } else { + if (vtav) { + + stripable = vtav->vca(); + + row[_columns.is_track] = false; row[_columns.is_input_active] = false; row[_columns.is_midi] = false; + row[_columns.no_vca] = false; + + } else if (rtav) { + + stripable = rtav->route (); + midi_trk= boost::dynamic_pointer_cast (stripable); + + row[_columns.is_track] = (boost::dynamic_pointer_cast (stripable) != 0); + row[_columns.no_vca] = true; + + if (midi_trk) { + row[_columns.is_input_active] = midi_trk->input_active (); + row[_columns.is_midi] = true; + } else { + row[_columns.is_input_active] = false; + row[_columns.is_midi] = false; + } + } + + if (!stripable) { + continue; } - row[_columns.mute_state] = (*x)->route()->muted() ? Gtkmm2ext::ExplicitActive : Gtkmm2ext::Off; - row[_columns.solo_state] = RouteUI::solo_active_state ((*x)->route()); - row[_columns.solo_visible] = !(*x)->route()->is_master (); - row[_columns.solo_isolate_state] = (*x)->route()->solo_isolated(); - row[_columns.solo_safe_state] = (*x)->route()->solo_safe(); + row[_columns.text] = stripable->name(); + row[_columns.visible] = (*x)->marked_for_display(); + row[_columns.active] = true; + row[_columns.tv] = *x; + row[_columns.stripable] = stripable; + row[_columns.mute_state] = RouteUI::mute_active_state (_session, stripable); + row[_columns.solo_state] = RouteUI::solo_active_state (stripable); + row[_columns.solo_visible] = !stripable->is_master (); + row[_columns.solo_lock_iso_visible] = row[_columns.solo_visible] && row[_columns.no_vca]; + row[_columns.solo_isolate_state] = RouteUI::solo_isolate_active_state (stripable); + row[_columns.solo_safe_state] = RouteUI::solo_safe_active_state (stripable); row[_columns.name_editable] = true; - boost::weak_ptr wr ((*x)->route()); + boost::weak_ptr ws (stripable); + + /* for now, we need both of these. PropertyChanged covers on + * pre-defined, "global" things of interest to a + * UI. gui_changed covers arbitrary, un-enumerated, un-typed + * changes that may only be of interest to a particular + * UI (e.g. track-height is not of any relevant to OSC) + */ - (*x)->route()->gui_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::handle_gui_changes, this, _1, _2), gui_context()); - (*x)->route()->PropertyChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::route_property_changed, this, _1, wr), gui_context()); + stripable->gui_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::handle_gui_changes, this, _1, _2), gui_context()); + stripable->PropertyChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::route_property_changed, this, _1, ws), gui_context()); + stripable->presentation_info().PropertyChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::route_property_changed, this, _1, ws), gui_context()); - if ((*x)->is_track()) { - boost::shared_ptr t = boost::dynamic_pointer_cast ((*x)->route()); - t->RecordEnableChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_rec_display, this), gui_context()); + if (boost::dynamic_pointer_cast (stripable)) { + boost::shared_ptr t = boost::dynamic_pointer_cast (stripable); + t->rec_enable_control()->Changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_rec_display, this), gui_context()); + t->rec_safe_control()->Changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_rec_display, this), gui_context()); } - if ((*x)->is_midi_track()) { - boost::shared_ptr t = boost::dynamic_pointer_cast ((*x)->route()); - t->StepEditStatusChange.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_rec_display, this), gui_context()); - t->InputActiveChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_input_active_display, this), gui_context()); + if (midi_trk) { + midi_trk->StepEditStatusChange.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_rec_display, this), gui_context()); + midi_trk->InputActiveChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_input_active_display, this), gui_context()); } - (*x)->route()->mute_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_mute_display, this), gui_context()); - (*x)->route()->solo_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_solo_display, this, _1), gui_context()); - (*x)->route()->listen_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_solo_display, this, _1), gui_context()); - (*x)->route()->solo_isolated_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_solo_isolate_display, this), gui_context()); - (*x)->route()->solo_safe_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_solo_safe_display, this), gui_context()); - (*x)->route()->active_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_active_display, this), gui_context ()); + boost::shared_ptr ac; + + if ((ac = stripable->mute_control()) != 0) { + ac->Changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_mute_display, this), gui_context()); + } + if ((ac = stripable->solo_control()) != 0) { + ac->Changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_solo_display, this), gui_context()); + } + if ((ac = stripable->solo_isolate_control()) != 0) { + ac->Changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_solo_isolate_display, this), gui_context()); + } + if ((ac = stripable->solo_safe_control()) != 0) { + ac->Changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_solo_safe_display, this), gui_context()); + } + if (rtav) { + rtav->route()->active_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_active_display, this), gui_context ()); + } } update_rec_display (); update_mute_display (); - update_solo_display (true); + update_solo_display (); update_solo_isolate_display (); update_solo_safe_display (); update_input_active_display (); update_active_display (); - _display.set_model (_model); + { + PBD::Unwinder uw (_ignore_selection_change, true); + _display.set_model (_model); + } /* now update route order keys from the treeview/track display order */ + if (!from_scratch) { - sync_order_keys_from_treeview (); + sync_presentation_info_from_treeview (); } + + redisplay (); } void @@ -748,6 +876,8 @@ EditorRoutes::route_removed (TimeAxisView *tv) TreeModel::Children rows = _model->children(); TreeModel::Children::iterator ri; + PBD::Unwinder uw (_ignore_selection_change, true); + for (ri = rows.begin(); ri != rows.end(); ++ri) { if ((*ri)[_columns.tv] == tv) { PBD::Unwinder uw (_route_deletion_in_progress, true); @@ -755,24 +885,22 @@ EditorRoutes::route_removed (TimeAxisView *tv) break; } } - - /* the deleted signal for the treeview/model will take - care of any updates. - */ } void -EditorRoutes::route_property_changed (const PropertyChange& what_changed, boost::weak_ptr r) +EditorRoutes::route_property_changed (const PropertyChange& what_changed, boost::weak_ptr s) { - if (!what_changed.contains (ARDOUR::Properties::name)) { + if (!what_changed.contains (ARDOUR::Properties::hidden) && !what_changed.contains (ARDOUR::Properties::name)) { return; } - ENSURE_GUI_THREAD (*this, &EditorRoutes::route_name_changed, r) + if (_adding_routes) { + return; + } - boost::shared_ptr route = r.lock (); + boost::shared_ptr stripable = s.lock (); - if (!route) { + if (!stripable) { return; } @@ -780,9 +908,22 @@ EditorRoutes::route_property_changed (const PropertyChange& what_changed, boost: TreeModel::Children::iterator i; for (i = rows.begin(); i != rows.end(); ++i) { - boost::shared_ptr t = (*i)[_columns.route]; - if (t == route) { - (*i)[_columns.text] = route->name(); + + boost::shared_ptr ss = (*i)[_columns.stripable]; + + if (ss == stripable) { + + if (what_changed.contains (ARDOUR::Properties::name)) { + (*i)[_columns.text] = stripable->name(); + break; + } + + if (what_changed.contains (ARDOUR::Properties::hidden)) { + (*i)[_columns.visible] = !stripable->presentation_info().hidden(); + redisplay (); + + } + break; } } @@ -791,7 +932,7 @@ EditorRoutes::route_property_changed (const PropertyChange& what_changed, boost: void EditorRoutes::update_active_display () { - if (g_atomic_int_compare_and_exchange (&_queue_tv_update, 0, 1)) { + if (g_atomic_int_compare_and_exchange (const_cast(&_queue_tv_update), 0, 1)) { Glib::signal_idle().connect (sigc::mem_fun (*this, &EditorRoutes::idle_update_mute_rec_solo_etc)); } } @@ -809,10 +950,9 @@ EditorRoutes::update_visibility () (*i)[_columns.visible] = tv->marked_for_display (); } - /* force route order keys catch up with visibility changes - */ + /* force route order keys catch up with visibility changes */ - sync_order_keys_from_treeview (); + sync_presentation_info_from_treeview (); } void @@ -849,66 +989,7 @@ EditorRoutes::show_track_in_display (TimeAxisView& tv) } void -EditorRoutes::reset_remote_control_ids () -{ - if (Config->get_remote_model() == UserOrdered || !_session || _session->deletion_in_progress()) { - return; - } - - TreeModel::Children rows = _model->children(); - - if (rows.empty()) { - return; - } - - - DEBUG_TRACE (DEBUG::OrderKeys, "editor reset remote control ids\n"); - - TreeModel::Children::iterator ri; - bool rid_change = false; - uint32_t rid = 1; - uint32_t invisible_key = UINT32_MAX; - - for (ri = rows.begin(); ri != rows.end(); ++ri) { - - /* skip two special values */ - - if (rid == Route::MasterBusRemoteControlID) { - rid++; - } - - if (rid == Route::MonitorBusRemoteControlID) { - rid++; - } - - boost::shared_ptr route = (*ri)[_columns.route]; - bool visible = (*ri)[_columns.visible]; - - if (!route->is_master() && !route->is_monitor()) { - - uint32_t new_rid = (visible ? rid : invisible_key--); - - if (new_rid != route->remote_control_id()) { - route->set_remote_control_id_explicit (new_rid); - rid_change = true; - } - - if (visible) { - rid++; - } - - } - } - - if (rid_change) { - /* tell the world that we changed the remote control IDs */ - _session->notify_remote_id_change (); - } -} - - -void -EditorRoutes::sync_order_keys_from_treeview () +EditorRoutes::sync_presentation_info_from_treeview () { if (_ignore_reorder || !_session || _session->deletion_in_progress()) { return; @@ -920,60 +1001,43 @@ EditorRoutes::sync_order_keys_from_treeview () return; } + DEBUG_TRACE (DEBUG::OrderKeys, "editor sync presentation info from treeview\n"); - DEBUG_TRACE (DEBUG::OrderKeys, "editor sync order keys from treeview\n"); + bool change = false; + PresentationInfo::order_t order = 0; - TreeModel::Children::iterator ri; - bool changed = false; - bool rid_change = false; - uint32_t order = 0; - uint32_t rid = 1; - uint32_t invisible_key = UINT32_MAX; - - for (ri = rows.begin(); ri != rows.end(); ++ri) { + PresentationInfo::ChangeSuspender cs; - boost::shared_ptr route = (*ri)[_columns.route]; + for (TreeModel::Children::iterator ri = rows.begin(); ri != rows.end(); ++ri) { + boost::shared_ptr stripable = (*ri)[_columns.stripable]; bool visible = (*ri)[_columns.visible]; - uint32_t old_key = route->order_key (); - - if (order != old_key) { - route->set_order_key (order); - - changed = true; +#ifndef NDEBUG // these should not exist in the treeview + assert (stripable); + if (stripable->is_monitor() || stripable->is_auditioner()) { + assert (0); + continue; } +#endif - if ((Config->get_remote_model() == MixerOrdered) && !route->is_master() && !route->is_monitor()) { - - uint32_t new_rid = (visible ? rid : invisible_key--); - - if (new_rid != route->remote_control_id()) { - route->set_remote_control_id_explicit (new_rid); - rid_change = true; - } - - if (visible) { - rid++; - } + stripable->presentation_info().set_hidden (!visible); + if (order != stripable->presentation_info().order()) { + stripable->set_presentation_order (order); + change = true; } - ++order; } - if (changed) { - /* tell the world that we changed the editor sort keys */ - _session->sync_order_keys (); - } + change |= _session->ensure_stripable_sort_order (); - if (rid_change) { - /* tell the world that we changed the remote control IDs */ - _session->notify_remote_id_change (); + if (change) { + _session->set_dirty(); } } void -EditorRoutes::sync_treeview_from_order_keys () +EditorRoutes::sync_treeview_from_presentation_info (PropertyChange const & what_changed) { /* Some route order key(s) have been changed, make sure that we update out tree/list model and GUI to reflect the change. @@ -983,51 +1047,80 @@ EditorRoutes::sync_treeview_from_order_keys () return; } - DEBUG_TRACE (DEBUG::OrderKeys, "editor sync model from order keys.\n"); + DEBUG_TRACE (DEBUG::OrderKeys, "editor sync model from presentation info.\n"); - /* we could get here after either a change in the Mixer or Editor sort - * order, but either way, the mixer order keys reflect the intended - * order for the GUI, so reorder the treeview model to match it. - */ + PropertyChange hidden_or_order; + hidden_or_order.add (Properties::hidden); + hidden_or_order.add (Properties::order); - vector neworder; TreeModel::Children rows = _model->children(); - uint32_t old_order = 0; + bool changed = false; - if (rows.empty()) { - return; - } + if (what_changed.contains (hidden_or_order)) { + vector neworder; + uint32_t old_order = 0; - OrderKeySortedRoutes sorted_routes; + if (rows.empty()) { + return; + } - for (TreeModel::Children::iterator ri = rows.begin(); ri != rows.end(); ++ri, ++old_order) { - boost::shared_ptr route = (*ri)[_columns.route]; - sorted_routes.push_back (RoutePlusOrderKey (route, old_order, route->order_key ())); - } + TreeOrderKeys sorted; + for (TreeModel::Children::iterator ri = rows.begin(); ri != rows.end(); ++ri, ++old_order) { + boost::shared_ptr stripable = (*ri)[_columns.stripable]; + /* use global order */ + sorted.push_back (TreeOrderKey (old_order, stripable)); + } - SortByNewDisplayOrder cmp; + TreeOrderKeySorter cmp; - sort (sorted_routes.begin(), sorted_routes.end(), cmp); - neworder.assign (sorted_routes.size(), 0); + sort (sorted.begin(), sorted.end(), cmp); + neworder.assign (sorted.size(), 0); - uint32_t n = 0; + uint32_t n = 0; - for (OrderKeySortedRoutes::iterator sr = sorted_routes.begin(); sr != sorted_routes.end(); ++sr, ++n) { + for (TreeOrderKeys::iterator sr = sorted.begin(); sr != sorted.end(); ++sr, ++n) { - neworder[n] = sr->old_display_order; + neworder[n] = sr->old_display_order; - if (sr->old_display_order != n) { - changed = true; + if (sr->old_display_order != n) { + changed = true; + } } - DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("EDITOR change order for %1 from %2 to %3\n", - sr->route->name(), sr->old_display_order, n)); + if (changed) { + Unwinder uw (_ignore_reorder, true); + /* prevent traverse_cells: assertion 'row_path != NULL' + * in case of DnD re-order: row-removed + row-inserted. + * + * The rows (stripables) are not actually removed from the model, + * but only from the display in the DnDTreeView. + * ->reorder() will fail to find the row_path. + * (re-order drag -> remove row -> sync PI from TV -> notify -> sync TV from PI -> crash) + */ + Unwinder uw2 (_ignore_selection_change, true); + + _display.unset_model(); + _model->reorder (neworder); + _display.set_model (_model); + } } - if (changed) { - Unwinder uw (_ignore_reorder, true); - _model->reorder (neworder); + if (changed || what_changed.contains (Properties::selected)) { + /* by the time this is invoked, the GUI Selection model has + * already updated itself. + */ + PBD::Unwinder uw (_ignore_selection_change, true); + + /* set the treeview model selection state */ + for (TreeModel::Children::iterator ri = rows.begin(); ri != rows.end(); ++ri) { + boost::shared_ptr stripable = (*ri)[_columns.stripable]; + if (stripable && stripable->is_selected()) { + _display.get_selection()->select (*ri); + } else { + _display.get_selection()->unselect (*ri); + } + } } redisplay (); @@ -1078,7 +1171,7 @@ EditorRoutes::set_all_tracks_visibility (bool yn) /* force route order keys catch up with visibility changes */ - sync_order_keys_from_treeview (); + sync_presentation_info_from_treeview (); } void @@ -1104,17 +1197,20 @@ EditorRoutes::set_all_audio_midi_visibility (int tracks, bool yn) if ((atv = dynamic_cast(tv)) != 0) { switch (tracks) { case 0: + atv->set_marked_for_display (yn); (*i)[_columns.visible] = yn; break; case 1: if (atv->is_audio_track()) { + atv->set_marked_for_display (yn); (*i)[_columns.visible] = yn; } break; case 2: if (!atv->is_audio_track()) { + atv->set_marked_for_display (yn); (*i)[_columns.visible] = yn; } break; @@ -1123,11 +1219,13 @@ EditorRoutes::set_all_audio_midi_visibility (int tracks, bool yn) else if ((mtv = dynamic_cast(tv)) != 0) { switch (tracks) { case 0: + mtv->set_marked_for_display (yn); (*i)[_columns.visible] = yn; break; case 3: if (mtv->is_midi_track()) { + mtv->set_marked_for_display (yn); (*i)[_columns.visible] = yn; } break; @@ -1138,7 +1236,7 @@ EditorRoutes::set_all_audio_midi_visibility (int tracks, bool yn) /* force route order keys catch up with visibility changes */ - sync_order_keys_from_treeview (); + sync_presentation_info_from_treeview (); } void @@ -1216,25 +1314,27 @@ EditorRoutes::key_press (GdkEventKey* ev) case 'm': if (get_relevant_routes (rl)) { - _session->set_mute (rl, !rl->front()->muted(), Session::rt_cleanup); + _session->set_controls (route_list_to_control_list (rl, &Stripable::mute_control), rl->front()->muted() ? 0.0 : 1.0, Controllable::NoGroup); } return true; break; case 's': if (get_relevant_routes (rl)) { - if (Config->get_solo_control_is_listen_control()) { - _session->set_listen (rl, !rl->front()->listening_via_monitor(), Session::rt_cleanup); - } else { - _session->set_solo (rl, !rl->front()->self_soloed(), Session::rt_cleanup); - } + _session->set_controls (route_list_to_control_list (rl, &Stripable::solo_control), rl->front()->self_soloed() ? 0.0 : 1.0, Controllable::NoGroup); } return true; break; case 'r': if (get_relevant_routes (rl)) { - _session->set_record_enabled (rl, !rl->front()->record_enabled(), Session::rt_cleanup); + for (RouteList::const_iterator r = rl->begin(); r != rl->end(); ++r) { + boost::shared_ptr t = boost::dynamic_pointer_cast (*r); + if (t) { + _session->set_controls (route_list_to_control_list (rl, &Stripable::rec_enable_control), !t->rec_enable_control()->get_value(), Controllable::NoGroup); + break; + } + } } break; @@ -1292,7 +1392,10 @@ bool EditorRoutes::button_press (GdkEventButton* ev) { if (Keyboard::is_context_menu_event (ev)) { - show_menu (); + if (_menu == 0) { + build_menu (); + } + _menu->popup (ev->button, ev->time); return true; } @@ -1326,6 +1429,10 @@ EditorRoutes::button_press (GdkEventButton* ev) void EditorRoutes::selection_changed () { + if (_ignore_selection_change) { + return; + } + _editor->begin_reversible_selection_op (X_("Select Track from Route List")); if (_display.get_selection()->count_selected_rows() > 0) { @@ -1334,8 +1441,6 @@ EditorRoutes::selection_changed () TreeView::Selection::ListHandle_Path rows = _display.get_selection()->get_selected_rows (); TrackViewList selected; - _editor->get_selection().clear_regions (); - for (TreeView::Selection::ListHandle_Path::iterator i = rows.begin(); i != rows.end(); ++i) { if ((iter = _model->get_iter (*i))) { @@ -1357,187 +1462,158 @@ EditorRoutes::selection_changed () } bool -EditorRoutes::selection_filter (Glib::RefPtr const &, TreeModel::Path const&, bool /*selected*/) +EditorRoutes::selection_filter (Glib::RefPtr const& model, TreeModel::Path const& path, bool /*selected*/) { - if (selection_countdown) { - if (--selection_countdown == 0) { - return true; - } else { - /* no selection yet ... */ - return false; - } + TreeModel::iterator iter = model->get_iter (path); + if (iter) { + boost::shared_ptr stripable = (*iter)[_columns.stripable]; } + return true; } -struct EditorOrderRouteSorter -{ - bool operator() (boost::shared_ptr a, boost::shared_ptr b) { - if (a->is_master()) { - /* master before everything else */ - return true; - } else if (b->is_master()) { - /* everything else before master */ - return false; - } - return a->order_key () < b->order_key (); - } -}; - void EditorRoutes::initial_display () { - DisplaySuspender ds; - _model->clear (); if (!_session) { + _model->clear (); return; } + DisplaySuspender ds; + _model->clear (); + + StripableList s; + RouteList r (*_session->get_routes()); - - r.sort (EditorOrderRouteSorter ()); - _editor->add_routes (r); -} + for (RouteList::iterator ri = r.begin(); ri != r.end(); ++ri) { + s.push_back (*ri); + } -void -EditorRoutes::display_drag_data_received (const RefPtr& context, - int x, int y, - const SelectionData& data, - guint info, guint time) -{ - if (data.get_target() == "GTK_TREE_MODEL_ROW") { - _display.on_drag_data_received (context, x, y, data, info, time); - return; + VCAList v (_session->vca_manager().vcas()); + for (VCAList::iterator vi = v.begin(); vi != v.end(); ++vi) { + s.push_back (*vi); } - context->drag_finish (true, false, time); + _editor->add_stripables (s); + + sync_treeview_from_presentation_info (Properties::order); } +struct ViewStripable { + TimeAxisView* tav; + boost::shared_ptr stripable; + + ViewStripable (TimeAxisView* t, boost::shared_ptr s) + : tav (t), stripable (s) {} +}; + void EditorRoutes::move_selected_tracks (bool up) { - if (_editor->selection->tracks.empty()) { + TimeAxisView* scroll_to = 0; + StripableList sl; + _session->get_stripables (sl); + + if (sl.size() < 2) { + /* nope */ return; } - typedef std::pair > ViewRoute; - std::list view_routes; - std::vector neworder; - TreeModel::Children rows = _model->children(); - TreeModel::Children::iterator ri; + sl.sort (Stripable::Sorter()); - for (ri = rows.begin(); ri != rows.end(); ++ri) { - TimeAxisView* tv = (*ri)[_columns.tv]; - boost::shared_ptr route = (*ri)[_columns.route]; + std::list view_stripables; - view_routes.push_back (ViewRoute (tv, route)); + /* build a list that includes time axis view information */ + + for (StripableList::const_iterator sli = sl.begin(); sli != sl.end(); ++sli) { + TimeAxisView* tv = _editor->time_axis_view_from_stripable (*sli); + view_stripables.push_back (ViewStripable (tv, *sli)); } - list::iterator trailing; - list::iterator leading; + /* for each selected stripable, move it above or below the adjacent + * stripable that has a time-axis view representation here. If there's + * no such representation, then + */ - if (up) { + list::iterator unselected_neighbour; + list::iterator vsi; - trailing = view_routes.begin(); - leading = view_routes.begin(); + { + PresentationInfo::ChangeSuspender cs; - ++leading; + if (up) { + unselected_neighbour = view_stripables.end (); + vsi = view_stripables.begin(); - while (leading != view_routes.end()) { - if (_editor->selection->selected (leading->first)) { - view_routes.insert (trailing, ViewRoute (leading->first, leading->second)); - leading = view_routes.erase (leading); - } else { - ++leading; - ++trailing; - } - } + while (vsi != view_stripables.end()) { - } else { + if (vsi->stripable->is_selected()) { - /* if we could use reverse_iterator in list::insert, this code - would be a beautiful reflection of the code above. but we can't - and so it looks like a bit of a mess. - */ + if (unselected_neighbour != view_stripables.end()) { + + PresentationInfo::order_t unselected_neighbour_order = unselected_neighbour->stripable->presentation_info().order(); + PresentationInfo::order_t my_order = vsi->stripable->presentation_info().order(); - trailing = view_routes.end(); - leading = view_routes.end(); + unselected_neighbour->stripable->set_presentation_order (my_order); + vsi->stripable->set_presentation_order (unselected_neighbour_order); - --leading; if (leading == view_routes.begin()) { return; } - --leading; - --trailing; + if (!scroll_to) { + scroll_to = vsi->tav; + } + } - while (1) { + } else { - if (_editor->selection->selected (leading->first)) { - list::iterator tmp; + if (vsi->tav) { + unselected_neighbour = vsi; + } - /* need to insert *after* trailing, not *before* it, - which is what insert (iter, val) normally does. - */ + } - tmp = trailing; - tmp++; + ++vsi; + } - view_routes.insert (tmp, ViewRoute (leading->first, leading->second)); + } else { - /* can't use iter = cont.erase (iter); form here, because - we need iter to move backwards. - */ + unselected_neighbour = view_stripables.end(); + vsi = unselected_neighbour; - tmp = leading; - --tmp; + do { - bool done = false; + --vsi; - if (leading == view_routes.begin()) { - /* the one we've just inserted somewhere else - was the first in the list. erase this copy, - and then break, because we're done. - */ - done = true; - } + if (vsi->stripable->is_selected()) { - view_routes.erase (leading); + if (unselected_neighbour != view_stripables.end()) { - if (done) { - break; - } + PresentationInfo::order_t unselected_neighbour_order = unselected_neighbour->stripable->presentation_info().order(); + PresentationInfo::order_t my_order = vsi->stripable->presentation_info().order(); - leading = tmp; + unselected_neighbour->stripable->set_presentation_order (my_order); + vsi->stripable->set_presentation_order (unselected_neighbour_order); - } else { - if (leading == view_routes.begin()) { - break; - } - --leading; - --trailing; - } - }; - } + if (!scroll_to) { + scroll_to = vsi->tav; + } + } - for (leading = view_routes.begin(); leading != view_routes.end(); ++leading) { - uint32_t order = leading->second->order_key (); - neworder.push_back (order); - } + } else { -#ifndef NDEBUG - DEBUG_TRACE (DEBUG::OrderKeys, "New order after moving tracks:\n"); - for (vector::iterator i = neworder.begin(); i != neworder.end(); ++i) { - DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("\t%1\n", *i)); - } - DEBUG_TRACE (DEBUG::OrderKeys, "-------\n"); + if (vsi->tav) { + unselected_neighbour = vsi; + } + + } - for (vector::iterator i = neworder.begin(); i != neworder.end(); ++i) { - if (*i >= (int) neworder.size()) { - cerr << "Trying to move something to " << *i << " of " << neworder.size() << endl; + } while (vsi != view_stripables.begin()); } - assert (*i < (int) neworder.size ()); } -#endif - _model->reorder (neworder); + if (scroll_to) { + _editor->ensure_time_axis_view_is_visible (*scroll_to, false); + } } void @@ -1547,10 +1623,10 @@ EditorRoutes::update_input_active_display () TreeModel::Children::iterator i; for (i = rows.begin(); i != rows.end(); ++i) { - boost::shared_ptr route = (*i)[_columns.route]; + boost::shared_ptr stripable = (*i)[_columns.stripable]; - if (boost::dynamic_pointer_cast (route)) { - boost::shared_ptr mt = boost::dynamic_pointer_cast (route); + if (boost::dynamic_pointer_cast (stripable)) { + boost::shared_ptr mt = boost::dynamic_pointer_cast (stripable); if (mt) { (*i)[_columns.is_input_active] = mt->input_active(); @@ -1562,7 +1638,7 @@ EditorRoutes::update_input_active_display () void EditorRoutes::update_rec_display () { - if (g_atomic_int_compare_and_exchange (&_queue_tv_update, 0, 1)) { + if (g_atomic_int_compare_and_exchange (const_cast(&_queue_tv_update), 0, 1)) { Glib::signal_idle().connect (sigc::mem_fun (*this, &EditorRoutes::idle_update_mute_rec_solo_etc)); } } @@ -1570,21 +1646,29 @@ EditorRoutes::update_rec_display () bool EditorRoutes::idle_update_mute_rec_solo_etc() { - g_atomic_int_set (&_queue_tv_update, 0); + g_atomic_int_set (const_cast(&_queue_tv_update), 0); TreeModel::Children rows = _model->children(); TreeModel::Children::iterator i; for (i = rows.begin(); i != rows.end(); ++i) { - boost::shared_ptr route = (*i)[_columns.route]; - (*i)[_columns.mute_state] = RouteUI::mute_active_state (_session, route); - (*i)[_columns.solo_state] = RouteUI::solo_active_state (route); - (*i)[_columns.solo_isolate_state] = RouteUI::solo_isolate_active_state (route) ? 1 : 0; - (*i)[_columns.solo_safe_state] = RouteUI::solo_safe_active_state (route) ? 1 : 0; - (*i)[_columns.active] = route->active (); - if (boost::dynamic_pointer_cast (route)) { + boost::shared_ptr stripable = (*i)[_columns.stripable]; + boost::shared_ptr route = boost::dynamic_pointer_cast (stripable); + (*i)[_columns.mute_state] = RouteUI::mute_active_state (_session, stripable); + (*i)[_columns.solo_state] = RouteUI::solo_active_state (stripable); + (*i)[_columns.solo_isolate_state] = RouteUI::solo_isolate_active_state (stripable) ? 1 : 0; + (*i)[_columns.solo_safe_state] = RouteUI::solo_safe_active_state (stripable) ? 1 : 0; + if (route) { + (*i)[_columns.active] = route->active (); + } else { + (*i)[_columns.active] = true; + } + + boost::shared_ptr trk (boost::dynamic_pointer_cast(route)); + + if (trk) { boost::shared_ptr mt = boost::dynamic_pointer_cast (route); - - if (route->record_enabled()) { + + if (trk->rec_enable_control()->get_value()) { if (_session->record_status() == Session::Recording) { (*i)[_columns.rec_state] = 1; } else { @@ -1595,8 +1679,9 @@ EditorRoutes::idle_update_mute_rec_solo_etc() } else { (*i)[_columns.rec_state] = 0; } - - (*i)[_columns.name_editable] = !route->record_enabled (); + + (*i)[_columns.rec_safe] = trk->rec_safe_control()->get_value(); + (*i)[_columns.name_editable] = !trk->rec_enable_control()->get_value(); } } @@ -1607,15 +1692,15 @@ EditorRoutes::idle_update_mute_rec_solo_etc() void EditorRoutes::update_mute_display () { - if (g_atomic_int_compare_and_exchange (&_queue_tv_update, 0, 1)) { + if (g_atomic_int_compare_and_exchange (const_cast(&_queue_tv_update), 0, 1)) { Glib::signal_idle().connect (sigc::mem_fun (*this, &EditorRoutes::idle_update_mute_rec_solo_etc)); } } void -EditorRoutes::update_solo_display (bool /* selfsoloed */) +EditorRoutes::update_solo_display () { - if (g_atomic_int_compare_and_exchange (&_queue_tv_update, 0, 1)) { + if (g_atomic_int_compare_and_exchange (const_cast(&_queue_tv_update), 0, 1)) { Glib::signal_idle().connect (sigc::mem_fun (*this, &EditorRoutes::idle_update_mute_rec_solo_etc)); } } @@ -1623,7 +1708,7 @@ EditorRoutes::update_solo_display (bool /* selfsoloed */) void EditorRoutes::update_solo_isolate_display () { - if (g_atomic_int_compare_and_exchange (&_queue_tv_update, 0, 1)) { + if (g_atomic_int_compare_and_exchange (const_cast(&_queue_tv_update), 0, 1)) { Glib::signal_idle().connect (sigc::mem_fun (*this, &EditorRoutes::idle_update_mute_rec_solo_etc)); } } @@ -1631,7 +1716,7 @@ EditorRoutes::update_solo_isolate_display () void EditorRoutes::update_solo_safe_display () { - if (g_atomic_int_compare_and_exchange (&_queue_tv_update, 0, 1)) { + if (g_atomic_int_compare_and_exchange (const_cast(&_queue_tv_update), 0, 1)) { Glib::signal_idle().connect (sigc::mem_fun (*this, &EditorRoutes::idle_update_mute_rec_solo_etc)); } } @@ -1650,6 +1735,7 @@ EditorRoutes::views () const void EditorRoutes::clear () { + PBD::Unwinder uw (_ignore_selection_change, true); _display.set_model (Glib::RefPtr (0)); _model->clear (); _display.set_model (_model); @@ -1680,10 +1766,10 @@ EditorRoutes::name_edit (std::string const & path, std::string const & new_text) return; } - boost::shared_ptr route = (*iter)[_columns.route]; + boost::shared_ptr stripable = (*iter)[_columns.stripable]; - if (route && route->name() != new_text) { - route->set_name (new_text); + if (stripable && stripable->name() != new_text) { + stripable->set_name (new_text); } } @@ -1700,7 +1786,7 @@ EditorRoutes::show_tracks_with_regions_at_playhead () set show; for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) { - TimeAxisView* tav = _editor->axis_view_from_route (*i); + TimeAxisView* tav = _editor->time_axis_view_from_stripable (*i); if (tav) { show.insert (tav); } @@ -1711,6 +1797,22 @@ EditorRoutes::show_tracks_with_regions_at_playhead () TreeModel::Children rows = _model->children (); for (TreeModel::Children::iterator i = rows.begin(); i != rows.end(); ++i) { TimeAxisView* tv = (*i)[_columns.tv]; - (*i)[_columns.visible] = (show.find (tv) != show.end()); + bool to_show = (show.find (tv) != show.end()); + + tv->set_marked_for_display (to_show); + (*i)[_columns.visible] = to_show; } + + /* force route order keys catch up with visibility changes + */ + + sync_presentation_info_from_treeview (); +} + +int +EditorRoutes::plugin_setup (boost::shared_ptr r, boost::shared_ptr pi, ARDOUR::Route::PluginSetupOptions flags) +{ + PluginSetupDialog psd (r, pi, flags); + int rv = psd.run (); + return rv + (psd.fan_out() ? 4 : 0); }