#include "ardour/session.h"
#include "ardour/solo_isolate_control.h"
#include "ardour/utils.h"
+#include "ardour/vca.h"
+#include "ardour/vca_manager.h"
#include "gtkmm2ext/cell_renderer_pixbuf_multi.h"
#include "gtkmm2ext/cell_renderer_pixbuf_toggle.h"
#include "plugin_setup_dialog.h"
#include "route_sorter.h"
#include "tooltips.h"
+#include "vca_time_axis.h"
#include "utils.h"
-#include "i18n.h"
+#include "pbd/i18n.h"
using namespace std;
using namespace ARDOUR;
_display.set_name (X_("EditGroupList"));
_display.set_rules_hint (true);
_display.set_size_request (100, -1);
- _display.add_object_drag (_columns.route.index(), "routes");
+ _display.add_object_drag (_columns.stripable.index(), "routes");
CellRendererText* name_cell = dynamic_cast<CellRendererText*> (_display.get_column_cell_renderer (_name_column));
_display.set_enable_search (false);
Route::PluginSetup.connect_same_thread (*this, boost::bind (&EditorRoutes::plugin_setup, this, _1, _2, _3));
- Stripable::PresentationInfoChange.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::sync_treeview_from_presentation_info, this), gui_context());
+ PresentationInfo::Change.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::sync_treeview_from_presentation_info, this), gui_context());
}
bool
TimeAxisView* tv = row[_columns.tv];
RouteTimeAxisView *rtv = dynamic_cast<RouteTimeAxisView*> (tv);
- if (rtv && rtv->track()) {
- // TODO check rec-safe and ...
- _session->set_control (rtv->track()->rec_enable_control(), !rtv->track()->rec_enable_control()->get_value(), Controllable::UseGroup);
+ if (!rtv) {
+ return;
+ }
+
+ boost::shared_ptr<AutomationControl> ac = rtv->route()->rec_enable_control();
+
+ if (ac) {
+ ac->set_value (!ac->get_value(), Controllable::UseGroup);
}
}
TimeAxisView* tv = row[_columns.tv];
RouteTimeAxisView *rtv = dynamic_cast<RouteTimeAxisView*> (tv);
- if (rtv && rtv->track() && !rtv->track()->record_enabled()) {
- DisplaySuspender ds;
- boost::shared_ptr<RouteList> rl (new RouteList);
- rl->push_back (rtv->route());
- _session->set_record_safe (rl, !rtv->track()->record_safe(), Session::rt_cleanup);
+ if (!rtv) {
+ return;
+ }
+
+ boost::shared_ptr<AutomationControl> ac (rtv->route()->rec_safe_control());
+
+ if (ac) {
+ ac->set_value (!ac->get_value(), Controllable::UseGroup);
}
}
TimeAxisView *tv = row[_columns.tv];
RouteTimeAxisView *rtv = dynamic_cast<RouteTimeAxisView*> (tv);
- if (rtv != 0) {
- _session->set_control (rtv->route()->mute_control(), rtv->route()->mute_control()->get_value() ? 0.0 : 1.0, Controllable::UseGroup);
+ if (!rtv) {
+ return;
+ }
+
+ boost::shared_ptr<AutomationControl> ac (rtv->route()->mute_control());
+
+ if (ac) {
+ ac->set_value (!ac->get_value(), Controllable::UseGroup);
}
}
TimeAxisView *tv = row[_columns.tv];
RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tv);
- if (rtv != 0) {
- rtv->route()->solo_control()->set_value (rtv->route()->soloed() ? 0.0 : 1.0, Controllable::UseGroup);
+ if (!rtv) {
+ return;
+ }
+
+ boost::shared_ptr<AutomationControl> ac (rtv->route()->solo_control());
+
+ if (ac) {
+ ac->set_value (!ac->get_value(), Controllable::UseGroup);
}
}
TimeAxisView *tv = row[_columns.tv];
RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tv);
- if (rtv) {
- rtv->route()->solo_isolate_control()->set_value (rtv->route()->solo_isolate_control()->get_value() ? 0.0 : 1.0, Controllable::UseGroup);
+ if (!rtv) {
+ return;
+ }
+
+ boost::shared_ptr<AutomationControl> ac (rtv->route()->solo_isolate_control());
+
+ if (ac) {
+ ac->set_value (!ac->get_value(), Controllable::UseGroup);
}
}
TimeAxisView *tv = row[_columns.tv];
RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tv);
- if (rtv) {
- rtv->route()->solo_safe_control()->set_value (rtv->route()->solo_safe_control()->get_value() ? 0.0 : 1.0, Controllable::UseGroup);
+ if (!rtv) {
+ return;
+ }
+
+ boost::shared_ptr<AutomationControl> ac (rtv->route()->solo_safe_control());
+
+ if (ac) {
+ ac->set_value (!ac->get_value(), Controllable::UseGroup);
}
}
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];
if (tv == 0) {
// just a "title" row
}
Gtk::TreeModel::Row row = *_model->get_iter (path);
- boost::shared_ptr<Route> route = row[_columns.route];
- bool const active = row[_columns.active];
- route->set_active (!active, this);
+ boost::shared_ptr<Stripable> stripable = row[_columns.stripable];
+ boost::shared_ptr<Route> route = boost::dynamic_pointer_cast<Route> (stripable);
+ if (route) {
+ bool const active = row[_columns.active];
+ route->set_active (!active, this);
+ }
}
void
-EditorRoutes::routes_added (list<RouteTimeAxisView*> routes)
+EditorRoutes::time_axis_views_added (list<TimeAxisView*> tavs)
{
PBD::Unwinder<bool> at (_adding_routes, true);
bool from_scratch = (_model->children().size() == 0);
Gtk::TreeModel::Children::iterator insert_iter = _model->children().end();
for (Gtk::TreeModel::Children::iterator it = _model->children().begin(); it != _model->children().end(); ++it) {
- boost::shared_ptr<Route> r = (*it)[_columns.route];
- if (r->presentation_info().group_order() == (routes.front()->route()->presentation_info().group_order() + routes.size())) {
+ boost::shared_ptr<Stripable> r = (*it)[_columns.stripable];
+
+ if (r->presentation_info().order() == (tavs.front()->stripable()->presentation_info().order() + tavs.size())) {
insert_iter = it;
break;
}
}
- DisplaySuspender ds;
-
_display.set_model (Glib::RefPtr<ListStore>());
- for (list<RouteTimeAxisView*>::iterator x = routes.begin(); x != routes.end(); ++x) {
+ for (list<TimeAxisView*>::iterator x = tavs.begin(); x != tavs.end(); ++x) {
- boost::shared_ptr<MidiTrack> midi_trk = boost::dynamic_pointer_cast<MidiTrack> ((*x)->route());
+ VCATimeAxisView* vtav = dynamic_cast<VCATimeAxisView*> (*x);
+ RouteTimeAxisView* rtav = dynamic_cast<RouteTimeAxisView*> (*x);
TreeModel::Row row = *(_model->insert (insert_iter));
- row[_columns.text] = (*x)->route()->name();
- row[_columns.visible] = (*x)->marked_for_display();
- row[_columns.active] = (*x)->route()->active ();
- row[_columns.tv] = *x;
- row[_columns.route] = (*x)->route ();
- row[_columns.is_track] = (boost::dynamic_pointer_cast<Track> ((*x)->route()) != 0);
+ boost::shared_ptr<Stripable> stripable;
+ boost::shared_ptr<MidiTrack> midi_trk;
- if (midi_trk) {
- row[_columns.is_input_active] = midi_trk->input_active ();
- row[_columns.is_midi] = true;
- } else {
+ if (vtav) {
+
+ stripable = vtav->vca();
+
+ row[_columns.is_track] = false;
row[_columns.is_input_active] = false;
row[_columns.is_midi] = false;
+
+ } else if (rtav) {
+
+ stripable = rtav->route ();
+ midi_trk= boost::dynamic_pointer_cast<MidiTrack> (stripable);
+
+ row[_columns.is_track] = (boost::dynamic_pointer_cast<Track> (stripable) != 0);
+
+
+ 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.mute_state] = (*x)->route()->muted() ? Gtkmm2ext::ExplicitActive : Gtkmm2ext::Off;
- row[_columns.solo_state] = RouteUI::solo_active_state ((*x)->route());
- row[_columns.solo_visible] = !(*x)->route()->is_master ();
- row[_columns.solo_isolate_state] = (*x)->route()->solo_isolate_control()->solo_isolated();
- row[_columns.solo_safe_state] = (*x)->route()->solo_safe_control()->solo_safe();
+ if (!stripable) {
+ continue;
+ }
+
+ row[_columns.text] = stripable->name();
+ row[_columns.visible] = (*x)->marked_for_display();
+ row[_columns.active] = true;
+ row[_columns.tv] = *x;
+ row[_columns.stripable] = stripable;
+ row[_columns.mute_state] = RouteUI::mute_active_state (_session, stripable);
+ row[_columns.solo_state] = RouteUI::solo_active_state (stripable);
+ row[_columns.solo_visible] = true;
+ row[_columns.solo_isolate_state] = RouteUI::solo_isolate_active_state (stripable);
+ row[_columns.solo_safe_state] = RouteUI::solo_safe_active_state (stripable);
row[_columns.name_editable] = true;
- boost::weak_ptr<Route> wr ((*x)->route());
+ boost::weak_ptr<Stripable> ws (stripable);
- (*x)->route()->gui_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::handle_gui_changes, this, _1, _2), gui_context());
- (*x)->route()->PropertyChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::route_property_changed, this, _1, wr), gui_context());
+ /* 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)
+ */
- if ((*x)->is_track()) {
- boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> ((*x)->route());
+ stripable->gui_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::handle_gui_changes, this, _1, _2), gui_context());
+ stripable->PropertyChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::route_property_changed, this, _1, ws), gui_context());
+ stripable->presentation_info().PropertyChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::route_property_changed, this, _1, ws), gui_context());
+
+ if (boost::dynamic_pointer_cast<Track> (stripable)) {
+ boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (stripable);
t->rec_enable_control()->Changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_rec_display, this), gui_context());
t->rec_safe_control()->Changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_rec_display, this), gui_context());
}
- if ((*x)->is_midi_track()) {
- boost::shared_ptr<MidiTrack> t = boost::dynamic_pointer_cast<MidiTrack> ((*x)->route());
- t->StepEditStatusChange.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_rec_display, this), gui_context());
- t->InputActiveChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_input_active_display, this), gui_context());
+ if (midi_trk) {
+ midi_trk->StepEditStatusChange.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_rec_display, this), gui_context());
+ midi_trk->InputActiveChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_input_active_display, this), gui_context());
}
- (*x)->route()->mute_control()->Changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_mute_display, this), gui_context());
- (*x)->route()->solo_control()->Changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_solo_display, this), gui_context());
- (*x)->route()->solo_isolate_control()->Changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_solo_isolate_display, this), gui_context());
- (*x)->route()->solo_safe_control()->Changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_solo_safe_display, this), gui_context());
+ boost::shared_ptr<AutomationControl> ac;
- (*x)->route()->active_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_active_display, this), gui_context ());
+ if ((ac = stripable->mute_control()) != 0) {
+ ac->Changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_mute_display, this), gui_context());
+ }
+ if ((ac = stripable->solo_control()) != 0) {
+ ac->Changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_solo_display, this), gui_context());
+ }
+ if ((ac = stripable->solo_isolate_control()) != 0) {
+ ac->Changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_solo_isolate_display, this), gui_context());
+ }
+ if ((ac = stripable->solo_safe_control()) != 0) {
+ ac->Changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_solo_safe_display, this), gui_context());
+ }
+ if (rtav) {
+ rtav->route()->active_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_active_display, this), gui_context ());
+ }
}
update_rec_display ();
_display.set_model (_model);
/* now update route order keys from the treeview/track display order */
+
if (!from_scratch) {
sync_presentation_info_from_treeview ();
}
+
+ redisplay ();
}
void
}
void
-EditorRoutes::route_property_changed (const PropertyChange& what_changed, boost::weak_ptr<Route> r)
+EditorRoutes::route_property_changed (const PropertyChange& what_changed, boost::weak_ptr<Stripable> s)
{
- if (!what_changed.contains (ARDOUR::Properties::name)) {
+ if (!what_changed.contains (ARDOUR::Properties::hidden) && !what_changed.contains (ARDOUR::Properties::name)) {
return;
}
- ENSURE_GUI_THREAD (*this, &EditorRoutes::route_name_changed, r)
+ if (_adding_routes) {
+ return;
+ }
- boost::shared_ptr<Route> route = r.lock ();
+ boost::shared_ptr<Stripable> stripable = s.lock ();
- if (!route) {
+ if (!stripable) {
return;
}
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();
+
+ boost::shared_ptr<Stripable> ss = (*i)[_columns.stripable];
+
+ if (ss == stripable) {
+
+ if (what_changed.contains (ARDOUR::Properties::name)) {
+ (*i)[_columns.text] = stripable->name();
+ break;
+ }
+
+ if (what_changed.contains (ARDOUR::Properties::hidden)) {
+ (*i)[_columns.visible] = !stripable->presentation_info().hidden();
+ cerr << stripable->name() << " visibility changed, redisplay\n";
+ redisplay ();
+
+ }
+
break;
}
}
}
}
-void
-EditorRoutes::reset_remote_control_ids ()
-{
- if (Config->get_remote_model() == UserOrdered || !_session || _session->deletion_in_progress()) {
- return;
- }
-
- sync_presentation_info_from_treeview ();
-}
void
EditorRoutes::sync_presentation_info_from_treeview ()
{
return;
}
- DEBUG_TRACE (DEBUG::OrderKeys, "editor sync order keys from treeview\n");
+ DEBUG_TRACE (DEBUG::OrderKeys, "editor sync presentation info from treeview\n");
TreeModel::Children::iterator ri;
bool change = false;
PresentationInfo::order_t order = 0;
+ bool master_is_first = false;
+ uint32_t count = 0;
- /* hmm, problem ... editor doesn't represent all Stripables... we can't
- reset the whole presentation order from here.
- */
+ // special case master if it's got PI order 0 lets keep it there
+ if (_session->master_out() && (_session->master_out()->presentation_info().order() == 0)) {
+ order++;
+ master_is_first = true;
+ }
for (ri = rows.begin(); ri != rows.end(); ++ri) {
- boost::shared_ptr<Route> route = (*ri)[_columns.route];
+ boost::shared_ptr<Stripable> stripable = (*ri)[_columns.stripable];
bool visible = (*ri)[_columns.visible];
- if (route->presentation_info().special ()) {
+ /* Monitor and Auditioner do not get their presentation
+ * info reset here.
+ */
+
+ if (stripable->is_monitor() || stripable->is_auditioner()) {
continue;
}
- if (!visible) {
- route->presentation_info().set_flag (PresentationInfo::Hidden);
- } else {
- route->presentation_info().unset_flag (PresentationInfo::Hidden);
+ stripable->presentation_info().set_hidden (!visible);
+
+ /* special case master if it's got PI order 0 lets keep it there
+ * but still allow master to move if first non-master route has
+ * presentation order 1
+ */
+ if ((count == 0) && master_is_first && (stripable->presentation_info().order() == 1)) {
+ master_is_first = false; // someone has moved master
+ order = 0;
+ }
+
+ if (stripable->is_master() && master_is_first) {
+ if (count) {
+ continue;
+ } else {
+ count++;
+ continue;
+ }
}
- if (order != route->presentation_info().group_order()) {
- route->set_presentation_group_order_explicit (order);
+ if (order != stripable->presentation_info().order()) {
+ stripable->set_presentation_order (order, false);
change = true;
}
++order;
+ ++count;
}
if (change) {
DEBUG_TRACE (DEBUG::OrderKeys, "... notify PI change from editor GUI\n");
_session->notify_presentation_info_change ();
+ _session->set_dirty();
}
}
DEBUG_TRACE (DEBUG::OrderKeys, "editor sync model from presentation info.\n");
- /* we could get here after either a change in the Mixer or Editor sort
- * order, but either way, the mixer order keys reflect the intended
- * order for the GUI, so reorder the treeview model to match it.
- */
-
vector<int> neworder;
TreeModel::Children rows = _model->children();
uint32_t old_order = 0;
OrderingKeys sorted;
for (TreeModel::Children::iterator ri = rows.begin(); ri != rows.end(); ++ri, ++old_order) {
- boost::shared_ptr<Route> route = (*ri)[_columns.route];
- sorted.push_back (OrderKeys (old_order, route->presentation_info().group_order()));
- DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("build new order: route %3 old = %1 new = %1\n",
- old_order,
- route->presentation_info().group_order(),
- route->name()));
+ boost::shared_ptr<Stripable> stripable = (*ri)[_columns.stripable];
+ /* use global order */
+ sorted.push_back (OrderKeys (old_order, stripable->presentation_info().order()));
}
SortByNewDisplayOrder cmp;
if (sr->old_display_order != n) {
changed = true;
}
-
- DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("EDITOR change order from %1 to %2\n",
- sr->old_display_order, n));
}
if (changed) {
case 'm':
if (get_relevant_routes (rl)) {
- _session->set_controls (route_list_to_control_list (rl, &Route::mute_control), rl->front()->muted() ? 0.0 : 1.0, Controllable::NoGroup);
+ _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, &Route::solo_control), rl->front()->self_soloed() ? 0.0 : 1.0, Controllable::NoGroup);
+ _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;
for (RouteList::const_iterator r = rl->begin(); r != rl->end(); ++r) {
boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*r);
if (t) {
- _session->set_controls (route_list_to_control_list (rl, &Track::rec_enable_control), !t->rec_enable_control()->get_value(), Controllable::NoGroup);
+ _session->set_controls (route_list_to_control_list (rl, &Stripable::rec_enable_control), !t->rec_enable_control()->get_value(), Controllable::NoGroup);
break;
}
}
/* everything else before master */
return false;
}
- return a->presentation_info().global_order () < b->presentation_info().global_order ();
+ return a->presentation_info().order () < b->presentation_info().order ();
+ }
+};
+
+struct PresentationInfoVCASorter
+{
+ bool operator() (boost::shared_ptr<VCA> a, boost::shared_ptr<VCA> b) {
+ return a->presentation_info().order () < b->presentation_info().order ();
}
};
return;
}
+ StripableList s;
+
RouteList r (*_session->get_routes());
+ for (RouteList::iterator ri = r.begin(); ri != r.end(); ++ri) {
+ s.push_back (*ri);
+ }
+
+ VCAList v (_session->vca_manager().vcas());
+ for (VCAList::iterator vi = v.begin(); vi != v.end(); ++vi) {
+ s.push_back (*vi);
+ }
- r.sort (PresentationInfoRouteSorter ());
- _editor->add_routes (r);
+ _editor->add_stripables (s);
}
void
context->drag_finish (true, false, time);
}
+struct ViewStripable {
+ TimeAxisView* tav;
+ boost::shared_ptr<Stripable> stripable;
+ uint32_t old_order;
+
+ ViewStripable (TimeAxisView* t, boost::shared_ptr<Stripable> s, uint32_t n)
+ : tav (t), stripable (s), old_order (n) {}
+};
+
void
EditorRoutes::move_selected_tracks (bool up)
{
return;
}
- typedef std::pair<TimeAxisView*,boost::shared_ptr<Route> > ViewRoute;
- std::list<ViewRoute> view_routes;
+ std::list<ViewStripable> view_stripables;
std::vector<int> neworder;
TreeModel::Children rows = _model->children();
TreeModel::Children::iterator ri;
+ TreeModel::Children::size_type n;
- for (ri = rows.begin(); ri != rows.end(); ++ri) {
+ for (n = 0, ri = rows.begin(); ri != rows.end(); ++ri, ++n) {
TimeAxisView* tv = (*ri)[_columns.tv];
- boost::shared_ptr<Route> route = (*ri)[_columns.route];
-
- view_routes.push_back (ViewRoute (tv, route));
+ boost::shared_ptr<Stripable> stripable = (*ri)[_columns.stripable];
+ view_stripables.push_back (ViewStripable (tv, stripable, n));
}
- list<ViewRoute>::iterator trailing;
- list<ViewRoute>::iterator leading;
+ list<ViewStripable>::iterator trailing;
+ list<ViewStripable>::iterator leading;
if (up) {
- trailing = view_routes.begin();
- leading = view_routes.begin();
+ trailing = view_stripables.begin();
+ leading = view_stripables.begin();
++leading;
- while (leading != view_routes.end()) {
- if (_editor->selection->selected (leading->first)) {
- view_routes.insert (trailing, ViewRoute (leading->first, leading->second));
- leading = view_routes.erase (leading);
+ while (leading != view_stripables.end()) {
+ if (_editor->selection->selected (leading->tav)) {
+ view_stripables.insert (trailing, ViewStripable (*leading));
+ leading = view_stripables.erase (leading);
} else {
++leading;
++trailing;
and so it looks like a bit of a mess.
*/
- trailing = view_routes.end();
- leading = view_routes.end();
+ trailing = view_stripables.end();
+ leading = view_stripables.end();
- --leading; if (leading == view_routes.begin()) { return; }
+ --leading; if (leading == view_stripables.begin()) { return; }
--leading;
--trailing;
while (1) {
- if (_editor->selection->selected (leading->first)) {
- list<ViewRoute>::iterator tmp;
+ if (_editor->selection->selected (leading->tav)) {
+ list<ViewStripable>::iterator tmp;
/* need to insert *after* trailing, not *before* it,
which is what insert (iter, val) normally does.
tmp = trailing;
tmp++;
- view_routes.insert (tmp, ViewRoute (leading->first, leading->second));
+ view_stripables.insert (tmp, ViewStripable (*leading));
/* can't use iter = cont.erase (iter); form here, because
we need iter to move backwards.
bool done = false;
- if (leading == view_routes.begin()) {
+ if (leading == view_stripables.begin()) {
/* the one we've just inserted somewhere else
was the first in the list. erase this copy,
and then break, because we're done.
done = true;
}
- view_routes.erase (leading);
+ view_stripables.erase (leading);
if (done) {
break;
leading = tmp;
} else {
- if (leading == view_routes.begin()) {
+ if (leading == view_stripables.begin()) {
break;
}
--leading;
};
}
- for (leading = view_routes.begin(); leading != view_routes.end(); ++leading) {
- uint32_t order = (uint32_t) leading->second->presentation_info().group_order ();
- neworder.push_back (order);
- }
+ for (leading = view_stripables.begin(); leading != view_stripables.end(); ++leading) {
+ neworder.push_back (leading->old_order);
+#ifndef NDEBUG
+ if (leading->old_order != neworder.size() - 1) {
+ DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("move %1 to %2\n", leading->old_order, neworder.size() - 1));
+ }
+#endif
+ }
#ifndef NDEBUG
DEBUG_TRACE (DEBUG::OrderKeys, "New order after moving tracks:\n");
for (vector<int>::iterator i = neworder.begin(); i != neworder.end(); ++i) {
DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("\t%1\n", *i));
}
DEBUG_TRACE (DEBUG::OrderKeys, "-------\n");
-
- for (vector<int>::iterator i = neworder.begin(); i != neworder.end(); ++i) {
- if (*i >= (int) neworder.size()) {
- cerr << "Trying to move something to " << *i << " of " << neworder.size() << endl;
- }
- assert (*i < (int) neworder.size ());
- }
#endif
+
_model->reorder (neworder);
}
TreeModel::Children::iterator i;
for (i = rows.begin(); i != rows.end(); ++i) {
- boost::shared_ptr<Route> route = (*i)[_columns.route];
+ boost::shared_ptr<Stripable> stripable = (*i)[_columns.stripable];
- if (boost::dynamic_pointer_cast<Track> (route)) {
- boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (route);
+ if (boost::dynamic_pointer_cast<Track> (stripable)) {
+ boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (stripable);
if (mt) {
(*i)[_columns.is_input_active] = mt->input_active();
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_active_state (_session, route);
- (*i)[_columns.solo_state] = RouteUI::solo_active_state (route);
- (*i)[_columns.solo_isolate_state] = RouteUI::solo_isolate_active_state (route) ? 1 : 0;
- (*i)[_columns.solo_safe_state] = RouteUI::solo_safe_active_state (route) ? 1 : 0;
- (*i)[_columns.active] = route->active ();
+ boost::shared_ptr<Stripable> stripable = (*i)[_columns.stripable];
+ boost::shared_ptr<Route> route = boost::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;
+ }
boost::shared_ptr<Track> trk (boost::dynamic_pointer_cast<Track>(route));
(*i)[_columns.rec_state] = 0;
}
- (*i)[_columns.rec_safe] = !trk->rec_safe_control()->get_value();
+ (*i)[_columns.rec_safe] = trk->rec_safe_control()->get_value();
(*i)[_columns.name_editable] = !trk->rec_enable_control()->get_value();
}
}
return;
}
- boost::shared_ptr<Route> route = (*iter)[_columns.route];
+ boost::shared_ptr<Stripable> stripable = (*iter)[_columns.stripable];
- if (route && route->name() != new_text) {
- route->set_name (new_text);
+ if (stripable && stripable->name() != new_text) {
+ stripable->set_name (new_text);
}
}
set<TimeAxisView*> show;
for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
- TimeAxisView* tav = _editor->axis_view_from_route (*i);
+ TimeAxisView* tav = _editor->axis_view_from_stripable (*i);
if (tav) {
show.insert (tav);
}
projects / ardour.git / blobdiff