X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Feditor_routes.cc;h=1368979e5896ef313775fb2f61437db3011747e5;hb=8b3d50f7e6c4ab7575b169cccc54efc0e2a94fd0;hp=e3f3c9d736ad0c1712ee48603083b0624a4d6a66;hpb=4297071b3f7360b17d81ef9cf36b8d75d46d2818;p=ardour.git diff --git a/gtk2_ardour/editor_routes.cc b/gtk2_ardour/editor_routes.cc index e3f3c9d736..1368979e58 100644 --- a/gtk2_ardour/editor_routes.cc +++ b/gtk2_ardour/editor_routes.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2000-2009 Paul Davis + Copyright (C) 2000-2009 Paul Davis This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -24,9 +24,7 @@ #include #include -#include "gtkmm2ext/cell_renderer_pixbuf_toggle.h" - -#include "ardour/diskstream.h" +#include "ardour/session.h" #include "editor.h" #include "keyboard.h" @@ -43,24 +41,32 @@ #include "pbd/unknown_type.h" #include "ardour/route.h" +#include "ardour/midi_track.h" + +#include "gtkmm2ext/cell_renderer_pixbuf_multi.h" +#include "gtkmm2ext/cell_renderer_pixbuf_toggle.h" +#include "gtkmm2ext/treeutils.h" #include "i18n.h" using namespace std; -using namespace sigc; using namespace ARDOUR; using namespace PBD; using namespace Gtk; using namespace Gtkmm2ext; using namespace Glib; +using Gtkmm2ext::Keyboard; EditorRoutes::EditorRoutes (Editor* e) - : EditorComponent (e), - _ignore_reorder (false), - _no_redisplay (false), - _redisplay_does_not_sync_order_keys (false), - _redisplay_does_not_reset_order_keys (false), - _menu (0) + : EditorComponent (e) + , _ignore_reorder (false) + , _no_redisplay (false) + , _redisplay_does_not_sync_order_keys (false) + , _redisplay_does_not_reset_order_keys (false) + ,_menu (0) + , old_focus (0) + , selection_countdown (0) + , name_editable (0) { _scroller.add (_display); _scroller.set_policy (POLICY_NEVER, POLICY_AUTOMATIC); @@ -68,65 +74,300 @@ EditorRoutes::EditorRoutes (Editor* e) _model = ListStore::create (_columns); _display.set_model (_model); - CellRendererPixbufToggle* rec_col_renderer = manage (new CellRendererPixbufToggle()); + // Record enable toggle + CellRendererPixbufMulti* rec_col_renderer = manage (new CellRendererPixbufMulti()); - rec_col_renderer->set_active_pixbuf (::get_icon("record_normal_red")); - rec_col_renderer->set_inactive_pixbuf (::get_icon("record_disabled_grey")); + rec_col_renderer->set_pixbuf (0, ::get_icon("act-disabled")); + rec_col_renderer->set_pixbuf (1, ::get_icon("rec-in-progress")); + rec_col_renderer->set_pixbuf (2, ::get_icon("rec-enabled")); + rec_col_renderer->set_pixbuf (3, ::get_icon("step-editing")); + rec_col_renderer->signal_changed().connect (sigc::mem_fun (*this, &EditorRoutes::on_tv_rec_enable_changed)); - rec_col_renderer->signal_toggled().connect (mem_fun (*this, &EditorRoutes::on_tv_rec_enable_toggled)); + TreeViewColumn* rec_state_column = manage (new TreeViewColumn("R", *rec_col_renderer)); - Gtk::TreeViewColumn* rec_state_column = manage (new TreeViewColumn("Rec", *rec_col_renderer)); - rec_state_column->add_attribute(rec_col_renderer->property_active(), _columns.rec_enabled); + rec_state_column->add_attribute(rec_col_renderer->property_state(), _columns.rec_state); rec_state_column->add_attribute(rec_col_renderer->property_visible(), _columns.is_track); + rec_state_column->set_sizing(TREE_VIEW_COLUMN_FIXED); + rec_state_column->set_alignment(ALIGN_CENTER); + rec_state_column->set_expand(false); + rec_state_column->set_fixed_width(15); + + // Mute enable toggle + CellRendererPixbufMulti* mute_col_renderer = manage (new CellRendererPixbufMulti()); + + mute_col_renderer->set_pixbuf (0, ::get_icon("act-disabled")); + mute_col_renderer->set_pixbuf (1, ::get_icon("muted-by-others")); + mute_col_renderer->set_pixbuf (2, ::get_icon("mute-enabled")); + mute_col_renderer->signal_changed().connect (sigc::mem_fun (*this, &EditorRoutes::on_tv_mute_enable_toggled)); + + TreeViewColumn* mute_state_column = manage (new TreeViewColumn("M", *mute_col_renderer)); + + mute_state_column->add_attribute(mute_col_renderer->property_state(), _columns.mute_state); + mute_state_column->set_sizing(TREE_VIEW_COLUMN_FIXED); + mute_state_column->set_alignment(ALIGN_CENTER); + mute_state_column->set_expand(false); + mute_state_column->set_fixed_width(15); + + // Solo enable toggle + CellRendererPixbufMulti* solo_col_renderer = manage (new CellRendererPixbufMulti()); + + solo_col_renderer->set_pixbuf (0, ::get_icon("act-disabled")); + solo_col_renderer->set_pixbuf (1, ::get_icon("solo-enabled")); + solo_col_renderer->set_pixbuf (3, ::get_icon("soloed-by-others")); + solo_col_renderer->signal_changed().connect (sigc::mem_fun (*this, &EditorRoutes::on_tv_solo_enable_toggled)); + + TreeViewColumn* solo_state_column = manage (new TreeViewColumn("S", *solo_col_renderer)); + + solo_state_column->add_attribute(solo_col_renderer->property_state(), _columns.solo_state); + solo_state_column->set_sizing(TREE_VIEW_COLUMN_FIXED); + solo_state_column->set_alignment(ALIGN_CENTER); + solo_state_column->set_expand(false); + solo_state_column->set_fixed_width(15); + + // Solo isolate toggle + CellRendererPixbufMulti* solo_iso_renderer = manage (new CellRendererPixbufMulti()); + + solo_iso_renderer->set_pixbuf (0, ::get_icon("act-disabled")); + solo_iso_renderer->set_pixbuf (1, ::get_icon("solo-isolated")); + solo_iso_renderer->signal_changed().connect (sigc::mem_fun (*this, &EditorRoutes::on_tv_solo_isolate_toggled)); + + 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->set_sizing(TREE_VIEW_COLUMN_FIXED); + solo_isolate_state_column->set_alignment(ALIGN_CENTER); + solo_isolate_state_column->set_expand(false); + solo_isolate_state_column->set_fixed_width(22); + + // Solo safe toggle + CellRendererPixbufMulti* solo_safe_renderer = manage (new CellRendererPixbufMulti ()); + + solo_safe_renderer->set_pixbuf (0, ::get_icon("act-disabled")); + solo_safe_renderer->set_pixbuf (1, ::get_icon("solo-enabled")); + solo_safe_renderer->signal_changed().connect (sigc::mem_fun (*this, &EditorRoutes::on_tv_solo_safe_toggled)); + + 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->set_sizing(TREE_VIEW_COLUMN_FIXED); + solo_safe_state_column->set_alignment(ALIGN_CENTER); + solo_safe_state_column->set_expand(false); + solo_safe_state_column->set_fixed_width(22); _display.append_column (*rec_state_column); - _display.append_column (_("Show"), _columns.visible); - _display.append_column (_("Name"), _columns.text); + _display.append_column (*mute_state_column); + _display.append_column (*solo_state_column); + _display.append_column (*solo_isolate_state_column); + _display.append_column (*solo_safe_state_column); - _display.get_column (0)->set_data (X_("colnum"), GUINT_TO_POINTER(0)); - _display.get_column (1)->set_data (X_("colnum"), GUINT_TO_POINTER(1)); - _display.get_column (2)->set_data (X_("colnum"), GUINT_TO_POINTER(2)); + int colnum = _display.append_column (_("Name"), _columns.text); + TreeViewColumn* c = _display.get_column (colnum-1); + c->set_data ("i_am_the_tab_column", (void*) 0xfeedface); + _display.append_column (_("V"), _columns.visible); _display.set_headers_visible (true); _display.set_name ("TrackListDisplay"); - _display.get_selection()->set_mode (SELECTION_NONE); + _display.get_selection()->set_mode (SELECTION_SINGLE); + _display.get_selection()->set_select_function (sigc::mem_fun (*this, &EditorRoutes::selection_filter)); _display.set_reorderable (true); _display.set_rules_hint (true); _display.set_size_request (100, -1); _display.add_object_drag (_columns.route.index(), "routes"); - CellRendererToggle* visible_cell = dynamic_cast(_display.get_column_cell_renderer (1)); - + CellRendererText* name_cell = dynamic_cast (_display.get_column_cell_renderer (5)); + + assert (name_cell); + name_cell->signal_editing_started().connect (sigc::mem_fun (*this, &EditorRoutes::name_edit_started)); + + TreeViewColumn* name_column = _display.get_column (5); + + assert (name_column); + + name_column->add_attribute (name_cell->property_editable(), _columns.name_editable); + name_column->set_sizing(TREE_VIEW_COLUMN_FIXED); + name_column->set_expand(true); + name_column->set_min_width(50); + + name_cell->property_editable() = true; + name_cell->signal_edited().connect (sigc::mem_fun (*this, &EditorRoutes::name_edit)); + + // Set the visible column cell renderer to radio toggle + CellRendererToggle* visible_cell = dynamic_cast (_display.get_column_cell_renderer (6)); + visible_cell->property_activatable() = true; visible_cell->property_radio() = false; + visible_cell->signal_toggled().connect (sigc::mem_fun (*this, &EditorRoutes::visible_changed)); + + TreeViewColumn* visible_col = dynamic_cast (_display.get_column (6)); + visible_col->set_expand(false); + visible_col->set_sizing(TREE_VIEW_COLUMN_FIXED); + visible_col->set_fixed_width(30); + visible_col->set_alignment(ALIGN_CENTER); + + _model->signal_row_deleted().connect (sigc::mem_fun (*this, &EditorRoutes::route_deleted)); + _model->signal_rows_reordered().connect (sigc::mem_fun (*this, &EditorRoutes::reordered)); + + _display.signal_button_press_event().connect (sigc::mem_fun (*this, &EditorRoutes::button_press), false); + _scroller.signal_key_press_event().connect (sigc::mem_fun(*this, &EditorRoutes::key_press), false); + + _scroller.signal_focus_in_event().connect (sigc::mem_fun (*this, &EditorRoutes::focus_in), false); + _scroller.signal_focus_out_event().connect (sigc::mem_fun (*this, &EditorRoutes::focus_out)); + + _display.signal_enter_notify_event().connect (sigc::mem_fun (*this, &EditorRoutes::enter_notify), false); + _display.signal_leave_notify_event().connect (sigc::mem_fun (*this, &EditorRoutes::leave_notify), false); + + _display.set_enable_search (false); + + Route::SyncOrderKeys.connect (*this, MISSING_INVALIDATOR, ui_bind (&EditorRoutes::sync_order_keys, this, _1), gui_context()); +} + +bool +EditorRoutes::focus_in (GdkEventFocus*) +{ + Window* win = dynamic_cast (_scroller.get_toplevel ()); + + if (win) { + old_focus = win->get_focus (); + } else { + old_focus = 0; + } + + name_editable = 0; + + /* try to do nothing on focus in (doesn't work, hence selection_count nonsense) */ + return true; +} - _model->signal_row_deleted().connect (mem_fun (*this, &EditorRoutes::route_deleted)); - _model->signal_row_changed().connect (mem_fun (*this, &EditorRoutes::changed)); - _model->signal_rows_reordered().connect (mem_fun (*this, &EditorRoutes::reordered)); - _display.signal_button_press_event().connect (mem_fun (*this, &EditorRoutes::button_press), false); +bool +EditorRoutes::focus_out (GdkEventFocus*) +{ + if (old_focus) { + old_focus->grab_focus (); + old_focus = 0; + } - Route::SyncOrderKeys.connect (mem_fun (*this, &EditorRoutes::sync_order_keys)); + return false; +} + +bool +EditorRoutes::enter_notify (GdkEventCrossing*) +{ + if (name_editable) { + return true; + } + + /* 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; +} + +bool +EditorRoutes::leave_notify (GdkEventCrossing*) +{ + selection_countdown = 0; + + if (old_focus) { + old_focus->grab_focus (); + old_focus = 0; + } + + Keyboard::magic_widget_drop_focus (); + return false; } void -EditorRoutes::connect_to_session (Session* s) +EditorRoutes::set_session (Session* s) { - EditorComponent::connect_to_session (s); + SessionHandlePtr::set_session (s); initial_display (); + + 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()); + } +} + +void +EditorRoutes::on_tv_rec_enable_changed (std::string const & path_string) +{ + // 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); + + 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); + } +} + +void +EditorRoutes::on_tv_mute_enable_toggled (std::string const & path_string) +{ + // 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); + + if (rtv != 0) { + boost::shared_ptr rl (new RouteList); + rl->push_back (rtv->route()); + _session->set_mute (rl, !rtv->route()->muted(), Session::rt_cleanup); + } +} + +void +EditorRoutes::on_tv_solo_enable_toggled (std::string const & path_string) +{ + // 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); + + 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); + } + } } -void -EditorRoutes::on_tv_rec_enable_toggled (Glib::ustring const & path_string) +void +EditorRoutes::on_tv_solo_isolate_toggled (std::string const & path_string) { // Get the model row that has been toggled. Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string)); - TimeAxisViewPtr tv = row[_columns.tv]; - AudioTimeAxisViewPtr atv = boost::dynamic_pointer_cast (tv); + TimeAxisView *tv = row[_columns.tv]; + RouteTimeAxisView* rtv = dynamic_cast (tv); - if (atv != 0 && atv->is_audio_track()){ - atv->get_diskstream()->set_record_enabled(!atv->get_diskstream()->record_enabled()); + if (rtv) { + rtv->route()->set_solo_isolated (!rtv->route()->solo_isolated(), this); + } +} + +void +EditorRoutes::on_tv_solo_safe_toggled (std::string const & path_string) +{ + // 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); + + if (rtv) { + rtv->route()->set_solo_safe (!rtv->route()->solo_safe(), this); } } @@ -137,17 +378,19 @@ EditorRoutes::build_menu () using namespace Gtk; _menu = new Menu; - + MenuList& items = _menu->items(); _menu->set_name ("ArdourContextMenu"); - items.push_back (MenuElem (_("Show All"), mem_fun (*this, &EditorRoutes::show_all_routes))); - items.push_back (MenuElem (_("Hide All"), mem_fun (*this, &EditorRoutes::hide_all_routes))); - items.push_back (MenuElem (_("Show All Audio Tracks"), mem_fun (*this, &EditorRoutes::show_all_audiotracks))); - items.push_back (MenuElem (_("Hide All Audio Tracks"), mem_fun (*this, &EditorRoutes::hide_all_audiotracks))); - items.push_back (MenuElem (_("Show All Audio Busses"), mem_fun (*this, &EditorRoutes::show_all_audiobus))); - items.push_back (MenuElem (_("Hide All Audio Busses"), mem_fun (*this, &EditorRoutes::hide_all_audiobus))); - + items.push_back (MenuElem (_("Show All"), sigc::mem_fun (*this, &EditorRoutes::show_all_routes))); + items.push_back (MenuElem (_("Hide All"), sigc::mem_fun (*this, &EditorRoutes::hide_all_routes))); + items.push_back (MenuElem (_("Show All Audio Tracks"), sigc::mem_fun (*this, &EditorRoutes::show_all_audiotracks))); + items.push_back (MenuElem (_("Hide All Audio Tracks"), sigc::mem_fun (*this, &EditorRoutes::hide_all_audiotracks))); + items.push_back (MenuElem (_("Show All Audio Busses"), sigc::mem_fun (*this, &EditorRoutes::show_all_audiobus))); + 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 @@ -163,17 +406,17 @@ EditorRoutes::show_menu () void EditorRoutes::redisplay () { + if (_no_redisplay || !_session) { + return; + } + TreeModel::Children rows = _model->children(); TreeModel::Children::iterator i; uint32_t position; int n; - if (_no_redisplay) { - return; - } - for (n = 0, position = 0, i = rows.begin(); i != rows.end(); ++i) { - TimeAxisViewPtr tv = (*i)[_columns.tv]; + TimeAxisView *tv = (*i)[_columns.tv]; boost::shared_ptr route = (*i)[_columns.route]; if (tv == 0) { @@ -182,17 +425,15 @@ EditorRoutes::redisplay () } if (!_redisplay_does_not_reset_order_keys) { - /* this reorder is caused by user action, so reassign sort order keys to tracks. */ - route->set_order_key (N_ ("editor"), n); } bool visible = (*i)[_columns.visible]; - /* show or hide the TimeAxisViewPtr */ + /* show or hide the TimeAxisView */ if (visible) { tv->set_marked_for_display (true); position += tv->show_at (position, n, &_editor->edit_controls_vbox); @@ -201,22 +442,24 @@ EditorRoutes::redisplay () tv->set_marked_for_display (false); tv->hide (); } - + n++; } + /* whenever we go idle, update the track view list to reflect the new order. we can't do this here, because we could mess up something that is traversing the track order and has caused a redisplay of the list. */ + Glib::signal_idle().connect (sigc::mem_fun (*_editor, &Editor::sync_track_view_list_and_routes)); - Glib::signal_idle().connect (mem_fun (*_editor, &Editor::sync_track_view_list_and_routes)); - + _editor->reset_controls_layout_height (position); + _editor->reset_controls_layout_width (); _editor->full_canvas_height = position + _editor->canvas_timebars_vsize; _editor->vertical_adjustment.set_upper (_editor->full_canvas_height); if ((_editor->vertical_adjustment.get_value() + _editor->_canvas_height) > _editor->vertical_adjustment.get_upper()) { - /* + /* We're increasing the size of the canvas while the bottom is visible. We scroll down to keep in step with the controls layout. */ @@ -229,20 +472,36 @@ EditorRoutes::redisplay () } void -EditorRoutes::route_deleted (Gtk::TreeModel::Path const & path) +EditorRoutes::route_deleted (Gtk::TreeModel::Path const &) { - /* this could require an order reset & sync */ + if (!_session || _session->deletion_in_progress()) { + return; + } + + /* this could require an order reset & sync */ _session->set_remote_control_ids(); _ignore_reorder = true; redisplay (); _ignore_reorder = false; } - void -EditorRoutes::changed (Gtk::TreeModel::Path const & path, Gtk::TreeModel::iterator const & iter) +EditorRoutes::visible_changed (std::string const & path) { - /* never reset order keys because of a property change */ + if (_session && _session->deletion_in_progress()) { + return; + } + + TreeIter iter; + + if ((iter = _model->get_iter (path))) { + TimeAxisView* tv = (*iter)[_columns.tv]; + if (tv) { + bool visible = (*iter)[_columns.visible]; + (*iter)[_columns.visible] = !visible; + } + } + _redisplay_does_not_reset_order_keys = true; _session->set_remote_control_ids(); redisplay (); @@ -250,14 +509,14 @@ EditorRoutes::changed (Gtk::TreeModel::Path const & path, Gtk::TreeModel::iterat } void -EditorRoutes::routes_added (list routes) +EditorRoutes::routes_added (list routes) { TreeModel::Row row; _redisplay_does_not_sync_order_keys = true; suspend_redisplay (); - for (list::iterator x = routes.begin(); x != routes.end(); ++x) { + for (list::iterator x = routes.begin(); x != routes.end(); ++x) { row = *(_model->append ()); @@ -266,38 +525,59 @@ EditorRoutes::routes_added (list routes) row[_columns.tv] = *x; row[_columns.route] = (*x)->route (); row[_columns.is_track] = (boost::dynamic_pointer_cast ((*x)->route()) != 0); + row[_columns.mute_state] = (*x)->route()->muted(); + row[_columns.solo_state] = RouteUI::solo_visual_state ((*x)->route()); + row[_columns.solo_isolate_state] = (*x)->route()->solo_isolated(); + row[_columns.solo_safe_state] = (*x)->route()->solo_safe(); + row[_columns.name_editable] = true; _ignore_reorder = true; - + /* added a new fresh one at the end */ if ((*x)->route()->order_key (N_ ("editor")) == -1) { (*x)->route()->set_order_key (N_ ("editor"), _model->children().size()-1); } - + _ignore_reorder = false; boost::weak_ptr wr ((*x)->route()); - (*x)->route()->gui_changed.connect (mem_fun (*this, &EditorRoutes::handle_gui_changes)); - (*x)->route()->NameChanged.connect (bind (mem_fun (*this, &EditorRoutes::route_name_changed), wr)); - (*x)->GoingAway.connect (bind (mem_fun (*this, &EditorRoutes::route_removed), *x)); + + (*x)->route()->gui_changed.connect (*this, MISSING_INVALIDATOR, ui_bind (&EditorRoutes::handle_gui_changes, this, _1, _2), gui_context()); + (*x)->route()->PropertyChanged.connect (*this, MISSING_INVALIDATOR, ui_bind (&EditorRoutes::route_property_changed, this, _1, wr), gui_context()); if ((*x)->is_track()) { boost::shared_ptr t = boost::dynamic_pointer_cast ((*x)->route()); - t->diskstream()->RecordEnableChanged.connect (mem_fun (*this, &EditorRoutes::update_rec_display)); + t->RecordEnableChanged.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()); } + + (*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, ui_bind (&EditorRoutes::update_solo_display, this, _1), gui_context()); + (*x)->route()->listen_changed.connect (*this, MISSING_INVALIDATOR, ui_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()); } + update_rec_display (); + update_mute_display (); + update_solo_display (true); + update_solo_isolate_display (); + update_solo_safe_display (); resume_redisplay (); _redisplay_does_not_sync_order_keys = false; } void -EditorRoutes::handle_gui_changes (string const & what, void *src) +EditorRoutes::handle_gui_changes (string const & what, void*) { - ENSURE_GUI_THREAD (bind (mem_fun(*this, &EditorRoutes::handle_gui_changes), what, src)); + ENSURE_GUI_THREAD (*this, &EditorRoutes::handle_gui_changes, what, src) if (what == "track_height") { - /* Optional :make tracks change height while it happens, instead + /* Optional :make tracks change height while it happens, instead of on first-idle */ //update_canvas_now (); @@ -310,22 +590,21 @@ EditorRoutes::handle_gui_changes (string const & what, void *src) } void -EditorRoutes::route_removed (TimeAxisViewPtr tv) +EditorRoutes::route_removed (TimeAxisView *tv) { - ENSURE_GUI_THREAD (bind (mem_fun(*this, &EditorRoutes::route_removed), tv)); + ENSURE_GUI_THREAD (*this, &EditorRoutes::route_removed, tv) TreeModel::Children rows = _model->children(); TreeModel::Children::iterator ri; - /* the core model has changed, there is no need to sync + /* the core model has changed, there is no need to sync view orders. */ _redisplay_does_not_sync_order_keys = true; for (ri = rows.begin(); ri != rows.end(); ++ri) { - TimeAxisViewPtr t = (*ri)[_columns.tv]; - if (t == tv) { + if ((*ri)[_columns.tv] == tv) { _model->erase (ri); break; } @@ -335,25 +614,30 @@ EditorRoutes::route_removed (TimeAxisViewPtr tv) } void -EditorRoutes::route_name_changed (boost::weak_ptr r) +EditorRoutes::route_property_changed (const PropertyChange& what_changed, boost::weak_ptr r) { - ENSURE_GUI_THREAD (bind (mem_fun (*this, &EditorRoutes::route_name_changed), r)); + if (!what_changed.contains (ARDOUR::Properties::name)) { + return; + } + + ENSURE_GUI_THREAD (*this, &EditorRoutes::route_name_changed, r) boost::shared_ptr route = r.lock (); + if (!route) { return; } - + TreeModel::Children rows = _model->children(); 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(); break; } - } + } } void @@ -365,7 +649,7 @@ EditorRoutes::update_visibility () suspend_redisplay (); for (i = rows.begin(); i != rows.end(); ++i) { - TimeAxisViewPtr tv = (*i)[_columns.tv]; + TimeAxisView *tv = (*i)[_columns.tv]; (*i)[_columns.visible] = tv->marked_for_display (); cerr << "marked " << tv->name() << " for display = " << tv->marked_for_display() << endl; } @@ -374,42 +658,44 @@ EditorRoutes::update_visibility () } void -EditorRoutes::hide_track_in_display (TimeAxisViewPtr tv) +EditorRoutes::hide_track_in_display (TimeAxisView& tv) { TreeModel::Children rows = _model->children(); TreeModel::Children::iterator i; for (i = rows.begin(); i != rows.end(); ++i) { - TimeAxisViewPtr t = (*i)[_columns.tv]; - if (t == tv) { + if ((*i)[_columns.tv] == &tv) { (*i)[_columns.visible] = false; break; } } + + redisplay (); } void -EditorRoutes::show_track_in_display (TimeAxisViewPtr tv) +EditorRoutes::show_track_in_display (TimeAxisView& tv) { TreeModel::Children rows = _model->children(); TreeModel::Children::iterator i; - + for (i = rows.begin(); i != rows.end(); ++i) { - TimeAxisViewPtr t = (*i)[_columns.tv]; - if (t == tv) { + if ((*i)[_columns.tv] == &tv) { (*i)[_columns.visible] = true; break; } } + + redisplay (); } void -EditorRoutes::reordered (TreeModel::Path const & path, TreeModel::iterator const & iter, int* what) +EditorRoutes::reordered (TreeModel::Path const &, TreeModel::iterator const &, int* /*what*/) { redisplay (); } -/** If src == "editor", take editor order keys from each route and use them to rearrange the +/** If src != "editor", take editor order keys from each route and use them to rearrange the * route list so that the visual arrangement of routes matches the order keys from the routes. */ void @@ -419,7 +705,7 @@ EditorRoutes::sync_order_keys (string const & src) TreeModel::Children rows = _model->children(); TreeModel::Children::iterator ri; - if (src != N_ ("editor") || !_session || (_session->state_of_the_state() & Session::Loading) || rows.empty()) { + if (src == N_ ("editor") || !_session || (_session->state_of_the_state() & (Session::Loading|Session::Deletion)) || rows.empty()) { return; } @@ -452,7 +738,7 @@ EditorRoutes::sync_order_keys (string const & src) void -EditorRoutes::hide_all_tracks (bool with_select) +EditorRoutes::hide_all_tracks (bool /*with_select*/) { TreeModel::Children rows = _model->children(); TreeModel::Children::iterator i; @@ -460,14 +746,14 @@ EditorRoutes::hide_all_tracks (bool with_select) suspend_redisplay (); for (i = rows.begin(); i != rows.end(); ++i) { - + TreeModel::Row row = (*i); - TimeAxisViewPtr tv = row[_columns.tv]; + TimeAxisView *tv = row[_columns.tv]; if (tv == 0) { continue; } - + row[_columns.visible] = false; } @@ -491,12 +777,12 @@ EditorRoutes::set_all_tracks_visibility (bool yn) for (i = rows.begin(); i != rows.end(); ++i) { TreeModel::Row row = (*i); - TimeAxisViewPtr tv = row[_columns.tv]; + TimeAxisView* tv = row[_columns.tv]; if (tv == 0) { continue; } - + (*i)[_columns.visible] = yn; } @@ -504,7 +790,7 @@ EditorRoutes::set_all_tracks_visibility (bool yn) } void -EditorRoutes::set_all_audio_visibility (int tracks, bool yn) +EditorRoutes::set_all_audio_midi_visibility (int tracks, bool yn) { TreeModel::Children rows = _model->children(); TreeModel::Children::iterator i; @@ -512,15 +798,18 @@ EditorRoutes::set_all_audio_visibility (int tracks, bool yn) suspend_redisplay (); for (i = rows.begin(); i != rows.end(); ++i) { + TreeModel::Row row = (*i); - TimeAxisViewPtr tv = row[_columns.tv]; - AudioTimeAxisViewPtr atv; - + TimeAxisView* tv = row[_columns.tv]; + + AudioTimeAxisView* atv; + MidiTimeAxisView* mtv; + if (tv == 0) { continue; } - if ((atv = boost::dynamic_pointer_cast(tv)) != 0) { + if ((atv = dynamic_cast(tv)) != 0) { switch (tracks) { case 0: (*i)[_columns.visible] = yn; @@ -531,7 +820,7 @@ EditorRoutes::set_all_audio_visibility (int tracks, bool yn) (*i)[_columns.visible] = yn; } break; - + case 2: if (!atv->is_audio_track()) { (*i)[_columns.visible] = yn; @@ -539,6 +828,19 @@ EditorRoutes::set_all_audio_visibility (int tracks, bool yn) break; } } + else if ((mtv = dynamic_cast(tv)) != 0) { + switch (tracks) { + case 0: + (*i)[_columns.visible] = yn; + break; + + case 3: + if (mtv->is_midi_track()) { + (*i)[_columns.visible] = yn; + } + break; + } + } } resume_redisplay (); @@ -556,26 +858,138 @@ EditorRoutes::show_all_routes () set_all_tracks_visibility (true); } +void +EditorRoutes::show_all_audiotracks() +{ + set_all_audio_midi_visibility (1, true); +} +void +EditorRoutes::hide_all_audiotracks () +{ + set_all_audio_midi_visibility (1, false); +} + void EditorRoutes::show_all_audiobus () { - set_all_audio_visibility (2, true); + set_all_audio_midi_visibility (2, true); } void EditorRoutes::hide_all_audiobus () { - set_all_audio_visibility (2, false); + set_all_audio_midi_visibility (2, false); } void -EditorRoutes::show_all_audiotracks() +EditorRoutes::show_all_miditracks() { - set_all_audio_visibility (1, true); + set_all_audio_midi_visibility (3, true); } void -EditorRoutes::hide_all_audiotracks () +EditorRoutes::hide_all_miditracks () { - set_all_audio_visibility (1, false); + set_all_audio_midi_visibility (3, false); +} + +bool +EditorRoutes::key_press (GdkEventKey* ev) +{ + TreeViewColumn *col; + boost::shared_ptr rl (new RouteList); + TreePath path; + + switch (ev->keyval) { + case GDK_Tab: + case GDK_ISO_Left_Tab: + + /* If we appear to be editing something, leave that cleanly and appropriately. + */ + if (name_editable) { + name_editable->editing_done (); + name_editable = 0; + } + + col = _display.get_column (5); // select&focus on name column + + if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) { + treeview_select_previous (_display, _model, col); + } else { + treeview_select_next (_display, _model, col); + } + + return true; + break; + + case 'm': + if (get_relevant_routes (rl)) { + _session->set_mute (rl, !rl->front()->muted(), Session::rt_cleanup); + } + return true; + break; + + case 's': + 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); + } + return true; + break; + + case 'r': + if (get_relevant_routes (rl)) { + _session->set_record_enabled (rl, !rl->front()->record_enabled(), Session::rt_cleanup); + } + break; + + default: + break; + } + + return false; +} + +bool +EditorRoutes::get_relevant_routes (boost::shared_ptr rl) +{ + TimeAxisView* tv; + RouteTimeAxisView* rtv; + RefPtr selection = _display.get_selection(); + TreePath path; + TreeIter iter; + + if (selection->count_selected_rows() != 0) { + + /* use selection */ + + RefPtr tm = RefPtr::cast_dynamic (_model); + iter = selection->get_selected (tm); + + } else { + /* use mouse pointer */ + + int x, y; + int bx, by; + + _display.get_pointer (x, y); + _display.convert_widget_to_bin_window_coords (x, y, bx, by); + + if (_display.get_path_at_pos (bx, by, path)) { + iter = _model->get_iter (path); + } + } + + if (iter) { + tv = (*iter)[_columns.tv]; + if (tv) { + rtv = dynamic_cast(tv); + if (rtv) { + rl->push_back (rtv->route()); + } + } + } + + return !rl->empty(); } bool @@ -585,46 +999,49 @@ EditorRoutes::button_press (GdkEventButton* ev) show_menu (); return true; } - - TreeIter iter; - TreeModel::Path path; - TreeViewColumn* column; - int cellx; - int celly; - if (!_display.get_path_at_pos ((int)ev->x, (int)ev->y, path, column, cellx, celly)) { - return false; - } - - switch (GPOINTER_TO_UINT (column->get_data (X_("colnum")))) { + //Scroll editor canvas to selected track + if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) { + + TreeModel::Path path; + TreeViewColumn *tvc; + int cell_x; + int cell_y; + + _display.get_path_at_pos ((int) ev->x, (int) ev->y, path, tvc, cell_x, cell_y); - case 0: - /* allow normal processing to occur */ - return false; - case 1: - if ((iter = _model->get_iter (path))) { - TimeAxisViewPtr tv = (*iter)[_columns.tv]; - if (tv) { - bool visible = (*iter)[_columns.visible]; - (*iter)[_columns.visible] = !visible; - } + // Get the model row. + Gtk::TreeModel::Row row = *_model->get_iter (path); + + TimeAxisView *tv = row[_columns.tv]; + + int y_pos = tv->y_position(); + + //Clamp the y pos so that we do not extend beyond the canvas full height. + if (_editor->full_canvas_height - y_pos < _editor->_canvas_height){ + y_pos = _editor->full_canvas_height - _editor->_canvas_height; + } + + //Only scroll to if the track is visible + if(y_pos != -1){ + _editor->reset_y_origin (y_pos); } - return true; - - case 2: - /* allow normal processing to occur */ - return false; - - default: - break; } - + return false; } bool -EditorRoutes::selection_filter (Glib::RefPtr const &, TreeModel::Path const &, bool) +EditorRoutes::selection_filter (Glib::RefPtr const &, TreeModel::Path const&, bool /*selected*/) { + if (selection_countdown) { + if (--selection_countdown == 0) { + return true; + } else { + /* no selection yet ... */ + return false; + } + } return true; } @@ -638,15 +1055,19 @@ struct EditorOrderRouteSorter { void EditorRoutes::initial_display () { + suspend_redisplay (); + _model->clear (); + + if (!_session) { + resume_redisplay (); + return; + } + boost::shared_ptr routes = _session->get_routes(); RouteList r (*routes); EditorOrderRouteSorter sorter; r.sort (sorter); - - suspend_redisplay (); - - _model->clear (); _editor->handle_new_route (r); /* don't show master bus in a new session */ @@ -655,29 +1076,30 @@ EditorRoutes::initial_display () TreeModel::Children rows = _model->children(); TreeModel::Children::iterator i; - + _no_redisplay = true; - + for (i = rows.begin(); i != rows.end(); ++i) { - TimeAxisViewPtr tv = (*i)[_columns.tv]; - RouteTimeAxisViewPtr rtv; - - if ((rtv = boost::dynamic_pointer_cast(tv)) != 0) { + + TimeAxisView *tv = (*i)[_columns.tv]; + RouteTimeAxisView *rtv; + + if ((rtv = dynamic_cast(tv)) != 0) { if (rtv->route()->is_master()) { _display.get_selection()->unselect (i); } } } - + _no_redisplay = false; redisplay (); - } + } resume_redisplay (); } void -EditorRoutes::track_list_reorder (Gtk::TreeModel::Path const & path, Gtk::TreeModel::iterator const & iter, int* new_order) +EditorRoutes::track_list_reorder (Gtk::TreeModel::Path const &, Gtk::TreeModel::iterator const &, int* /*new_order*/) { _redisplay_does_not_sync_order_keys = true; _session->set_remote_control_ids(); @@ -685,9 +1107,9 @@ EditorRoutes::track_list_reorder (Gtk::TreeModel::Path const & path, Gtk::TreeMo _redisplay_does_not_sync_order_keys = false; } -void +void EditorRoutes::display_drag_data_received (const RefPtr& context, - int x, int y, + int x, int y, const SelectionData& data, guint info, guint time) { @@ -695,7 +1117,7 @@ EditorRoutes::display_drag_data_received (const RefPtr& contex _display.on_drag_data_received (context, x, y, data, info, time); return; } - + context->drag_finish (true, false, time); } @@ -706,14 +1128,14 @@ EditorRoutes::move_selected_tracks (bool up) return; } - typedef std::pair > ViewRoute; + typedef std::pair > ViewRoute; std::list view_routes; std::vector neworder; TreeModel::Children rows = _model->children(); TreeModel::Children::iterator ri; for (ri = rows.begin(); ri != rows.end(); ++ri) { - TimeAxisViewPtr tv = (*ri)[_columns.tv]; + TimeAxisView* tv = (*ri)[_columns.tv]; boost::shared_ptr route = (*ri)[_columns.route]; view_routes.push_back (ViewRoute (tv, route)); @@ -721,14 +1143,14 @@ EditorRoutes::move_selected_tracks (bool up) list::iterator trailing; list::iterator leading; - + if (up) { - + trailing = view_routes.begin(); leading = view_routes.begin(); - + ++leading; - + while (leading != view_routes.end()) { if (_editor->selection->selected (leading->first)) { view_routes.insert (trailing, ViewRoute (leading->first, leading->second)); @@ -766,7 +1188,7 @@ EditorRoutes::move_selected_tracks (bool up) tmp++; view_routes.insert (tmp, ViewRoute (leading->first, leading->second)); - + /* can't use iter = cont.erase (iter); form here, because we need iter to move backwards. */ @@ -785,7 +1207,7 @@ EditorRoutes::move_selected_tracks (bool up) } view_routes.erase (leading); - + if (done) { break; } @@ -808,7 +1230,7 @@ EditorRoutes::move_selected_tracks (bool up) _model->reorder (neworder); - _session->sync_order_keys (N_ ("editor")); + _session->sync_order_keys (N_ ("editor")); } void @@ -816,25 +1238,82 @@ EditorRoutes::update_rec_display () { TreeModel::Children rows = _model->children(); TreeModel::Children::iterator i; - + for (i = rows.begin(); i != rows.end(); ++i) { boost::shared_ptr route = (*i)[_columns.route]; - if (boost::dynamic_pointer_cast(route)) { + if (boost::dynamic_pointer_cast (route)) { + boost::shared_ptr mt = boost::dynamic_pointer_cast (route); - if (route->record_enabled()){ - (*i)[_columns.rec_enabled] = true; + if (route->record_enabled()) { + if (_session->record_status() == Session::Recording) { + (*i)[_columns.rec_state] = 1; + } else { + (*i)[_columns.rec_state] = 2; + } + } else if (mt && mt->step_editing()) { + (*i)[_columns.rec_state] = 3; } else { - (*i)[_columns.rec_enabled] = false; + (*i)[_columns.rec_state] = 0; } - } + + (*i)[_columns.name_editable] = !route->record_enabled (); + } + } +} + +void +EditorRoutes::update_mute_display () +{ + 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_visual_state (_session, route); + } +} + +void +EditorRoutes::update_solo_display (bool /* selfsoloed */) +{ + 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.solo_state] = RouteUI::solo_visual_state (route); + } +} + +void +EditorRoutes::update_solo_isolate_display () +{ + 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.solo_isolate_state] = RouteUI::solo_isolate_visual_state (route) > 0 ? 1 : 0; + } +} + +void +EditorRoutes::update_solo_safe_display () +{ + 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.solo_safe_state] = RouteUI::solo_safe_visual_state (route) > 0 ? 1 : 0; } } -list +list EditorRoutes::views () const { - list v; + list v; for (TreeModel::Children::iterator i = _model->children().begin(); i != _model->children().end(); ++i) { v.push_back ((*i)[_columns.tv]); } @@ -849,3 +1328,65 @@ EditorRoutes::clear () _model->clear (); _display.set_model (_model); } + +void +EditorRoutes::name_edit_started (CellEditable* ce, const Glib::ustring&) +{ + name_editable = ce; + + /* give it a special name */ + + Gtk::Entry *e = dynamic_cast (ce); + + if (e) { + e->set_name (X_("RouteNameEditorEntry")); + } +} + +void +EditorRoutes::name_edit (std::string const & path, std::string const & new_text) +{ + name_editable = 0; + + TreeIter iter = _model->get_iter (path); + + if (!iter) { + return; + } + + boost::shared_ptr route = (*iter)[_columns.route]; + + if (route && route->name() != new_text) { + route->set_name (new_text); + } +} + +void +EditorRoutes::solo_changed_so_update_mute () +{ + update_mute_display (); +} + +void +EditorRoutes::show_tracks_with_regions_at_playhead () +{ + boost::shared_ptr const r = _session->get_routes_with_regions_at (_session->transport_frame ()); + + set show; + for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) { + TimeAxisView* tav = _editor->axis_view_from_route (*i); + if (tav) { + show.insert (tav); + } + } + + suspend_redisplay (); + + 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()); + } + + resume_redisplay (); +}