#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),
rec_col_renderer->set_active_pixbuf (::get_icon("rec-enabled"));
rec_col_renderer->set_inactive_pixbuf (::get_icon("act-disabled"));
- rec_col_renderer->signal_toggled().connect (mem_fun (*this, &EditorRoutes::on_tv_rec_enable_toggled));
+ rec_col_renderer->signal_toggled().connect (sigc::mem_fun (*this, &EditorRoutes::on_tv_rec_enable_toggled));
- Gtk::TreeViewColumn* rec_state_column = manage (new TreeViewColumn("R", *rec_col_renderer));
+ TreeViewColumn* rec_state_column = manage (new TreeViewColumn("R", *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_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("mute-enabled"));
- mute_col_renderer->signal_changed().connect (mem_fun (*this, &EditorRoutes::on_tv_mute_enable_toggled));
+ mute_col_renderer->signal_changed().connect (sigc::mem_fun (*this, &EditorRoutes::on_tv_mute_enable_toggled));
- Gtk::TreeViewColumn* mute_state_column = manage (new TreeViewColumn("M", *mute_col_renderer));
+ 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->signal_changed().connect (mem_fun (*this, &EditorRoutes::on_tv_solo_enable_toggled));
+ solo_col_renderer->signal_changed().connect (sigc::mem_fun (*this, &EditorRoutes::on_tv_solo_enable_toggled));
- Gtk::TreeViewColumn* solo_state_column = manage (new TreeViewColumn("S", *solo_col_renderer));
+ 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("I", *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(15);
+
_display.append_column (*rec_state_column);
_display.append_column (*mute_state_column);
_display.append_column (*solo_state_column);
- _display.append_column (_("Show"), _columns.visible);
+ _display.append_column (*solo_isolate_state_column);
+
_display.append_column (_("Name"), _columns.text);
-
- _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));
- _display.get_column (3)->set_data (X_("colnum"), GUINT_TO_POINTER(3));
- _display.get_column (4)->set_data (X_("colnum"), GUINT_TO_POINTER(4));
-
+ _display.append_column (_("V"), _columns.visible);
+
_display.set_headers_visible (true);
_display.set_name ("TrackListDisplay");
_display.get_selection()->set_mode (SELECTION_SINGLE);
_display.add_object_drag (_columns.route.index(), "routes");
CellRendererText* name_cell = dynamic_cast<CellRendererText*> (_display.get_column_cell_renderer (4));
+
assert (name_cell);
- Gtk::TreeViewColumn* name_column = _display.get_column (4);
+ TreeViewColumn* name_column = _display.get_column (4);
+
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 (mem_fun (*this, &EditorRoutes::name_edit));
+ name_cell->signal_edited().connect (sigc::mem_fun (*this, &EditorRoutes::name_edit));
- CellRendererToggle* visible_cell = dynamic_cast<CellRendererToggle*>(_display.get_column_cell_renderer (3));
+ // Set the visible column cell renderer to radio toggle
+ CellRendererToggle* visible_cell = dynamic_cast<CellRendererToggle*> (_display.get_column_cell_renderer (5));
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<TreeViewColumn*> (_display.get_column (5));
+ 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);
- _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);
-
- Route::SyncOrderKeys.connect (mem_fun (*this, &EditorRoutes::sync_order_keys));
+ Route::SyncOrderKeys.connect (*this, ui_bind (&EditorRoutes::sync_order_keys, this, _1), gui_context());
}
void
-EditorRoutes::connect_to_session (Session* s)
+EditorRoutes::set_session (Session* s)
{
- EditorComponent::connect_to_session (s);
+ EditorComponent::set_session (s);
initial_display ();
- _session->SoloChanged.connect (mem_fun (*this, &EditorRoutes::solo_changed_so_update_mute));
+ if (_session) {
+ _session->SoloChanged.connect (*this, boost::bind (&EditorRoutes::solo_changed_so_update_mute, this), gui_context());
+ }
}
void
// Get the model row that has been toggled.
Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string));
- row[_columns.name_editable] = !row[_columns.rec_enabled];
-
TimeAxisView *tv = row[_columns.tv];
AudioTimeAxisView *atv = dynamic_cast<AudioTimeAxisView*> (tv);
if (atv != 0 && atv->is_audio_track()){
- atv->reversibly_apply_track_boolean ("rec-enable change", &Track::set_record_enable, !atv->track()->record_enabled(), this);
+ boost::shared_ptr<RouteList> rl (new RouteList);
+ rl->push_back (atv->route());
+ _session->set_record_enable (rl, !atv->track()->record_enabled(), Session::rt_cleanup);
}
}
AudioTimeAxisView *atv = dynamic_cast<AudioTimeAxisView*> (tv);
if (atv != 0) {
- atv->reversibly_apply_route_boolean ("mute-enable change", &Route::set_mute, !atv->route()->muted(), this);
+ boost::shared_ptr<RouteList> rl (new RouteList);
+ rl->push_back (atv->route());
+ _session->set_mute (rl, !atv->route()->muted(), Session::rt_cleanup);
}
}
AudioTimeAxisView *atv = dynamic_cast<AudioTimeAxisView*> (tv);
if (atv != 0) {
- atv->reversibly_apply_route_boolean ("solo-enable change", &Route::set_solo, !atv->route()->soloed(), this);
+ boost::shared_ptr<RouteList> rl (new RouteList);
+ rl->push_back (atv->route());
+ _session->set_solo (rl, !atv->route()->soloed(), Session::rt_cleanup);
+ }
+}
+
+void
+EditorRoutes::on_tv_solo_isolate_toggled (Glib::ustring 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];
+ AudioTimeAxisView *atv = dynamic_cast<AudioTimeAxisView*> (tv);
+
+ if (atv != 0) {
+ atv->route()->set_solo_isolated (!atv->route()->solo_isolated(), this);
}
}
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 Tracks With Regions Under Playhead"), mem_fun (*this, &EditorRoutes::show_tracks_with_regions_at_playhead)));
+ 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 Tracks With Regions Under Playhead"), sigc::mem_fun (*this, &EditorRoutes::show_tracks_with_regions_at_playhead)));
}
void
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) {
TimeAxisView *tv = (*i)[_columns.tv];
boost::shared_ptr<Route> route = (*i)[_columns.route];
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 (mem_fun (*_editor, &Editor::sync_track_view_list_and_routes));
+ Glib::signal_idle().connect (sigc::mem_fun (*_editor, &Editor::sync_track_view_list_and_routes));
_editor->full_canvas_height = position + _editor->canvas_timebars_vsize;
_editor->vertical_adjustment.set_upper (_editor->full_canvas_height);
void
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 &, Gtk::TreeModel::iterator const &)
+EditorRoutes::visible_changed (Glib::ustring 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 ();
row[_columns.tv] = *x;
row[_columns.route] = (*x)->route ();
row[_columns.is_track] = (boost::dynamic_pointer_cast<Track> ((*x)->route()) != 0);
+ row[_columns.mute_state] = (*x)->route()->muted();
+ row[_columns.solo_state] = (*x)->route()->soloed();
+ row[_columns.solo_isolate_state] = (*x)->route()->solo_isolated();
+ row[_columns.name_editable] = true;
_ignore_reorder = true;
_ignore_reorder = false;
boost::weak_ptr<Route> 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, ui_bind (&EditorRoutes::handle_gui_changes, this, _1, _2), gui_context());
+ (*x)->route()->PropertyChanged.connect (*this, ui_bind (&EditorRoutes::route_property_changed, this, _1, wr), gui_context());
if ((*x)->is_track()) {
boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> ((*x)->route());
- t->diskstream()->RecordEnableChanged.connect (mem_fun (*this, &EditorRoutes::update_rec_display));
+ t->diskstream()->RecordEnableChanged.connect (*this, boost::bind (&EditorRoutes::update_rec_display, this), gui_context());
}
- (*x)->route()->mute_changed.connect (mem_fun (*this, &EditorRoutes::update_mute_display));
- (*x)->route()->solo_changed.connect (mem_fun (*this, &EditorRoutes::update_solo_display));
+ (*x)->route()->mute_changed.connect (*this, boost::bind (&EditorRoutes::update_mute_display, this), gui_context());
+ (*x)->route()->solo_changed.connect (*this, boost::bind (&EditorRoutes::update_solo_display, this), gui_context());
+ (*x)->route()->solo_isolated_changed.connect (*this, boost::bind (&EditorRoutes::update_solo_isolate_display, this), gui_context());
}
update_rec_display ();
+ update_mute_display ();
+ update_solo_display ();
+ update_solo_isolate_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
void
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;
}
void
-EditorRoutes::route_name_changed (boost::weak_ptr<Route> r)
+EditorRoutes::route_property_changed (const PropertyChange& what_changed, boost::weak_ptr<Route> 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> route = r.lock ();
+
if (!route) {
return;
}
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")))) {
-
- case 0:
- /* allow normal processing to occur */
- return false;
- case 1:
- /* allow normal processing to occur */
- return false;
- case 2:
- /* allow normal processing to occur */
- return false;
- case 3:
- if ((iter = _model->get_iter (path))) {
- TimeAxisView* tv = (*iter)[_columns.tv];
- if (tv) {
- bool visible = (*iter)[_columns.visible];
- (*iter)[_columns.visible] = !visible;
- }
+
+ //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);
+
+ // 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 4:
- /* allow normal processing to occur */
- return false;
-
- default:
- break;
}
-
+
return false;
}
void
EditorRoutes::initial_display ()
{
+ suspend_redisplay ();
+ _model->clear ();
+
+ if (!_session) {
+ resume_redisplay ();
+ return;
+ }
+
boost::shared_ptr<RouteList> 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 */
_no_redisplay = true;
for (i = rows.begin(); i != rows.end(); ++i) {
+
TimeAxisView *tv = (*i)[_columns.tv];
RouteTimeAxisView *rtv;
_model->reorder (neworder);
- _session->sync_order_keys (N_ ("editor"));
+ _session->sync_order_keys (N_ ("editor"));
}
void
}
void
-EditorRoutes::update_mute_display (void* /*src*/)
+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> route = (*i)[_columns.route];
- (*i)[_columns.mute_state] = RouteUI::mute_visual_state (*_session, route) > 0 ? 1 : 0;
+ (*i)[_columns.mute_state] = RouteUI::mute_visual_state (_session, route) > 0 ? 1 : 0;
}
}
void
-EditorRoutes::update_solo_display (void* /*src*/)
+EditorRoutes::update_solo_display ()
{
TreeModel::Children rows = _model->children();
TreeModel::Children::iterator i;
}
}
+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> route = (*i)[_columns.route];
+ (*i)[_columns.solo_isolate_state] = RouteUI::solo_isolate_visual_state (route) > 0 ? 1 : 0;
+ }
+}
+
list<TimeAxisView*>
EditorRoutes::views () const
{
void
EditorRoutes::solo_changed_so_update_mute ()
{
- ENSURE_GUI_THREAD (mem_fun (*this, &EditorRoutes::solo_changed_so_update_mute));
-
- update_mute_display (this);
+ ENSURE_GUI_THREAD (*this, &EditorRoutes::solo_changed_so_update_mute)
+ update_mute_display ();
}
void
set<TimeAxisView*> show;
for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
- cout << "show " << (*i)->name() << "\n";
- TimeAxisView* tav = _editor->axis_view_from_route (i->get ());
+ TimeAxisView* tav = _editor->axis_view_from_route (*i);
if (tav) {
show.insert (tav);
}
}
resume_redisplay ();
-
}
projects / ardour.git / blobdiff