/*
- 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
#include <cmath>
#include <cassert>
-#include "gtkmm2ext/cell_renderer_pixbuf_toggle.h"
-
#include "ardour/diskstream.h"
+#include "ardour/session.h"
#include "editor.h"
#include "keyboard.h"
#include "ardour/route.h"
+#include "gtkmm2ext/cell_renderer_pixbuf_multi.h"
+#include "gtkmm2ext/cell_renderer_pixbuf_toggle.h"
+
#include "i18n.h"
using namespace std;
_model = ListStore::create (_columns);
_display.set_model (_model);
+ // Record enable toggle
CellRendererPixbufToggle* rec_col_renderer = manage (new CellRendererPixbufToggle());
- 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_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));
- Gtk::TreeViewColumn* rec_state_column = manage (new TreeViewColumn("Rec", *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);
+ // 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));
+
+ TreeViewColumn* mute_state_column = manage (new TreeViewColumn("M", *mute_col_renderer));
+
+ mute_state_column->add_attribute(mute_col_renderer->property_state(), _columns.mute_state);
+
+ // 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));
+
+ TreeViewColumn* solo_state_column = manage (new TreeViewColumn("S", *solo_col_renderer));
+
+ solo_state_column->add_attribute(solo_col_renderer->property_state(), _columns.solo_state);
+
_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 (_("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.set_headers_visible (true);
_display.set_name ("TrackListDisplay");
- _display.get_selection()->set_mode (SELECTION_NONE);
+ _display.get_selection()->set_mode (SELECTION_SINGLE);
_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<CellRendererToggle*>(_display.get_column_cell_renderer (1));
-
+ CellRendererText* name_cell = dynamic_cast<CellRendererText*> (_display.get_column_cell_renderer (4));
+ assert (name_cell);
+
+ TreeViewColumn* name_column = _display.get_column (4);
+ assert (name_column);
+
+ name_column->add_attribute (name_cell->property_editable(), _columns.name_editable);
+ name_cell->property_editable() = true;
+ name_cell->signal_edited().connect (mem_fun (*this, &EditorRoutes::name_edit));
+
+ CellRendererToggle* visible_cell = dynamic_cast<CellRendererToggle*> (_display.get_column_cell_renderer (3));
+
visible_cell->property_activatable() = true;
visible_cell->property_radio() = false;
+ visible_cell->signal_toggled().connect (mem_fun (*this, &EditorRoutes::visible_changed));
_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));
}
-void
+void
+EditorRoutes::connect_to_session (Session* s)
+{
+ EditorComponent::connect_to_session (s);
+
+ initial_display ();
+
+ _session->SoloChanged.connect (mem_fun (*this, &EditorRoutes::solo_changed_so_update_mute));
+}
+
+void
EditorRoutes::on_tv_rec_enable_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));
+ 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->get_diskstream()->set_record_enabled(!atv->get_diskstream()->record_enabled());
+ atv->reversibly_apply_track_boolean ("rec-enable change", &Track::set_record_enable, !atv->track()->record_enabled(), this);
+ }
+}
+
+void
+EditorRoutes::on_tv_mute_enable_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->reversibly_apply_route_boolean ("mute-enable change", &Route::set_mute, !atv->route()->muted(), this);
+ }
+}
+
+void
+EditorRoutes::on_tv_solo_enable_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->reversibly_apply_route_boolean ("solo-enable change", &Route::set_solo, !atv->route()->soloed(), this);
}
}
using namespace Gtk;
_menu = new Menu;
-
+
MenuList& items = _menu->items();
_menu->set_name ("ArdourContextMenu");
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)));
}
void
_menu->popup (1, gtk_get_current_event_time());
}
-const char* _order_key = N_("editor");
-
void
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 (_order_key, n);
+ route->set_order_key (N_ ("editor"), n);
}
bool visible = (*i)[_columns.visible];
tv->set_marked_for_display (false);
tv->hide ();
}
-
+
n++;
}
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));
-
+
_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.
*/
}
if (!_redisplay_does_not_reset_order_keys && !_redisplay_does_not_sync_order_keys) {
- _editor->current_session()->sync_order_keys (_order_key);
+ _session->sync_order_keys (N_ ("editor"));
}
}
void
-EditorRoutes::route_deleted (Gtk::TreeModel::Path const & path)
+EditorRoutes::route_deleted (Gtk::TreeModel::Path const &)
{
/* this could require an order reset & sync */
- _editor->current_session()->set_remote_control_ids();
+ _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 (Glib::ustring const & path)
{
- /* never reset order keys because of a property change */
+ 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;
- _editor->current_session()->set_remote_control_ids();
+ _session->set_remote_control_ids();
redisplay ();
_redisplay_does_not_reset_order_keys = false;
}
row[_columns.is_track] = (boost::dynamic_pointer_cast<Track> ((*x)->route()) != 0);
_ignore_reorder = true;
-
+
/* added a new fresh one at the end */
- if ((*x)->route()->order_key(_order_key) == -1) {
- (*x)->route()->set_order_key (_order_key, _model->children().size()-1);
+ 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<Route> wr ((*x)->route());
boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> ((*x)->route());
t->diskstream()->RecordEnableChanged.connect (mem_fun (*this, &EditorRoutes::update_rec_display));
}
+
+ (*x)->route()->mute_changed.connect (mem_fun (*this, &EditorRoutes::update_mute_display));
+ (*x)->route()->solo_changed.connect (mem_fun (*this, &EditorRoutes::update_solo_display));
}
+ update_rec_display ();
resume_redisplay ();
_redisplay_does_not_sync_order_keys = false;
}
ENSURE_GUI_THREAD (bind (mem_fun(*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 ();
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.
*/
if (!route) {
return;
}
-
+
TreeModel::Children rows = _model->children();
TreeModel::Children::iterator i;
-
+
for (i = rows.begin(); i != rows.end(); ++i) {
boost::shared_ptr<Route> t = (*i)[_columns.route];
if (t == route) {
(*i)[_columns.text] = route->name();
break;
}
- }
+ }
}
void
TreeModel::Children::iterator i;
for (i = rows.begin(); i != rows.end(); ++i) {
- if ((*i)[_columns.tv] == &tv) {
+ if ((*i)[_columns.tv] == &tv) {
(*i)[_columns.visible] = false;
break;
}
{
TreeModel::Children rows = _model->children();
TreeModel::Children::iterator i;
-
+
for (i = rows.begin(); i != rows.end(); ++i) {
- if ((*i)[_columns.tv] == &tv) {
+ if ((*i)[_columns.tv] == &tv) {
(*i)[_columns.visible] = true;
break;
}
}
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
+ * route list so that the visual arrangement of routes matches the order keys from the routes.
+ */
void
-EditorRoutes::sync_order_keys (char const * src)
+EditorRoutes::sync_order_keys (string const & src)
{
vector<int> neworder;
TreeModel::Children rows = _model->children();
TreeModel::Children::iterator ri;
- ARDOUR::Session* s = _editor->current_session ();
-
- if ((strcmp (src, _order_key) == 0) || !s || (s->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;
}
boost::shared_ptr<Route> route = (*ri)[_columns.route];
int old_key = order;
- int new_key = route->order_key (_order_key);
+ int new_key = route->order_key (N_ ("editor"));
neworder[new_key] = old_key;
void
-EditorRoutes::hide_all_tracks (bool with_select)
+EditorRoutes::hide_all_tracks (bool /*with_select*/)
{
TreeModel::Children rows = _model->children();
TreeModel::Children::iterator i;
suspend_redisplay ();
for (i = rows.begin(); i != rows.end(); ++i) {
-
+
TreeModel::Row row = (*i);
TimeAxisView *tv = row[_columns.tv];
if (tv == 0) {
continue;
}
-
+
row[_columns.visible] = false;
}
if (tv == 0) {
continue;
}
-
+
(*i)[_columns.visible] = yn;
}
}
void
-EditorRoutes::set_all_audio_visibility (int tracks, bool yn)
+EditorRoutes::set_all_audio_visibility (int tracks, bool yn)
{
TreeModel::Children rows = _model->children();
TreeModel::Children::iterator i;
(*i)[_columns.visible] = yn;
}
break;
-
+
case 2:
if (!atv->is_audio_track()) {
(*i)[_columns.visible] = yn;
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:
- if ((iter = _model->get_iter (path))) {
- TimeAxisView* tv = (*iter)[_columns.tv];
- if (tv) {
- bool visible = (*iter)[_columns.visible];
- (*iter)[_columns.visible] = !visible;
- }
- }
- return true;
-
- case 2:
- /* allow normal processing to occur */
- return false;
-
- default:
- break;
- }
-
return false;
}
struct EditorOrderRouteSorter {
bool operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b) {
/* use of ">" forces the correct sort order */
- return a->order_key (_order_key) < b->order_key (_order_key);
+ return a->order_key (N_ ("editor")) < b->order_key (N_ ("editor"));
}
};
void
EditorRoutes::initial_display ()
{
- boost::shared_ptr<RouteList> routes = _editor->current_session()->get_routes();
+ boost::shared_ptr<RouteList> routes = _session->get_routes();
RouteList r (*routes);
EditorOrderRouteSorter sorter;
TreeModel::Children rows = _model->children();
TreeModel::Children::iterator i;
-
+
_no_redisplay = true;
-
+
for (i = rows.begin(); i != rows.end(); ++i) {
TimeAxisView *tv = (*i)[_columns.tv];
RouteTimeAxisView *rtv;
-
+
if ((rtv = dynamic_cast<RouteTimeAxisView*>(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;
- _editor->current_session()->set_remote_control_ids();
+ _session->set_remote_control_ids();
redisplay ();
_redisplay_does_not_sync_order_keys = false;
}
-void
+void
EditorRoutes::display_drag_data_received (const RefPtr<Gdk::DragContext>& context,
- int x, int y,
+ int x, int y,
const SelectionData& data,
guint info, guint time)
{
_display.on_drag_data_received (context, x, y, data, info, time);
return;
}
-
+
context->drag_finish (true, false, time);
}
list<ViewRoute>::iterator trailing;
list<ViewRoute>::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));
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.
*/
}
view_routes.erase (leading);
-
+
if (done) {
break;
}
}
for (leading = view_routes.begin(); leading != view_routes.end(); ++leading) {
- neworder.push_back (leading->second->order_key (_order_key));
+ neworder.push_back (leading->second->order_key (N_ ("editor")));
}
_model->reorder (neworder);
- _editor->current_session()->sync_order_keys (_order_key);
+ _session->sync_order_keys (N_ ("editor"));
}
void
{
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];
if (boost::dynamic_pointer_cast<Track>(route)) {
+ (*i)[_columns.rec_enabled] = route->record_enabled ();
+ (*i)[_columns.name_editable] = !route->record_enabled ();
+ }
+ }
+}
- if (route->record_enabled()){
- (*i)[_columns.rec_enabled] = true;
- } else {
- (*i)[_columns.rec_enabled] = false;
- }
- }
+void
+EditorRoutes::update_mute_display (void* /*src*/)
+{
+ 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;
+ }
+}
+
+void
+EditorRoutes::update_solo_display (void* /*src*/)
+{
+ 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_state] = RouteUI::solo_visual_state (route) > 0 ? 1 : 0;
}
}
_model->clear ();
_display.set_model (_model);
}
+
+void
+EditorRoutes::name_edit (Glib::ustring const & path, Glib::ustring const & new_text)
+{
+ TreeIter iter = _model->get_iter (path);
+ if (!iter) {
+ return;
+ }
+
+ boost::shared_ptr<Route> route = (*iter)[_columns.route];
+
+ if (route && route->name() != new_text) {
+ route->set_name (new_text);
+ }
+}
+
+void
+EditorRoutes::solo_changed_so_update_mute ()
+{
+ ENSURE_GUI_THREAD (mem_fun (*this, &EditorRoutes::solo_changed_so_update_mute));
+
+ update_mute_display (this);
+}
+
+void
+EditorRoutes::show_tracks_with_regions_at_playhead ()
+{
+ boost::shared_ptr<RouteList> const r = _session->get_routes_with_regions_at (_session->transport_frame ());
+
+ set<TimeAxisView*> show;
+ for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
+ TimeAxisView* tav = _editor->axis_view_from_route (i->get ());
+ 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 ();
+
+}
projects / ardour.git / blobdiff