ardour/ardour
ardour
/
ardour
13
1
Fork 0
Code Pull Requests Releases Activity
ardour/gtk2_ardour/route_list_base.cc

1242 lines
38 KiB
C++
Raw Permalink Blame History

/*
* Copyright (C) 2009-2011 Carl Hetherington <carl@carlh.net>
* Copyright (C) 2009-2014 David Robillard <d@drobilla.net>
* Copyright (C) 2009-2017 Paul Davis <paul@linuxaudiosystems.com>
* Copyright (C) 2013-2015 Nick Mainsbridge <mainsbridge@gmail.com>
* Copyright (C) 2014-2019 Robin Gareus <robin@gareus.org>
* Copyright (C) 2016-2018 Len Ovens <len@ovenwerks.net>
*
* 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
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdlib>
#include <list>
#include <vector>
#include "pbd/unwind.h"
#include "ardour/audio_track.h"
#include "ardour/debug.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/treeutils.h"
#include "widgets/tooltips.h"
#include "actions.h"
#include "ardour_ui.h"
#include "route_list_base.h"
#include "gui_thread.h"
#include "keyboard.h"
#include "public_editor.h"
#include "route_sorter.h"
#include "utils.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;
using namespace Gtkmm2ext;
using namespace Glib;
using Gtkmm2ext::Keyboard;
RouteListBase::RouteListBase ()
: _menu (0)
, old_focus (0)
, name_editable (0)
, _ignore_reorder (false)
, _ignore_visibility_change (false)
, _ignore_selection_change (false)
, _column_does_not_select (false)
, _adding_routes (false)
, _route_deletion_in_progress (false)
{
add_name_column ();
#if 0
setup_col (append_toggle (_columns.visible, _columns.noop_true, sigc::mem_fun (*this, &RouteListBase::on_tv_visible_changed)), S_("Visible|V"), _("Track/Bus visible ?"));
setup_col (append_toggle (_columns.trigger, _columns.is_track, sigc::mem_fun (*this, &RouteListBase::on_tv_trigger_changed)), S_("Cues|C"), _("Visible on Cues window ?"));
setup_col (append_toggle (_columns.active, _columns.activatable, sigc::mem_fun (*this, &RouteListBase::on_tv_active_changed)), S_("Active|A"), _("Track/Bus active ?"));
append_col_input_active ();
append_col_rec_enable ();
append_col_rec_safe ();
append_col_mute ();
append_col_solo ();
#endif
_display.set_headers_visible (true);
_display.get_selection ()->set_mode (SELECTION_MULTIPLE);
_display.get_selection ()->signal_changed ().connect (sigc::mem_fun (*this, &RouteListBase::selection_changed));
_display.set_reorderable (true);
_display.set_name (X_("EditGroupList"));
_display.set_rules_hint (true);
_display.set_size_request (100, -1);
_scroller.add (_display);
_scroller.set_policy (POLICY_NEVER, POLICY_AUTOMATIC);
_model = ListStore::create (_columns);
_display.set_model (_model);
_display.get_selection ()->set_select_function (sigc::mem_fun (*this, &RouteListBase::select_function));
_model->signal_row_deleted ().connect (sigc::mem_fun (*this, &RouteListBase::row_deleted));
_model->signal_rows_reordered ().connect (sigc::mem_fun (*this, &RouteListBase::reordered));
_display.signal_button_press_event ().connect (sigc::mem_fun (*this, &RouteListBase::button_press), false);
_display.signal_button_release_event ().connect (sigc::mem_fun (*this, &RouteListBase::button_release), false);
_scroller.signal_key_press_event ().connect (sigc::mem_fun (*this, &RouteListBase::key_press), false);
_scroller.signal_focus_in_event ().connect (sigc::mem_fun (*this, &RouteListBase::focus_in), false);
_scroller.signal_focus_out_event ().connect (sigc::mem_fun (*this, &RouteListBase::focus_out));
_display.signal_enter_notify_event ().connect (sigc::mem_fun (*this, &RouteListBase::enter_notify), false);
_display.signal_leave_notify_event ().connect (sigc::mem_fun (*this, &RouteListBase::leave_notify), false);
_display.set_enable_search (false);
}
RouteListBase::~RouteListBase ()
{
delete _menu;
}
void
RouteListBase::setup_col (Gtk::TreeViewColumn* tvc, const char* label, const char* tooltip, bool require_mod_to_edit)
{
Gtk::Label* l = manage (new Label (label));
set_tooltip (*l, tooltip);
tvc->set_widget (*l);
l->show ();
if (require_mod_to_edit) {
/* Try to prevent single mouse presses from initiating edits.
* This relies on a hack in gtktreeview.c:gtk_treeview_button_press() */
tvc->set_data ("mouse-edits-require-mod1", (gpointer)0x1);
}
}
void
RouteListBase::add_name_column ()
{
Gtk::TreeViewColumn* tvc = manage (new Gtk::TreeViewColumn ("", _columns.text));
setup_col (tvc, _("Name"), ("Track/Bus name"), true);
CellRendererText* cell = dynamic_cast<CellRendererText*> (tvc->get_first_cell ());
cell->signal_editing_started ().connect (sigc::mem_fun (*this, &RouteListBase::name_edit_started));
tvc->set_sizing (TREE_VIEW_COLUMN_FIXED);
tvc->set_expand (true);
tvc->set_min_width (50);
cell->property_editable () = true;
cell->signal_editing_started ().connect (sigc::mem_fun (*this, &RouteListBase::name_edit_started));
cell->signal_edited ().connect (sigc::mem_fun (*this, &RouteListBase::name_edit));
_display.append_column (*tvc);
}
void
RouteListBase::append_col_rec_enable ()
{
CellRendererPixbufMulti* cell;
cell = append_cell (S_("Rec|R"), _("Record enabled"), _columns.rec_state, _columns.is_track, sigc::mem_fun (*this, &RouteListBase::on_tv_rec_enable_changed));
cell->set_pixbuf (0, ::get_icon ("record-normal-disabled"));
cell->set_pixbuf (1, ::get_icon ("record-normal-in-progress"));
cell->set_pixbuf (2, ::get_icon ("record-normal-enabled"));
cell->set_pixbuf (3, ::get_icon ("record-step"));
}
void
RouteListBase::append_col_rec_safe ()
{
CellRendererPixbufMulti* cell;
cell = append_cell (S_("Rec|RS"), _("Record Safe"), _columns.rec_safe, _columns.is_track, sigc::mem_fun (*this, &RouteListBase::on_tv_rec_safe_toggled));
cell->set_pixbuf (0, ::get_icon ("rec-safe-disabled"));
cell->set_pixbuf (1, ::get_icon ("rec-safe-enabled"));
}
void
RouteListBase::append_col_input_active ()
{
CellRendererPixbufMulti* cell;
cell = append_cell (S_("MidiInput|I"), _("MIDI input enabled"), _columns.is_input_active, _columns.is_midi, sigc::mem_fun (*this, &RouteListBase::on_tv_input_active_changed));
cell->set_pixbuf (0, ::get_icon ("midi-input-inactive"));
cell->set_pixbuf (1, ::get_icon ("midi-input-active"));
}
void
RouteListBase::append_col_mute ()
{
CellRendererPixbufMulti* cell;
cell = append_cell (S_("Mute|M"), _("Muted"), _columns.mute_state, _columns.noop_true, sigc::mem_fun (*this, &RouteListBase::on_tv_mute_enable_toggled));
cell->set_pixbuf (Gtkmm2ext::Off, ::get_icon ("mute-disabled"));
cell->set_pixbuf (Gtkmm2ext::ImplicitActive, ::get_icon ("muted-by-others"));
cell->set_pixbuf (Gtkmm2ext::ExplicitActive, ::get_icon ("mute-enabled"));
}
void
RouteListBase::append_col_solo ()
{
CellRendererPixbufMulti* cell;
cell = append_cell (S_("Solo|S"), _("Soloed"), _columns.solo_state, _columns.solo_visible, sigc::mem_fun (*this, &RouteListBase::on_tv_solo_enable_toggled));
cell->set_pixbuf (Gtkmm2ext::Off, ::get_icon ("solo-disabled"));
cell->set_pixbuf (Gtkmm2ext::ExplicitActive, ::get_icon ("solo-enabled"));
cell->set_pixbuf (Gtkmm2ext::ImplicitActive, ::get_icon ("soloed-by-others"));
cell = append_cell (S_("SoloIso|SI"), _("Solo Isolated"), _columns.solo_isolate_state, _columns.solo_lock_iso_visible, sigc::mem_fun (*this, &RouteListBase::on_tv_solo_isolate_toggled));
cell->set_pixbuf (0, ::get_icon ("solo-isolate-disabled"));
cell->set_pixbuf (1, ::get_icon ("solo-isolate-enabled"));
cell = append_cell (S_("SoloLock|SS"), _("Solo Safe (Locked)"), _columns.solo_safe_state, _columns.solo_lock_iso_visible, sigc::mem_fun (*this, &RouteListBase::on_tv_solo_safe_toggled));
cell->set_pixbuf (0, ::get_icon ("solo-safe-disabled"));
cell->set_pixbuf (1, ::get_icon ("solo-safe-enabled"));
}
bool
RouteListBase::focus_in (GdkEventFocus*)
{
Window* win = dynamic_cast<Window*> (_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;
}
bool
RouteListBase::focus_out (GdkEventFocus*)
{
if (old_focus) {
old_focus->grab_focus ();
old_focus = 0;
}
return false;
}
bool
RouteListBase::enter_notify (GdkEventCrossing*)
{
if (name_editable) {
return true;
}
Keyboard::magic_widget_grab_focus ();
return false;
}
bool
RouteListBase::leave_notify (GdkEventCrossing*)
{
if (old_focus) {
old_focus->grab_focus ();
old_focus = 0;
}
Keyboard::magic_widget_drop_focus ();
return false;
}
void
RouteListBase::set_session (Session* s)
{
SessionHandlePtr::set_session (s);
initial_display ();
if (_session) {
_session->vca_manager ().VCAAdded.connect (_session_connections, invalidator (_scroller), boost::bind (&RouteListBase::add_masters, this, _1), gui_context ());
_session->RouteAdded.connect (_session_connections, invalidator (_scroller), boost::bind (&RouteListBase::add_routes, this, _1), gui_context ());
_session->SoloChanged.connect (_session_connections, invalidator (_scroller), boost::bind (&RouteListBase::queue_idle_update, this), gui_context ());
_session->RecordStateChanged.connect (_session_connections, invalidator (_scroller), boost::bind (&RouteListBase::queue_idle_update, this), gui_context ());
PresentationInfo::Change.connect (_session_connections, invalidator (_scroller), boost::bind (&RouteListBase::presentation_info_changed, this, _1), gui_context ());
}
}
void
RouteListBase::on_tv_input_active_changed (std::string const& path_string)
{
Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string));
std::shared_ptr<Stripable> stripable = row[_columns.stripable];
std::shared_ptr<MidiTrack> mt = std::dynamic_pointer_cast<MidiTrack> (stripable);
if (mt) {
mt->set_input_active (!mt->input_active ());
}
}
void
RouteListBase::on_tv_rec_enable_changed (std::string const& path_string)
{
Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string));
std::shared_ptr<Stripable> stripable = row[_columns.stripable];
std::shared_ptr<AutomationControl> ac = stripable->rec_enable_control ();
if (ac) {
ac->set_value (!ac->get_value (), Controllable::UseGroup);
}
}
void
RouteListBase::on_tv_rec_safe_toggled (std::string const& path_string)
{
Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string));
std::shared_ptr<Stripable> stripable = row[_columns.stripable];
std::shared_ptr<AutomationControl> ac (stripable->rec_safe_control ());
if (ac) {
ac->set_value (!ac->get_value (), Controllable::UseGroup);
}
}
void
RouteListBase::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));
std::shared_ptr<Stripable> stripable = row[_columns.stripable];
std::shared_ptr<AutomationControl> ac (stripable->mute_control ());
if (ac) {
ac->set_value (!ac->get_value (), Controllable::UseGroup);
}
}
void
RouteListBase::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));
std::shared_ptr<Stripable> stripable = row[_columns.stripable];
std::shared_ptr<AutomationControl> ac (stripable->solo_control ());
if (ac) {
ac->set_value (!ac->get_value (), Controllable::UseGroup);
}
}
void
RouteListBase::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));
std::shared_ptr<Stripable> stripable = row[_columns.stripable];
std::shared_ptr<AutomationControl> ac (stripable->solo_isolate_control ());
if (ac) {
ac->set_value (!ac->get_value (), Controllable::UseGroup);
}
}
void
RouteListBase::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));
std::shared_ptr<Stripable> stripable = row[_columns.stripable];
std::shared_ptr<AutomationControl> ac (stripable->solo_safe_control ());
if (ac) {
ac->set_value (!ac->get_value (), Controllable::UseGroup);
}
}
void
RouteListBase::build_menu ()
{
using namespace Menu_Helpers;
using namespace Gtk;
_menu = new Menu;
MenuList& items = _menu->items ();
_menu->set_name ("ArdourContextMenu");
items.push_back (MenuElem (_("Show All"), sigc::bind (sigc::mem_fun (*this, &RouteListBase::set_all_audio_midi_visibility), 0, true)));
items.push_back (MenuElem (_("Hide All"), sigc::bind (sigc::mem_fun (*this, &RouteListBase::set_all_audio_midi_visibility), 0, false)));
items.push_back (MenuElem (_("Show All Audio Tracks"), sigc::bind (sigc::mem_fun (*this, &RouteListBase::set_all_audio_midi_visibility), 1, true)));
items.push_back (MenuElem (_("Hide All Audio Tracks"), sigc::bind (sigc::mem_fun (*this, &RouteListBase::set_all_audio_midi_visibility), 1, false)));
items.push_back (MenuElem (_("Show All Midi Tracks"), sigc::bind (sigc::mem_fun (*this, &RouteListBase::set_all_audio_midi_visibility), 3, true)));
items.push_back (MenuElem (_("Hide All Midi Tracks"), sigc::bind (sigc::mem_fun (*this, &RouteListBase::set_all_audio_midi_visibility), 3, false)));
items.push_back (MenuElem (_("Show All Busses"), sigc::bind (sigc::mem_fun (*this, &RouteListBase::set_all_audio_midi_visibility), 2, true)));
items.push_back (MenuElem (_("Hide All Busses"), sigc::bind (sigc::mem_fun (*this, &RouteListBase::set_all_audio_midi_visibility), 2, false)));
items.push_back (MenuElem (_("Only Show Tracks with Regions Under Playhead"), sigc::mem_fun (*this, &RouteListBase::show_tracks_with_regions_at_playhead)));
}
void
RouteListBase::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_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");
if (!_route_deletion_in_progress) {
sync_presentation_info_from_treeview ();
}
}
void
RouteListBase::reordered (TreeModel::Path const&, TreeModel::iterator const&, int* /*what*/)
{
/* 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_presentation_info_from_treeview ();
}
void
RouteListBase::on_tv_visible_changed (std::string const& path)
{
if (!_session || _session->deletion_in_progress ()) {
return;
}
if (_ignore_visibility_change) {
return;
}
DisplaySuspender ds;
TreeIter iter;
if ((iter = _model->get_iter (path))) {
bool hidden = (*iter)[_columns.visible]; // toggle -> invert flag
std::shared_ptr<Stripable> stripable = (*iter)[_columns.stripable];
if (hidden != stripable->presentation_info ().hidden ()) {
stripable->presentation_info ().set_hidden (hidden);
std::shared_ptr<Route> route = std::dynamic_pointer_cast<Route> (stripable);
RouteGroup* rg = route ? route->route_group () : 0;
if (rg && rg->is_active () && rg->is_hidden ()) {
std::shared_ptr<RouteList> rl (rg->route_list ());
for (RouteList::const_iterator i = rl->begin (); i != rl->end (); ++i) {
(*i)->presentation_info ().set_hidden (hidden);
}
}
}
}
}
void
RouteListBase::on_tv_trigger_changed (std::string const& path)
{
if (!_session || _session->deletion_in_progress ()) {
return;
}
Gtk::TreeModel::Row row = *_model->get_iter (path);
assert (row[_columns.is_track]);
std::shared_ptr<Stripable> stripable = row[_columns.stripable];
bool const tt = row[_columns.trigger];
stripable->presentation_info ().set_trigger_track (!tt);
}
void
RouteListBase::on_tv_active_changed (std::string const& path)
{
if (!_session || _session->deletion_in_progress ()) {
return;
}
Gtk::TreeModel::Row row = *_model->get_iter (path);
std::shared_ptr<Stripable> stripable = row[_columns.stripable];
std::shared_ptr<Route> route = std::dynamic_pointer_cast<Route> (stripable);
if (route) {
bool const active = row[_columns.active];
route->set_active (!active, this);
}
}
void
RouteListBase::initial_display ()
{
if (!_session) {
clear ();
return;
}
_model->clear ();
StripableList sl;
_session->get_stripables (sl);
add_stripables (sl);
sync_treeview_from_presentation_info (Properties::order);
}
void
RouteListBase::add_masters (VCAList& vlist)
{
StripableList sl;
for (VCAList::iterator v = vlist.begin (); v != vlist.end (); ++v) {
sl.push_back (std::dynamic_pointer_cast<Stripable> (*v));
}
add_stripables (sl);
}
void
RouteListBase::add_routes (RouteList& rlist)
{
StripableList sl;
for (RouteList::iterator r = rlist.begin (); r != rlist.end (); ++r) {
sl.push_back (*r);
}
add_stripables (sl);
}
void
RouteListBase::add_stripables (StripableList& slist)
{
PBD::Unwinder<bool> at (_adding_routes, true);
Gtk::TreeModel::Children::iterator insert_iter = _model->children ().end ();
slist.sort (Stripable::Sorter ());
for (Gtk::TreeModel::Children::iterator it = _model->children ().begin (); it != _model->children ().end (); ++it) {
std::shared_ptr<Stripable> r = (*it)[_columns.stripable];
if (r->presentation_info ().order () == (slist.front ()->presentation_info ().order () + slist.size ())) {
insert_iter = it;
break;
}
}
{
PBD::Unwinder<bool> uw (_ignore_selection_change, true);
_display.set_model (Glib::RefPtr<ListStore> ());
}
for (StripableList::iterator s = slist.begin (); s != slist.end (); ++s) {
std::shared_ptr<Stripable> stripable = *s;
std::shared_ptr<MidiTrack> midi_trk;
std::shared_ptr<Route> route;
TreeModel::Row row;
if (std::dynamic_pointer_cast<VCA> (stripable)) {
row = *(_model->insert (insert_iter));
row[_columns.is_track] = false;
row[_columns.is_input_active] = false;
row[_columns.is_midi] = false;
row[_columns.activatable] = true;
} else if ((route = std::dynamic_pointer_cast<Route> (*s))) {
if (route->is_auditioner ()) {
continue;
}
if (route->is_monitor ()) {
continue;
}
if (route->is_surround_master ()) {
continue;
}
row = *(_model->insert (insert_iter));
midi_trk = std::dynamic_pointer_cast<MidiTrack> (stripable);
row[_columns.is_track] = (std::dynamic_pointer_cast<Track> (stripable) != 0);
row[_columns.activatable] = !stripable->is_singleton ();
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;
}
}
row[_columns.noop_true] = true;
row[_columns.text] = stripable->name ();
row[_columns.visible] = !stripable->presentation_info ().hidden ();
row[_columns.trigger] = stripable->presentation_info ().trigger_track () && row[_columns.is_track];
row[_columns.active] = true;
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.activatable];
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;
std::weak_ptr<Stripable> 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)
*/
stripable->PropertyChanged.connect (_stripable_connections, invalidator (_scroller), boost::bind (&RouteListBase::route_property_changed, this, _1, ws), gui_context ());
stripable->presentation_info ().PropertyChanged.connect (_stripable_connections, invalidator (_scroller), boost::bind (&RouteListBase::route_property_changed, this, _1, ws), gui_context ());
if (std::dynamic_pointer_cast<Track> (stripable)) {
std::shared_ptr<Track> t = std::dynamic_pointer_cast<Track> (stripable);
t->rec_enable_control ()->Changed.connect (_stripable_connections, invalidator (_scroller), boost::bind (&RouteListBase::queue_idle_update, this), gui_context ());
t->rec_safe_control ()->Changed.connect (_stripable_connections, invalidator (_scroller), boost::bind (&RouteListBase::queue_idle_update, this), gui_context ());
}
if (midi_trk) {
midi_trk->StepEditStatusChange.connect (_stripable_connections, invalidator (_scroller), boost::bind (&RouteListBase::queue_idle_update, this), gui_context ());
midi_trk->InputActiveChanged.connect (_stripable_connections, invalidator (_scroller), boost::bind (&RouteListBase::update_input_active_display, this), gui_context ());
}
std::shared_ptr<AutomationControl> ac;
if ((ac = stripable->mute_control ()) != 0) {
ac->Changed.connect (_stripable_connections, invalidator (_scroller), boost::bind (&RouteListBase::queue_idle_update, this), gui_context ());
}
if ((ac = stripable->solo_control ()) != 0) {
ac->Changed.connect (_stripable_connections, invalidator (_scroller), boost::bind (&RouteListBase::queue_idle_update, this), gui_context ());
}
if ((ac = stripable->solo_isolate_control ()) != 0) {
ac->Changed.connect (_stripable_connections, invalidator (_scroller), boost::bind (&RouteListBase::queue_idle_update, this), gui_context ());
}
if ((ac = stripable->solo_safe_control ()) != 0) {
ac->Changed.connect (_stripable_connections, invalidator (_scroller), boost::bind (&RouteListBase::queue_idle_update, this), gui_context ());
}
if (route) {
route->active_changed.connect (_stripable_connections, invalidator (_scroller), boost::bind (&RouteListBase::queue_idle_update, this), gui_context ());
}
stripable->DropReferences.connect (_stripable_connections, invalidator (_scroller), boost::bind (&RouteListBase::remove_strip, this, ws), gui_context ());
}
queue_idle_update ();
update_input_active_display ();
{
PBD::Unwinder<bool> uw (_ignore_selection_change, true);
_display.set_model (_model);
/* set the treeview model selection state */
TreeModel::Children rows = _model->children ();
for (TreeModel::Children::iterator ri = rows.begin (); ri != rows.end (); ++ri) {
std::shared_ptr<Stripable> stripable = (*ri)[_columns.stripable];
if (stripable && stripable->is_selected ()) {
_display.get_selection ()->select (*ri);
} else {
_display.get_selection ()->unselect (*ri);
}
}
}
}
void
RouteListBase::remove_strip (std::weak_ptr<ARDOUR::Stripable> ws)
{
std::shared_ptr<Stripable> stripable (ws.lock ());
if (!stripable) {
return;
}
TreeModel::Children rows = _model->children ();
TreeModel::Children::iterator ri;
PBD::Unwinder<bool> uw (_ignore_selection_change, true);
for (ri = rows.begin (); ri != rows.end (); ++ri) {
std::shared_ptr<Stripable> s = (*ri)[_columns.stripable];
if (s == stripable) {
PBD::Unwinder<bool> uw (_route_deletion_in_progress, true);
_model->erase (ri);
break;
}
}
}
void
RouteListBase::route_property_changed (const PropertyChange& what_changed, std::weak_ptr<Stripable> s)
{
if (_adding_routes) {
return;
}
PropertyChange interests;
interests.add (ARDOUR::Properties::name);
interests.add (ARDOUR::Properties::hidden);
interests.add (ARDOUR::Properties::trigger_track);
if (!what_changed.contains (interests)) {
return;
}
std::shared_ptr<Stripable> stripable = s.lock ();
if (!stripable) {
return;
}
TreeModel::Children rows = _model->children ();
for (TreeModel::Children::iterator i = rows.begin (); i != rows.end (); ++i) {
std::shared_ptr<Stripable> ss = (*i)[_columns.stripable];
if (ss != stripable) {
continue;
}
if (what_changed.contains (ARDOUR::Properties::name)) {
(*i)[_columns.text] = stripable->name ();
}
if (what_changed.contains (ARDOUR::Properties::hidden)) {
(*i)[_columns.visible] = !stripable->presentation_info ().hidden ();
}
if (what_changed.contains (ARDOUR::Properties::trigger_track)) {
(*i)[_columns.trigger] = stripable->presentation_info ().trigger_track () && (*i)[_columns.is_track];
}
break;
}
}
void
RouteListBase::presentation_info_changed (PropertyChange const& what_changed)
{
PropertyChange soh;
soh.add (Properties::order);
soh.add (Properties::selected);
if (what_changed.contains (soh)) {
sync_treeview_from_presentation_info (what_changed);
}
}
void
RouteListBase::sync_presentation_info_from_treeview ()
{
if (_ignore_reorder || !_session || _session->deletion_in_progress ()) {
return;
}
TreeModel::Children rows = _model->children ();
if (rows.empty ()) {
return;
}
DEBUG_TRACE (DEBUG::OrderKeys, "editor sync presentation info from treeview\n");
PresentationInfo::order_t order = 0;
PresentationInfo::ChangeSuspender cs;
for (TreeModel::Children::iterator ri = rows.begin (); ri != rows.end (); ++ri) {
std::shared_ptr<Stripable> stripable = (*ri)[_columns.stripable];
bool visible = (*ri)[_columns.visible];
stripable->presentation_info ().set_hidden (!visible);
stripable->set_presentation_order (order);
++order;
}
}
void
RouteListBase::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.
*/
if (_ignore_reorder || !_session || _session->deletion_in_progress ()) {
return;
}
TreeModel::Children rows = _model->children ();
if (rows.empty ()) {
return;
}
DEBUG_TRACE (DEBUG::OrderKeys, "editor sync model from presentation info.\n");
bool changed = false;
if (what_changed.contains (Properties::order)) {
vector<int> neworder;
uint32_t old_order = 0;
TreeOrderKeys sorted;
for (TreeModel::Children::iterator ri = rows.begin (); ri != rows.end (); ++ri, ++old_order) {
std::shared_ptr<Stripable> stripable = (*ri)[_columns.stripable];
/* use global order */
sorted.push_back (TreeOrderKey (old_order, stripable));
}
TreeOrderKeySorter cmp;
sort (sorted.begin (), sorted.end (), cmp);
neworder.assign (sorted.size (), 0);
uint32_t n = 0;
for (TreeOrderKeys::iterator sr = sorted.begin (); sr != sorted.end (); ++sr, ++n) {
neworder[n] = sr->old_display_order;
if (sr->old_display_order != n) {
changed = true;
}
}
if (changed) {
Unwinder<bool> 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<bool> uw2 (_ignore_selection_change, true);
_display.unset_model ();
_model->reorder (neworder);
_display.set_model (_model);
}
}
if (changed || what_changed.contains (Properties::selected)) {
/* by the time this is invoked, the GUI Selection model has
* already updated itself.
*/
PBD::Unwinder<bool> uw (_ignore_selection_change, true);
/* set the treeview model selection state */
for (TreeModel::Children::iterator ri = rows.begin (); ri != rows.end (); ++ri) {
std::shared_ptr<Stripable> stripable = (*ri)[_columns.stripable];
if (stripable && stripable->is_selected ()) {
_display.get_selection ()->select (*ri);
} else {
_display.get_selection ()->unselect (*ri);
}
}
}
}
void
RouteListBase::set_all_audio_midi_visibility (int which, bool yn)
{
TreeModel::Children rows = _model->children ();
TreeModel::Children::iterator i;
DisplaySuspender ds;
PBD::Unwinder<bool> uw (_ignore_visibility_change, true);
for (i = rows.begin (); i != rows.end (); ++i) {
std::shared_ptr<Stripable> stripable = (*i)[_columns.stripable];
/*
* which = 0: any (incl. VCA)
* which = 1: audio-tracks
* which = 2: busses
* which = 3: midi-tracks
*/
bool is_audio = std::dynamic_pointer_cast<AudioTrack> (stripable) != 0;
bool is_midi = std::dynamic_pointer_cast<MidiTrack> (stripable) != 0;
bool is_bus = !is_audio && !is_midi && std::dynamic_pointer_cast<Route> (stripable) != 0;
switch (which) {
case 0:
(*i)[_columns.visible] = yn;
break;
case 1:
if (is_audio) {
(*i)[_columns.visible] = yn;
}
break;
case 2:
if (is_bus) {
(*i)[_columns.visible] = yn;
}
break;
case 3:
if (is_midi) {
(*i)[_columns.visible] = yn;
}
break;
default:
assert (0);
}
}
sync_presentation_info_from_treeview ();
}
bool
RouteListBase::key_press (GdkEventKey* ev)
{
TreeViewColumn* col;
TreePath path;
std::shared_ptr<RouteList> rl (new RouteList);
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 (0); /* track-name col */
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_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)) {
_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)) {
for (RouteList::const_iterator r = rl->begin (); r != rl->end (); ++r) {
std::shared_ptr<Track> t = std::dynamic_pointer_cast<Track> (*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;
default:
break;
}
return false;
}
bool
RouteListBase::get_relevant_routes (std::shared_ptr<RouteList> rl)
{
RefPtr<TreeSelection> selection = _display.get_selection ();
TreePath path;
TreeIter iter;
if (selection->count_selected_rows () != 0) {
/* use selection */
RefPtr<TreeModel> tm = RefPtr<TreeModel>::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) {
std::shared_ptr<Stripable> stripable = (*iter)[_columns.stripable];
std::shared_ptr<Route> route = std::dynamic_pointer_cast<Route> (stripable);
if (route) {
rl->push_back (route);
}
}
return !rl->empty ();
}
bool
RouteListBase::select_function (const Glib::RefPtr<Gtk::TreeModel>&, const Gtk::TreeModel::Path&, bool)
{
return !_column_does_not_select;
}
bool
RouteListBase::button_release (GdkEventButton*)
{
_column_does_not_select = false;
return false;
}
bool
RouteListBase::button_press (GdkEventButton* ev)
{
if (Keyboard::is_context_menu_event (ev)) {
if (_menu == 0) {
build_menu ();
}
_menu->popup (ev->button, ev->time);
return true;
}
TreeModel::Path path;
TreeViewColumn* tvc;
int cell_x;
int cell_y;
if (!_display.get_path_at_pos ((int)ev->x, (int)ev->y, path, tvc, cell_x, cell_y)) {
/* cancel selection */
_display.get_selection ()->unselect_all ();
/* end any editing by grabbing focus */
_display.grab_focus ();
return true;
}
if (no_select_columns.find (tvc) != no_select_columns.end ()) {
_column_does_not_select = true;
}
//Scroll editor canvas to selected track
if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
PublicEditor& e (PublicEditor::instance ());
Gtk::TreeModel::Row row = *_model->get_iter (path);
TimeAxisView* tv = e.time_axis_view_from_stripable (row[_columns.stripable]);
if (tv) {
e.ensure_time_axis_view_is_visible (*tv, true);
}
}
return false;
}
void
RouteListBase::selection_changed ()
{
if (_ignore_selection_change || _column_does_not_select) {
return;
}
PublicEditor& e (PublicEditor::instance ());
TrackViewList selected;
if (_display.get_selection ()->count_selected_rows () > 0) {
TreeView::Selection::ListHandle_Path rows = _display.get_selection ()->get_selected_rows ();
for (TreeView::Selection::ListHandle_Path::iterator i = rows.begin (); i != rows.end (); ++i) {
TreeIter iter;
if ((iter = _model->get_iter (*i))) {
TimeAxisView* tv = e.time_axis_view_from_stripable ((*iter)[_columns.stripable]);
if (tv) {
selected.push_back (tv);
}
}
}
}
e.begin_reversible_selection_op (X_("Select Track from Route List"));
Selection& s (e.get_selection ());
if (selected.empty ()) {
s.clear_tracks ();
} else {
s.set (selected);
e.ensure_time_axis_view_is_visible (*(selected.front ()), true);
}
e.commit_reversible_selection_op ();
}
void
RouteListBase::update_input_active_display ()
{
TreeModel::Children rows = _model->children ();
TreeModel::Children::iterator i;
for (i = rows.begin (); i != rows.end (); ++i) {
std::shared_ptr<Stripable> stripable = (*i)[_columns.stripable];
if (std::dynamic_pointer_cast<Track> (stripable)) {
std::shared_ptr<MidiTrack> mt = std::dynamic_pointer_cast<MidiTrack> (stripable);
if (mt) {
(*i)[_columns.is_input_active] = mt->input_active ();
}
}
}
}
void
RouteListBase::queue_idle_update ()
{
if (!_idle_update_connection.connected ()) {
_idle_update_connection = Glib::signal_idle ().connect (sigc::mem_fun (*this, &RouteListBase::idle_update_mute_rec_solo_etc));
}
}
bool
RouteListBase::idle_update_mute_rec_solo_etc ()
{
TreeModel::Children rows = _model->children ();
TreeModel::Children::iterator i;
for (i = rows.begin (); i != rows.end (); ++i) {
std::shared_ptr<Stripable> stripable = (*i)[_columns.stripable];
std::shared_ptr<Route> route = std::dynamic_pointer_cast<Route> (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;
}
std::shared_ptr<Track> trk (std::dynamic_pointer_cast<Track> (route));
if (trk) {
std::shared_ptr<MidiTrack> mt = std::dynamic_pointer_cast<MidiTrack> (route);
if (trk->rec_enable_control ()->get_value ()) {
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_state] = 0;
}
(*i)[_columns.rec_safe] = trk->rec_safe_control ()->get_value ();
(*i)[_columns.name_editable] = !trk->rec_enable_control ()->get_value ();
}
}
return false; // do not call again (until needed)
}
void
RouteListBase::clear ()
{
PBD::Unwinder<bool> uw (_ignore_selection_change, true);
_stripable_connections.drop_connections ();
_display.set_model (Glib::RefPtr<Gtk::TreeStore> (0));
_model->clear ();
_display.set_model (_model);
}
void
RouteListBase::name_edit_started (CellEditable* ce, const Glib::ustring&)
{
name_editable = ce;
/* give it a special name */
Gtk::Entry* e = dynamic_cast<Gtk::Entry*> (ce);
if (e) {
e->set_name (X_("RouteNameEditorEntry"));
}
}
void
RouteListBase::name_edit (std::string const& path, std::string const& new_text)
{
name_editable = 0;
TreeIter iter = _model->get_iter (path);
if (!iter) {
return;
}
std::shared_ptr<Stripable> stripable = (*iter)[_columns.stripable];
if (stripable && stripable->name () != new_text) {
stripable->set_name (new_text);
}
}
void
RouteListBase::show_tracks_with_regions_at_playhead ()
{
std::shared_ptr<RouteList> const r = _session->get_routes_with_regions_at (timepos_t (_session->transport_sample ()));
DisplaySuspender ds;
TreeModel::Children rows = _model->children ();
for (TreeModel::Children::iterator i = rows.begin (); i != rows.end (); ++i) {
std::shared_ptr<Stripable> stripable = (*i)[_columns.stripable];
std::shared_ptr<Route> route = std::dynamic_pointer_cast<Route> (stripable);
bool to_show = std::find (r->begin (), r->end (), route) != r->end ();
stripable->presentation_info ().set_hidden (!to_show);
}
}
View Git Blame Copy Permalink