ardour/ardour
ardour
/
ardour
13
1
Fork 0
Code Pull Requests Releases Activity

move from PresentationInfo::global_order() to PresentationInfo::order, and fix up part of reordering behaviour 

Dragging tracks/busses in the editor *below* VCAs still does not work
This commit is contained in:
Paul Davis 2016-06-03 15:15:30 -04:00
parent ee0f073e8d
commit 260058a4a9
17 changed files with 233 additions and 179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
gtk2_ardour/ardour_ui.cc
View File

@ -3927,13 +3927,13 @@ ARDOUR_UI::translate_order (AddRouteDialog::InsertAt place)
if (place == AddRouteDialog::AfterSelection) {
RouteTimeAxisView *rtav = dynamic_cast<RouteTimeAxisView*> (editor->get_selection().tracks.back());
if (rtav) {
order_hint = rtav->route()->presentation_info().group_order();
order_hint = rtav->route()->presentation_info().order();
order_hint++;
}
} else if (place == AddRouteDialog::BeforeSelection) {
RouteTimeAxisView *rtav = dynamic_cast<RouteTimeAxisView*> (editor->get_selection().tracks.front());
if (rtav) {
order_hint = rtav->route()->presentation_info().group_order();
order_hint = rtav->route()->presentation_info().order();
}
} else if (place == AddRouteDialog::First) {
order_hint = 0;

6
gtk2_ardour/automation_time_axis.cc
View File

@ -1044,3 +1044,9 @@ AutomationTimeAxisView::presentation_info () const
{
return _route->presentation_info();
}
boost::shared_ptr<Stripable>
AutomationTimeAxisView::stripable () const
{
return _route;
}

1
gtk2_ardour/automation_time_axis.h
View File

@ -73,6 +73,7 @@ class AutomationTimeAxisView : public TimeAxisView {
void set_samples_per_pixel (double);
std::string name() const { return _name; }
boost::shared_ptr<ARDOUR::Stripable> stripable() const;
ARDOUR::PresentationInfo const & presentation_info () const;
void add_automation_event (GdkEvent *, framepos_t, double, bool with_guard_points);

109
gtk2_ardour/editor.cc
View File

@ -72,11 +72,13 @@
#include "ardour/lmath.h"
#include "ardour/location.h"
#include "ardour/profile.h"
#include "ardour/route.h"
#include "ardour/route_group.h"
#include "ardour/session_playlists.h"
#include "ardour/tempo.h"
#include "ardour/utils.h"
#include "ardour/vca_manager.h"
#include "ardour/vca.h"
#include "canvas/debug.h"
#include "canvas/text.h"
@ -1033,7 +1035,7 @@ Editor::control_select (PresentationInfo::global_order_t global_order, Selection
}
PresentationInfo pi (global_order, select_flags);
boost::shared_ptr<Stripable> s = _session->get_remote_nth_stripable (pi.group_order(), pi.flags());
boost::shared_ptr<Stripable> s = _session->get_remote_nth_stripable (pi.order(), pi.flags());
/* selected object may not be a Route */
@ -5194,73 +5196,92 @@ Editor::resume_route_redisplay ()
}
void
Editor::add_vcas (VCAList& vcas)
Editor::add_vcas (VCAList& vlist)
{
VCATimeAxisView* vtv;
list<VCATimeAxisView*> new_views;
StripableList sl;
for (VCAList::iterator v = vcas.begin(); v != vcas.end(); ++v) {
vtv = new VCATimeAxisView (*this, _session, *_track_canvas);
vtv->set_vca (*v);
new_views.push_back (vtv);
for (VCAList::iterator v = vlist.begin(); v != vlist.end(); ++v) {
sl.push_back (boost::dynamic_pointer_cast<Stripable> (*v));
}
if (new_views.size() > 0) {
_routes->vcas_added (new_views);
}
add_stripables (sl);
}
void
Editor::add_routes (RouteList& routes)
Editor::add_routes (RouteList& rlist)
{
ENSURE_GUI_THREAD (*this, &Editor::handle_new_route, routes)
StripableList sl;
RouteTimeAxisView *rtv;
list<RouteTimeAxisView*> new_views;
for (RouteList::iterator r = rlist.begin(); r != rlist.end(); ++r) {
sl.push_back (*r);
}
add_stripables (sl);
}
void
Editor::add_stripables (StripableList& sl)
{
list<TimeAxisView*> new_views;
boost::shared_ptr<VCA> v;
boost::shared_ptr<Route> r;
TrackViewList new_selection;
bool from_scratch = (track_views.size() == 0);
for (RouteList::iterator x = routes.begin(); x != routes.end(); ++x) {
boost::shared_ptr<Route> route = (*x);
for (StripableList::iterator s = sl.begin(); s != sl.end(); ++s) {
if (route->is_auditioner() || route->is_monitor()) {
continue;
if ((v = boost::dynamic_pointer_cast<VCA> (*s)) != 0) {
VCATimeAxisView* vtv = new VCATimeAxisView (*this, _session, *_track_canvas);
vtv->set_vca (v);
new_views.push_back (vtv);
} else if ((r = boost::dynamic_pointer_cast<Route> (*s)) != 0) {
if (r->is_auditioner() || r->is_monitor()) {
continue;
}
RouteTimeAxisView* rtv;
DataType dt = r->input()->default_type();
if (dt == ARDOUR::DataType::AUDIO) {
rtv = new AudioTimeAxisView (*this, _session, *_track_canvas);
rtv->set_route (r);
} else if (dt == ARDOUR::DataType::MIDI) {
rtv = new MidiTimeAxisView (*this, _session, *_track_canvas);
rtv->set_route (r);
} else {
throw unknown_type();
}
new_views.push_back (rtv);
track_views.push_back (rtv);
new_selection.push_back (rtv);
rtv->effective_gain_display ();
rtv->view()->RegionViewAdded.connect (sigc::mem_fun (*this, &Editor::region_view_added));
rtv->view()->RegionViewRemoved.connect (sigc::mem_fun (*this, &Editor::region_view_removed));
}
DataType dt = route->input()->default_type();
if (dt == ARDOUR::DataType::AUDIO) {
rtv = new AudioTimeAxisView (*this, _session, *_track_canvas);
rtv->set_route (route);
} else if (dt == ARDOUR::DataType::MIDI) {
rtv = new MidiTimeAxisView (*this, _session, *_track_canvas);
rtv->set_route (route);
} else {
throw unknown_type();
}
new_views.push_back (rtv);
track_views.push_back (rtv);
new_selection.push_back (rtv);
rtv->effective_gain_display ();
rtv->view()->RegionViewAdded.connect (sigc::mem_fun (*this, &Editor::region_view_added));
rtv->view()->RegionViewRemoved.connect (sigc::mem_fun (*this, &Editor::region_view_removed));
}
if (new_views.size() > 0) {
_routes->routes_added (new_views);
_summary->routes_added (new_views);
_routes->time_axis_views_added (new_views);
//_summary->routes_added (new_selection); /* XXX requires RouteTimeAxisViewList */
}
if (!from_scratch) {
/* note: !new_selection.empty() means that we got some routes rather
* than just VCAs
*/
if (!from_scratch && !new_selection.empty()) {
selection->tracks.clear();
selection->add (new_selection);
begin_selection_op_history();
}
if (show_editor_mixer_when_tracks_arrive) {
if (show_editor_mixer_when_tracks_arrive && !new_selection.empty()) {
show_editor_mixer (true);
}

1
gtk2_ardour/editor.h
View File

@ -772,6 +772,7 @@ class Editor : public PublicEditor, public PBD::ScopedConnectionList, public ARD
void popup_note_context_menu (ArdourCanvas::Item *, GdkEvent *);
Gtk::Menu _note_context_menu;
void add_stripables (ARDOUR::StripableList&);
void add_routes (ARDOUR::RouteList&);
void timeaxisview_deleted (TimeAxisView *);
void add_vcas (ARDOUR::VCAList&);

248
gtk2_ardour/editor_routes.cc
View File

@ -721,126 +721,111 @@ EditorRoutes::active_changed (std::string const & path)
}
void
EditorRoutes::vcas_added (list<VCATimeAxisView*> vcas)
{
PBD::Unwinder<bool> at (_adding_routes, true);
bool from_scratch = (_model->children().size() == 0);
Gtk::TreeModel::Children::iterator insert_iter = _model->children().end();
_display.set_model (Glib::RefPtr<ListStore>());
for (list<VCATimeAxisView*>::iterator x = vcas.begin(); x != vcas.end(); ++x) {
boost::shared_ptr<VCA> vca ((*x)->vca());
TreeModel::Row row = *(_model->insert (insert_iter));
row[_columns.text] = vca->name();
row[_columns.visible] = (*x)->marked_for_display();
row[_columns.active] = true;
row[_columns.tv] = *x;
row[_columns.stripable] = vca;
row[_columns.is_track] = false;
row[_columns.is_input_active] = false;
row[_columns.is_midi] = false;
row[_columns.mute_state] = RouteUI::mute_active_state (_session, vca);
row[_columns.solo_state] = RouteUI::solo_active_state (vca);
row[_columns.solo_visible] = true;
row[_columns.solo_isolate_state] = RouteUI::solo_isolate_active_state (vca);
row[_columns.solo_safe_state] = RouteUI::solo_safe_active_state (vca);
row[_columns.name_editable] = true;
boost::weak_ptr<Stripable> wv (vca);
// vca->gui_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::handle_gui_changes, this, _1, _2), gui_context());
vca->PropertyChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::route_property_changed, this, _1, wv), gui_context());
vca->mute_control()->Changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_mute_display, this), gui_context());
vca->solo_control()->Changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_solo_display, this), gui_context());
}
_display.set_model (_model);
/* now update route order keys from the treeview/track display order */
if (!from_scratch) {
sync_presentation_info_from_treeview ();
}
}
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<Stripable> r = (*it)[_columns.stripable];
if (r->presentation_info().group_order() == (routes.front()->route()->presentation_info().group_order() + routes.size())) {
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<Route> route = (*x)->route ();
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] = route->name();
row[_columns.visible] = (*x)->marked_for_display();
boost::shared_ptr<Stripable> stripable;
boost::shared_ptr<MidiTrack> midi_trk;
row[_columns.active] = route->active ();
row[_columns.tv] = *x;
row[_columns.stripable] = route;
row[_columns.is_track] = (boost::dynamic_pointer_cast<Track> (route) != 0);
if (vtav) {
if (midi_trk) {
row[_columns.is_input_active] = midi_trk->input_active ();
row[_columns.is_midi] = true;
} else {
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] = RouteUI::mute_active_state (_session, route);
row[_columns.solo_state] = RouteUI::solo_active_state (route);
row[_columns.solo_visible] = !(*x)->route()->is_master ();
row[_columns.solo_isolate_state] = RouteUI::solo_isolate_active_state (route);
row[_columns.solo_safe_state] = RouteUI::solo_safe_active_state (route);
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<Stripable> wr (route);
boost::weak_ptr<Stripable> ws (stripable);
route->gui_changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::handle_gui_changes, this, _1, _2), gui_context());
route->PropertyChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::route_property_changed, this, _1, wr), gui_context());
if (rtav) {
rtav->route()->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());
if ((*x)->is_track()) {
boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (route);
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> (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());
}
route->mute_control()->Changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_mute_display, this), gui_context());
route->solo_control()->Changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_solo_display, this), gui_context());
route->solo_isolate_control()->Changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_solo_isolate_display, this), gui_context());
route->solo_safe_control()->Changed.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::update_solo_safe_display, this), gui_context());
boost::shared_ptr<AutomationControl> ac;
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 ();
@ -1014,16 +999,16 @@ EditorRoutes::sync_presentation_info_from_treeview ()
bool change = false;
PresentationInfo::order_t order = 0;
/* hmm, problem ... editor doesn't represent all Stripables... we can't
reset the whole presentation order from here.
*/
for (ri = rows.begin(); ri != rows.end(); ++ri) {
boost::shared_ptr<Stripable> stripable = (*ri)[_columns.stripable];
bool visible = (*ri)[_columns.visible];
if (stripable->presentation_info().special ()) {
/* Monitor and Auditioner do not get their presentation
* info reset here.
*/
if (stripable->is_monitor() || stripable->is_auditioner()) {
continue;
}
@ -1033,7 +1018,9 @@ EditorRoutes::sync_presentation_info_from_treeview ()
stripable->presentation_info().unset_flag (PresentationInfo::Hidden);
}
if (order != stripable->presentation_info().group_order()) {
cerr << "Would change PI go for " << stripable->name() << " to " << order << " currently " << stripable->presentation_info().order() << endl;
if (order != stripable->presentation_info().order()) {
stripable->set_presentation_group_order_explicit (order);
change = true;
}
@ -1060,11 +1047,6 @@ EditorRoutes::sync_treeview_from_presentation_info ()
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;
@ -1078,7 +1060,8 @@ EditorRoutes::sync_treeview_from_presentation_info ()
for (TreeModel::Children::iterator ri = rows.begin(); ri != rows.end(); ++ri, ++old_order) {
boost::shared_ptr<Stripable> stripable = (*ri)[_columns.stripable];
sorted.push_back (OrderKeys (old_order, stripable->presentation_info().group_order()));
/* use global order */
sorted.push_back (OrderKeys (old_order, stripable->presentation_info().order()));
}
SortByNewDisplayOrder cmp;
@ -1459,14 +1442,28 @@ struct PresentationInfoRouteSorter
/* 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 PresentationInfoEditorSorter
{
bool operator() (boost::shared_ptr<Stripable> a, boost::shared_ptr<Stripable> b) {
if (a->is_master()) {
/* master before everything else */
return true;
} else if (b->is_master()) {
/* everything else before master */
return false;
}
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().global_order () < b->presentation_info().global_order ();
return a->presentation_info().order () < b->presentation_info().order ();
}
};
@ -1480,13 +1477,20 @@ EditorRoutes::initial_display ()
return;
}
RouteList r (*_session->get_routes());
StripableList s;
RouteList r (*_session->get_routes());
for (RouteList::iterator ri = r.begin(); ri != r.end(); ++ri) {
s.push_back (*ri);
}
r.sort (PresentationInfoRouteSorter ());
_editor->add_routes (r);
VCAList v (_session->vca_manager().vcas());
v.sort (PresentationInfoVCASorter ());
for (VCAList::iterator vi = v.begin(); vi != v.end(); ++vi) {
s.push_back (*vi);
}
s.sort (PresentationInfoEditorSorter ());
_editor->add_vcas (v);
}
@ -1505,6 +1509,15 @@ EditorRoutes::display_drag_data_received (const RefPtr<Gdk::DragContext>& contex
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)
{
@ -1512,17 +1525,16 @@ EditorRoutes::move_selected_tracks (bool up)
return;
}
typedef std::pair<TimeAxisView*,boost::shared_ptr<Stripable> > ViewStripable;
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<Stripable> stripable = (*ri)[_columns.stripable];
view_stripables.push_back (ViewStripable (tv, stripable));
view_stripables.push_back (ViewStripable (tv, stripable, n));
}
list<ViewStripable>::iterator trailing;
@ -1536,8 +1548,8 @@ EditorRoutes::move_selected_tracks (bool up)
++leading;
while (leading != view_stripables.end()) {
if (_editor->selection->selected (leading->first)) {
view_stripables.insert (trailing, ViewStripable (leading->first, leading->second));
if (_editor->selection->selected (leading->tav)) {
view_stripables.insert (trailing, ViewStripable (*leading));
leading = view_stripables.erase (leading);
} else {
++leading;
@ -1561,7 +1573,7 @@ EditorRoutes::move_selected_tracks (bool up)
while (1) {
if (_editor->selection->selected (leading->first)) {
if (_editor->selection->selected (leading->tav)) {
list<ViewStripable>::iterator tmp;
/* need to insert *after* trailing, not *before* it,
@ -1571,7 +1583,7 @@ EditorRoutes::move_selected_tracks (bool up)
tmp = trailing;
tmp++;
view_stripables.insert (tmp, ViewStripable (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.
@ -1609,25 +1621,23 @@ EditorRoutes::move_selected_tracks (bool up)
}
for (leading = view_stripables.begin(); leading != view_stripables.end(); ++leading) {
uint32_t order = (uint32_t) leading->second->presentation_info().group_order ();
neworder.push_back (order);
}
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);
}

3
gtk2_ardour/editor_routes.h
View File

@ -58,8 +58,7 @@ public:
void redisplay ();
void update_visibility ();
void routes_added (std::list<RouteTimeAxisView*> routes);
void vcas_added (std::list<VCATimeAxisView*> routes);
void time_axis_views_added (std::list<TimeAxisView*>);
void route_removed (TimeAxisView *);
void hide_track_in_display (TimeAxisView &);
std::list<TimeAxisView*> views () const;

8
gtk2_ardour/editor_selection.cc
View File

@ -791,7 +791,7 @@ Editor::set_selected_regionview_from_click (bool press, Selection::Operation op)
RouteTimeAxisView* closest = 0;
int distance = INT_MAX;
int key = rtv->route()->presentation_info().global_order ();
int key = rtv->route()->presentation_info().order ();
for (RegionSelection::iterator x = selection->regions.begin(); x != selection->regions.end(); ++x) {
@ -806,7 +806,7 @@ Editor::set_selected_regionview_from_click (bool press, Selection::Operation op)
if (result.second) {
/* newly added to already_in_selection */
int d = artv->route()->presentation_info().global_order ();
int d = artv->route()->presentation_info().order ();
d -= key;
@ -822,7 +822,7 @@ Editor::set_selected_regionview_from_click (bool press, Selection::Operation op)
/* now add all tracks between that one and this one */
int okey = closest->route()->presentation_info().global_order ();
int okey = closest->route()->presentation_info().order ();
if (okey > key) {
swap (okey, key);
@ -832,7 +832,7 @@ Editor::set_selected_regionview_from_click (bool press, Selection::Operation op)
RouteTimeAxisView* artv = dynamic_cast<RouteTimeAxisView*>(*x);
if (artv && artv != rtv) {
int k = artv->route()->presentation_info().global_order ();
int k = artv->route()->presentation_info().order ();
if (k >= okey && k <= key) {

2
gtk2_ardour/export_channel_selector.cc
View File

@ -695,7 +695,7 @@ TrackExportChannelSelector::add_track (boost::shared_ptr<Route> route)
row[track_cols.selected] = false;
row[track_cols.label] = route->name();
row[track_cols.route] = route;
row[track_cols.order_key] = route->presentation_info().global_order();
row[track_cols.order_key] = route->presentation_info().order();
}
void

2
gtk2_ardour/group_tabs.cc
View File

@ -694,7 +694,7 @@ GroupTabs::collect (RouteGroup* g)
int coll = -1;
while (i != group_routes->end() && j != routes->end()) {
PresentationInfo::order_t const k = (*j)->presentation_info ().group_order();
PresentationInfo::order_t const k = (*j)->presentation_info ().order();
if (*i == *j) {

10
gtk2_ardour/mixer_ui.cc
View File

@ -484,7 +484,7 @@ Mixer_UI::add_strips (RouteList& routes)
nroutes++;
if (r->presentation_info().group_order() == (routes.front()->presentation_info().group_order() + routes.size())) {
if (r->presentation_info().order() == (routes.front()->presentation_info().order() + routes.size())) {
insert_iter = it;
break;
}
@ -670,7 +670,7 @@ Mixer_UI::sync_presentation_info_from_treeview ()
route->presentation_info().unset_flag (PresentationInfo::Hidden);
}
if (order != route->presentation_info().group_order()) {
if (order != route->presentation_info().order()) {
route->set_presentation_group_order_explicit (order);
change = true;
}
@ -719,7 +719,7 @@ Mixer_UI::sync_treeview_from_presentation_info ()
for (TreeModel::Children::iterator ri = rows.begin(); ri != rows.end(); ++ri) {
boost::shared_ptr<Route> route = (*ri)[track_columns.route];
if (route) {
max_route_order_key = max (route->presentation_info().group_order(), max_route_order_key);
max_route_order_key = max (route->presentation_info().order(), max_route_order_key);
}
}
@ -732,7 +732,7 @@ Mixer_UI::sync_treeview_from_presentation_info ()
*/
sorted.push_back (OrderKeys (old_order, max_route_order_key + ++vca_cnt));
} else {
sorted.push_back (OrderKeys (old_order, route->presentation_info().group_order()));
sorted.push_back (OrderKeys (old_order, route->presentation_info().order()));
}
}
@ -1375,7 +1375,7 @@ Mixer_UI::strip_width_changed ()
struct PresentationInfoRouteSorter
{
bool operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b) {
return a->presentation_info().global_order () < b->presentation_info().global_order ();
return a->presentation_info().order () < b->presentation_info().order ();
}
};

2
gtk2_ardour/port_group.cc
View File

@ -316,7 +316,7 @@ struct RouteIOs {
class RouteIOsComparator {
public:
bool operator() (RouteIOs const & a, RouteIOs const & b) {
return a.route->presentation_info ().group_order() < b.route->presentation_info().group_order();
return a.route->presentation_info ().order() < b.route->presentation_info().order();
}
};

6
gtk2_ardour/route_time_axis.cc
View File

@ -2925,3 +2925,9 @@ RouteTimeAxisView::presentation_info () const
{
return _route->presentation_info();
}
boost::shared_ptr<Stripable>
RouteTimeAxisView::stripable () const
{
return _route;
}

1
gtk2_ardour/route_time_axis.h
View File

@ -80,6 +80,7 @@ public:
void set_route (boost::shared_ptr<ARDOUR::Route>);
boost::shared_ptr<ARDOUR::Stripable> stripable() const;
ARDOUR::PresentationInfo const & presentation_info () const;
void show_selection (TimeSelection&);

2
gtk2_ardour/time_axis_view.h
View File

@ -57,6 +57,7 @@ namespace ARDOUR {
class Session;
class RouteGroup;
class Playlist;
class Stripable;
}
namespace Gtk {
@ -104,6 +105,7 @@ class TimeAxisView : public virtual AxisView
static void setup_sizes ();
virtual boost::shared_ptr<ARDOUR::Stripable> stripable() const = 0;
virtual ARDOUR::PresentationInfo const & presentation_info () const = 0;
/** @return index of this TimeAxisView within its parent */

6
gtk2_ardour/vca_time_axis.cc
View File

@ -280,3 +280,9 @@ VCATimeAxisView::presentation_info () const
{
return _vca->presentation_info();
}
boost::shared_ptr<Stripable>
VCATimeAxisView::stripable () const
{
return _vca;
}

1
gtk2_ardour/vca_time_axis.h
View File

@ -39,6 +39,7 @@ class VCATimeAxisView : public TimeAxisView
VCATimeAxisView (PublicEditor&, ARDOUR::Session*, ArdourCanvas::Canvas& canvas);
virtual ~VCATimeAxisView ();
boost::shared_ptr<ARDOUR::Stripable> stripable() const;
ARDOUR::PresentationInfo const & presentation_info () const;
void set_vca (boost::shared_ptr<ARDOUR::VCA>);