output_chan = input_chan;
}
- cerr << "ARD said " << input_chan << " and " << output_chan << endl;
-
/* XXX do something with name template */
switch (add_route_dialog->type_wanted()) {
int packing_extra = 6; // this is the total vertical packing in our top level window
- MoveWindow (carbon_window, x, y + titlebar_height + top_box.get_height() + packing_extra, false);
- ShowWindow (carbon_window);
-
// create the cocoa window for the carbon one and make it visible
cocoa_parent = [[NSWindow alloc] initWithWindowRef: carbon_window];
+ PositionWindow (carbon_window, [cocoa_parent windowRef], kWindowCascadeStartAtParentWindowScreen);
+ MoveWindow (carbon_window, x, y + titlebar_height + top_box.get_height() + packing_extra, false);
+ ShowWindow (carbon_window);
+
SetWindowActivationScope (carbon_window, kWindowActivationScopeNone);
_notify = [ [NotificationObject alloc] initWithPluginUI:this andCocoaParent:cocoa_parent andTopLevelParent:win ];
_session->StepEditStatusChange.connect (_session_connections, invalidator (*this), boost::bind (&Editor::step_edit_status_change, this, _1), gui_context());
_session->TransportStateChange.connect (_session_connections, invalidator (*this), boost::bind (&Editor::map_transport_state, this), gui_context());
_session->PositionChanged.connect (_session_connections, invalidator (*this), boost::bind (&Editor::map_position_change, this, _1), gui_context());
- _session->RouteAdded.connect (_session_connections, invalidator (*this), boost::bind (&Editor::handle_new_route, this, _1), gui_context());
+ _session->RouteAdded.connect (_session_connections, invalidator (*this), boost::bind (&Editor::add_routes, this, _1), gui_context());
_session->DirtyChanged.connect (_session_connections, invalidator (*this), boost::bind (&Editor::update_title, this), gui_context());
_session->tempo_map().PropertyChanged.connect (_session_connections, invalidator (*this), boost::bind (&Editor::tempo_map_changed, this, _1), gui_context());
_session->Located.connect (_session_connections, invalidator (*this), boost::bind (&Editor::located, this), gui_context());
return t;
}
-
void
-Editor::handle_new_route (RouteList& routes)
+Editor::add_routes (RouteList& routes)
{
ENSURE_GUI_THREAD (*this, &Editor::handle_new_route, routes)
for (RouteList::iterator x = routes.begin(); x != routes.end(); ++x) {
boost::shared_ptr<Route> route = (*x);
- if (route->is_hidden() || route->is_monitor()) {
+ if (route->is_hidden()) {
continue;
}
void popup_control_point_context_menu (ArdourCanvas::Item *, GdkEvent *);
Gtk::Menu _control_point_context_menu;
- void handle_new_route (ARDOUR::RouteList&);
+ void add_routes (ARDOUR::RouteList&);
void timeaxisview_deleted (TimeAxisView *);
Gtk::HBox global_hpacker;
void
EditorGroupTabs::sync_order_keys ()
{
- _editor->_routes->sync_order_keys (UndefinedSort);
+ _editor->_routes->sync_order_keys_from_model ();
}
#include <cmath>
#include <cassert>
+#include "pbd/unknown_type.h"
+#include "pbd/unwind.h"
+
+#include "gtkmm2ext/cell_renderer_pixbuf_multi.h"
+#include "gtkmm2ext/cell_renderer_pixbuf_toggle.h"
+#include "gtkmm2ext/treeutils.h"
+
+#include "ardour/debug.h"
+#include "ardour/route.h"
+#include "ardour/midi_track.h"
#include "ardour/session.h"
#include "editor.h"
#include "editor_group_tabs.h"
#include "editor_routes.h"
-#include "pbd/unknown_type.h"
-
-#include "ardour/route.h"
-#include "ardour/midi_track.h"
-
-#include "gtkmm2ext/cell_renderer_pixbuf_multi.h"
-#include "gtkmm2ext/cell_renderer_pixbuf_toggle.h"
-#include "gtkmm2ext/treeutils.h"
-
#include "i18n.h"
using namespace std;
: EditorComponent (e)
, _ignore_reorder (false)
, _no_redisplay (false)
- , _redisplay_does_not_sync_order_keys (false)
- , _redisplay_does_not_reset_order_keys (false)
- ,_menu (0)
+ , _menu (0)
, old_focus (0)
, selection_countdown (0)
, name_editable (0)
_display.set_enable_search (false);
- Route::SyncOrderKeys.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::sync_order_keys, this, _1), gui_context());
+ Route::SyncOrderKeys.connect (*this, MISSING_INVALIDATOR, boost::bind (&EditorRoutes::sync_model_from_order_keys, this, _1), gui_context());
}
bool
*/
int n;
- /* Order keys must not take children into account, so use a separate counter
- for that.
- */
- int order_key;
-
- for (n = 0, order_key = 0, position = 0, i = rows.begin(); i != rows.end(); ++i) {
+ 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];
continue;
}
- if (!_redisplay_does_not_reset_order_keys) {
- /* this reorder is caused by user action, so reassign sort order keys
- to tracks.
- */
-
- if (route->is_master()) {
- route->set_order_key (EditorSort, Route::MasterBusRemoteControlID);
- } else if (route->is_monitor()) {
- route->set_order_key (EditorSort, Route::MonitorBusRemoteControlID);
- } else {
- route->set_order_key (EditorSort, order_key++);
- }
- }
-
bool visible = tv->marked_for_display ();
/* show or hide the TimeAxisView */
*/
_editor->vertical_adjustment.set_value (_editor->full_canvas_height - _editor->_canvas_height);
}
-
- if (!_redisplay_does_not_reset_order_keys && !_redisplay_does_not_sync_order_keys) {
- _session->sync_order_keys (EditorSort);
- }
}
void
EditorRoutes::route_deleted (Gtk::TreeModel::Path const &)
{
- if (!_session || _session->deletion_in_progress()) {
- return;
- }
+ /* this happens as the second step of a DnD within the treeview as well
+ as when a row/route is actually deleted.
+ */
+ DEBUG_TRACE (DEBUG::OrderKeys, "editor routes treeview row deleted\n");
+ sync_order_keys_from_model ();
+}
- /* this could require an order reset & sync */
- _ignore_reorder = true;
- redisplay ();
- _ignore_reorder = false;
+void
+EditorRoutes::reordered (TreeModel::Path const &, TreeModel::iterator const &, int* /*what*/)
+{
+ DEBUG_TRACE (DEBUG::OrderKeys, "editor routes treeview reordered\n");
+ sync_order_keys_from_model ();
}
void
bool visible = (*iter)[_columns.visible];
if (tv->set_marked_for_display (!visible)) {
- _redisplay_does_not_reset_order_keys = true;
update_visibility ();
- redisplay ();
- _redisplay_does_not_reset_order_keys = false;
}
}
}
{
TreeModel::Row row;
- _redisplay_does_not_sync_order_keys = true;
suspend_redisplay ();
for (list<RouteTimeAxisView*>::iterator x = routes.begin(); x != routes.end(); ++x) {
update_input_active_display ();
update_active_display ();
resume_redisplay ();
- _redisplay_does_not_sync_order_keys = false;
+
+ /* now update route order keys from the treeview/track display order */
+
+ sync_order_keys_from_model ();
}
void
TreeModel::Children rows = _model->children();
TreeModel::Children::iterator ri;
- /* the core model has changed, there is no need to sync
- view orders.
- */
-
- _redisplay_does_not_sync_order_keys = true;
-
for (ri = rows.begin(); ri != rows.end(); ++ri) {
if ((*ri)[_columns.tv] == tv) {
_model->erase (ri);
}
}
- _redisplay_does_not_sync_order_keys = false;
+ /* the deleted signal for the treeview/model will take
+ care of any updates.
+ */
}
void
(*i)[_columns.visible] = tv->marked_for_display ();
}
+ /* force route order keys catch up with visibility changes
+ */
+
+ sync_order_keys_from_model ();
+
resume_redisplay ();
}
}
void
-EditorRoutes::reordered (TreeModel::Path const &, TreeModel::iterator const &, int* /*what*/)
+EditorRoutes::sync_order_keys_from_model ()
{
- redisplay ();
-}
+ if (_ignore_reorder || !_session || _session->deletion_in_progress()) {
+ return;
+ }
-/** 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 (RouteSortOrderKey src)
-{
- map<int, int> new_order;
TreeModel::Children rows = _model->children();
- TreeModel::Children::iterator ri;
-
- if (src == EditorSort || !_session || (_session->state_of_the_state() & (Session::Loading|Session::Deletion)) || rows.empty()) {
+
+ if (rows.empty()) {
return;
}
+ DEBUG_TRACE (DEBUG::OrderKeys, "editor sync order keys from model\n");
+
+ TreeModel::Children::iterator ri;
bool changed = false;
- int order;
+ uint32_t order = 0;
- for (order = 0, ri = rows.begin(); ri != rows.end(); ++ri, ++order) {
+ for (ri = rows.begin(); ri != rows.end(); ++ri) {
boost::shared_ptr<Route> route = (*ri)[_columns.route];
+ bool visible = (*ri)[_columns.visible];
- int const old_key = order;
- int const new_key = route->order_key (EditorSort);
+ uint32_t old_key = route->order_key (EditorSort);
+ uint32_t new_key;
- new_order[new_key] = old_key;
+ if (!visible) {
+ new_key = UINT_MAX;
+ } else {
+ new_key = order;
+ }
- if (new_key != old_key) {
+ if (old_key != new_key) {
+ route->set_order_key (EditorSort, new_key);
changed = true;
}
- }
+ order++;
+ }
+
if (changed) {
- _redisplay_does_not_reset_order_keys = true;
+ /* tell the world that we changed the editor sort keys */
+ _session->sync_order_keys (EditorSort);
+ }
+}
+
+void
+EditorRoutes::sync_model_from_order_keys (RouteSortOrderKey src)
+{
+ if (!_session || _session->deletion_in_progress()) {
+ return;
+ }
- /* `compact' new_order into a vector */
- vector<int> co;
- for (map<int, int>::const_iterator i = new_order.begin(); i != new_order.end(); ++i) {
- co.push_back (i->second);
+ DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("editor sync model from order keys, src = %1\n", enum_2_string (src)));
+
+ if (src == MixerSort) {
+
+ if (!Config->get_sync_all_route_ordering()) {
+ /* mixer sort keys changed - we don't care */
+ return;
}
- assert (co.size() == _model->children().size ());
+ DEBUG_TRACE (DEBUG::OrderKeys, "reset editor order key to match mixer\n");
- _model->reorder (co);
- _redisplay_does_not_reset_order_keys = false;
+ /* mixer sort keys were changed, update the editor sort
+ * keys since "sync mixer+editor order" is enabled.
+ */
+
+ boost::shared_ptr<RouteList> r = _session->get_routes ();
+
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ (*i)->sync_order_keys (src);
+ }
}
-}
+ /* 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 n = 0;
+
+ if (rows.empty()) {
+ return;
+ }
+
+ neworder.assign (rows.size(), 0);
+
+ for (TreeModel::Children::iterator ri = rows.begin(); ri != rows.end(); ++ri, ++n) {
+ boost::shared_ptr<Route> route = (*ri)[_columns.route];
+ neworder[route->order_key (EditorSort)] = n;
+ DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("editor change order for %1 to %2\n",
+ route->name(), route->order_key (MixerSort)));
+ }
+
+ {
+ Unwinder<bool> uw (_ignore_reorder, true);
+ _model->reorder (neworder);
+ }
+
+ redisplay ();
+}
void
EditorRoutes::hide_all_tracks (bool /*with_select*/)
(*i)[_columns.visible] = yn;
}
+ /* force route order keys catch up with visibility changes
+ */
+
+ sync_order_keys_from_model ();
+
resume_redisplay ();
}
}
}
+ /* force route order keys catch up with visibility changes
+ */
+
+ sync_order_keys_from_model ();
+
resume_redisplay ();
}
struct EditorOrderRouteSorter {
bool operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b) {
- /* use of ">" forces the correct sort order */
+ if (a->is_master()) {
+ /* master before everything else */
+ return true;
+ } else if (b->is_master()) {
+ /* everything else before master */
+ return false;
+ }
return a->order_key (EditorSort) < b->order_key (EditorSort);
}
};
}
boost::shared_ptr<RouteList> routes = _session->get_routes();
- RouteList r (*routes);
- EditorOrderRouteSorter sorter;
-
- r.sort (sorter);
- _editor->handle_new_route (r);
-
- /* don't show master bus in a new session */
if (ARDOUR_UI::instance()->session_is_new ()) {
- TreeModel::Children rows = _model->children();
- TreeModel::Children::iterator i;
-
- _no_redisplay = true;
-
- for (i = rows.begin(); i != rows.end(); ++i) {
+ /* new session: stamp all routes with the right editor order
+ * key
+ */
- TimeAxisView *tv = (*i)[_columns.tv];
- RouteTimeAxisView *rtv;
+ _editor->add_routes (*(routes.get()));
+
+ } else {
- if ((rtv = dynamic_cast<RouteTimeAxisView*>(tv)) != 0) {
- if (rtv->route()->is_master()) {
- _display.get_selection()->unselect (i);
- }
- }
- }
+ /* existing session: sort a copy of the route list by
+ * editor-order and add its contents to the display.
+ */
- _no_redisplay = false;
- redisplay ();
+ RouteList r (*routes);
+ EditorOrderRouteSorter sorter;
+
+ r.sort (sorter);
+ _editor->add_routes (r);
+
}
resume_redisplay ();
}
-void
-EditorRoutes::track_list_reorder (Gtk::TreeModel::Path const &, Gtk::TreeModel::iterator const &, int* /*new_order*/)
-{
- _redisplay_does_not_sync_order_keys = true;
- redisplay ();
- _redisplay_does_not_sync_order_keys = false;
-}
-
void
EditorRoutes::display_drag_data_received (const RefPtr<Gdk::DragContext>& context,
int x, int y,
}
for (leading = view_routes.begin(); leading != view_routes.end(); ++leading) {
- neworder.push_back (leading->second->order_key (EditorSort));
+ uint32_t order = leading->second->order_key (EditorSort);
+ neworder.push_back (order);
}
#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);
-
- _session->sync_order_keys (EditorSort);
}
void
resume_redisplay ();
}
+
+uint32_t
+EditorRoutes::count_displayed_non_special_routes () const
+{
+ if (!_model) {
+ return 0;
+ }
+ uint32_t cnt = 0;
+ TreeModel::Children rows = _model->children ();
+ for (TreeModel::Children::iterator i = rows.begin(); i != rows.end(); ++i) {
+ bool visible = (*i)[_columns.visible];
+ if (visible) {
+ boost::shared_ptr<Route> route = (*i)[_columns.route];
+ if (route) {
+ if (route->is_master() || route->is_monitor()) {
+ continue;
+ }
+ cnt++;
+ }
+ }
+ }
+
+ return cnt;
+}
_no_redisplay = true;
}
+ void allow_redisplay () {
+ _no_redisplay = false;
+ }
+
void resume_redisplay () {
_no_redisplay = false;
redisplay ();
std::list<TimeAxisView*> views () const;
void hide_all_tracks (bool);
void clear ();
- void sync_order_keys (ARDOUR::RouteSortOrderKey);
-
+ uint32_t count_displayed_non_special_routes () const;
+ void sync_order_keys_from_model ();
private:
void initial_display ();
void on_tv_solo_safe_toggled (std::string const &);
void build_menu ();
void show_menu ();
+ void sync_model_from_order_keys (ARDOUR::RouteSortOrderKey);
void route_deleted (Gtk::TreeModel::Path const &);
void visible_changed (std::string const &);
void active_changed (std::string const &);
Glib::RefPtr<Gdk::DragContext> const &, gint, gint, Gtk::SelectionData const &, guint, guint
);
- void track_list_reorder (Gtk::TreeModel::Path const &, Gtk::TreeModel::iterator const & iter, int* new_order);
bool selection_filter (Glib::RefPtr<Gtk::TreeModel> const &, Gtk::TreeModel::Path const &, bool);
void name_edit (std::string const &, std::string const &);
void solo_changed_so_update_mute ();
bool _ignore_reorder;
bool _no_redisplay;
- bool _redisplay_does_not_sync_order_keys;
- bool _redisplay_does_not_reset_order_keys;
Gtk::Menu* _menu;
Gtk::Widget* old_focus;
void
MixerGroupTabs::sync_order_keys ()
{
- _mixer->sync_order_keys (UndefinedSort);
+ _mixer->sync_order_keys_from_model ();
}
#include "pbd/convert.h"
#include "pbd/stacktrace.h"
+#include "pbd/unwind.h"
+
#include <glibmm/thread.h>
#include <gtkmm2ext/gtk_ui.h>
#include <gtkmm2ext/tearoff.h>
#include <gtkmm2ext/window_title.h>
+#include "ardour/debug.h"
#include "ardour/plugin_manager.h"
#include "ardour/route_group.h"
#include "ardour/session.h"
using namespace std;
using PBD::atoi;
+using PBD::Unwinder;
Mixer_UI* Mixer_UI::_instance = 0;
Mixer_UI::Mixer_UI ()
: Window (Gtk::WINDOW_TOPLEVEL)
+ , _visible (false)
+ , no_track_list_redisplay (false)
+ , in_group_row_change (false)
+ , track_menu (0)
+ , _monitor_section (0)
+ , _strip_width (Config->get_default_narrow_ms() ? Narrow : Wide)
+ , ignore_reorder (false)
, _following_editor_selection (false)
{
/* allow this window to become the key focus window */
set_flags (CAN_FOCUS);
- _strip_width = Config->get_default_narrow_ms() ? Narrow : Wide;
- track_menu = 0;
- _monitor_section = 0;
- no_track_list_redisplay = false;
- in_group_row_change = false;
- _visible = false;
- strip_redisplay_does_not_reset_order_keys = false;
- strip_redisplay_does_not_sync_order_keys = false;
- ignore_sync = false;
-
- Route::SyncOrderKeys.connect (*this, invalidator (*this), boost::bind (&Mixer_UI::sync_order_keys, this, _1), gui_context());
+ Route::SyncOrderKeys.connect (*this, invalidator (*this), boost::bind (&Mixer_UI::sync_model_from_order_keys, this, _1), gui_context());
scroller_base.set_flags (Gtk::CAN_FOCUS);
scroller_base.add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
void
-Mixer_UI::add_strip (RouteList& routes)
+Mixer_UI::add_strips (RouteList& routes)
{
MixerStrip* strip;
- no_track_list_redisplay = true;
- strip_redisplay_does_not_sync_order_keys = true;
-
- for (RouteList::iterator x = routes.begin(); x != routes.end(); ++x) {
- boost::shared_ptr<Route> route = (*x);
-
- if (route->is_hidden()) {
- continue;
- }
-
- if (route->is_monitor()) {
-
- if (!_monitor_section) {
- _monitor_section = new MonitorSection (_session);
+ {
+ Unwinder<bool> uw (no_track_list_redisplay, true);
+
+ for (RouteList::iterator x = routes.begin(); x != routes.end(); ++x) {
+ boost::shared_ptr<Route> route = (*x);
+
+ if (route->is_hidden()) {
+ continue;
+ }
+
+ if (route->is_monitor()) {
- XMLNode* mnode = ARDOUR_UI::instance()->tearoff_settings (X_("monitor-section"));
- if (mnode) {
- _monitor_section->tearoff().set_state (*mnode);
- }
- }
-
- out_packer.pack_end (_monitor_section->tearoff(), false, false);
- _monitor_section->set_session (_session);
- _monitor_section->tearoff().show_all ();
-
- route->DropReferences.connect (*this, invalidator(*this), boost::bind (&Mixer_UI::monitor_section_going_away, this), gui_context());
-
- /* no regular strip shown for control out */
-
- continue;
- }
-
- strip = new MixerStrip (*this, _session, route);
- strips.push_back (strip);
-
- Config->get_default_narrow_ms() ? _strip_width = Narrow : _strip_width = Wide;
-
- if (strip->width_owner() != strip) {
- strip->set_width_enum (_strip_width, this);
+ if (!_monitor_section) {
+ _monitor_section = new MonitorSection (_session);
+
+ XMLNode* mnode = ARDOUR_UI::instance()->tearoff_settings (X_("monitor-section"));
+ if (mnode) {
+ _monitor_section->tearoff().set_state (*mnode);
+ }
+ }
+
+ out_packer.pack_end (_monitor_section->tearoff(), false, false);
+ _monitor_section->set_session (_session);
+ _monitor_section->tearoff().show_all ();
+
+ route->DropReferences.connect (*this, invalidator(*this), boost::bind (&Mixer_UI::monitor_section_going_away, this), gui_context());
+
+ /* no regular strip shown for control out */
+
+ continue;
+ }
+
+ strip = new MixerStrip (*this, _session, route);
+ strips.push_back (strip);
+
+ Config->get_default_narrow_ms() ? _strip_width = Narrow : _strip_width = Wide;
+
+ if (strip->width_owner() != strip) {
+ strip->set_width_enum (_strip_width, this);
+ }
+
+ show_strip (strip);
+
+ TreeModel::Row row = *(track_model->append());
+ row[track_columns.text] = route->name();
+ row[track_columns.visible] = strip->route()->is_master() ? true : strip->marked_for_display();
+ row[track_columns.route] = route;
+ row[track_columns.strip] = strip;
+
+ route->PropertyChanged.connect (*this, invalidator (*this), boost::bind (&Mixer_UI::strip_property_changed, this, _1, strip), gui_context());
+
+ strip->WidthChanged.connect (sigc::mem_fun(*this, &Mixer_UI::strip_width_changed));
+ strip->signal_button_release_event().connect (sigc::bind (sigc::mem_fun(*this, &Mixer_UI::strip_button_release_event), strip));
}
-
- show_strip (strip);
-
- TreeModel::Row row = *(track_model->append());
- row[track_columns.text] = route->name();
- row[track_columns.visible] = strip->route()->is_master() ? true : strip->marked_for_display();
- row[track_columns.route] = route;
- row[track_columns.strip] = strip;
-
- route->PropertyChanged.connect (*this, invalidator (*this), boost::bind (&Mixer_UI::strip_property_changed, this, _1, strip), gui_context());
-
- strip->WidthChanged.connect (sigc::mem_fun(*this, &Mixer_UI::strip_width_changed));
- strip->signal_button_release_event().connect (sigc::bind (sigc::mem_fun(*this, &Mixer_UI::strip_button_release_event), strip));
}
- no_track_list_redisplay = false;
-
+ sync_order_keys_from_model ();
redisplay_track_list ();
-
- strip_redisplay_does_not_sync_order_keys = false;
}
void
strips.erase (i);
}
- strip_redisplay_does_not_sync_order_keys = true;
-
for (ri = rows.begin(); ri != rows.end(); ++ri) {
if ((*ri)[track_columns.strip] == strip) {
track_model->erase (ri);
break;
}
}
-
- strip_redisplay_does_not_sync_order_keys = false;
}
void
-Mixer_UI::sync_order_keys (RouteSortOrderKey src)
+Mixer_UI::sync_order_keys_from_model ()
{
- TreeModel::Children rows = track_model->children();
- TreeModel::Children::iterator ri;
+ if (ignore_reorder || !_session || _session->deletion_in_progress()) {
+ return;
+ }
- if (src == MixerSort || !_session || (_session->state_of_the_state() & (Session::Loading|Session::Deletion)) || rows.empty()) {
+ TreeModel::Children rows = track_model->children();
+
+ if (rows.empty()) {
return;
}
- std::map<int,int> keys;
+ DEBUG_TRACE (DEBUG::OrderKeys, "mixer sync order keys from model\n");
+ TreeModel::Children::iterator ri;
bool changed = false;
+ uint32_t order = 0;
- unsigned order = 0;
- for (ri = rows.begin(); ri != rows.end(); ++ri, ++order) {
+ for (ri = rows.begin(); ri != rows.end(); ++ri) {
boost::shared_ptr<Route> route = (*ri)[track_columns.route];
- unsigned int old_key = order;
- unsigned int new_key = route->order_key (MixerSort);
+ bool visible = (*ri)[track_columns.visible];
+
+ uint32_t old_key = route->order_key (MixerSort);
+ uint32_t new_key;
- keys[new_key] = old_key;
+ if (!visible) {
+ new_key = UINT_MAX;
+ } else {
+ new_key = order;
+ }
- if (new_key != old_key) {
+ if (old_key != new_key) {
+ route->set_order_key (MixerSort, new_key);
changed = true;
}
+
+ order++;
+ }
+
+ if (changed) {
+ /* tell everyone that we changed the mixer sort keys */
+ _session->sync_order_keys (MixerSort);
}
+}
- if (keys.size() != rows.size()) {
- PBD::stacktrace (cerr, 20);
+void
+Mixer_UI::sync_model_from_order_keys (RouteSortOrderKey src)
+{
+ if (!_session || _session->deletion_in_progress()) {
+ return;
}
- assert(keys.size() == rows.size());
- // Remove any gaps in keys caused by automation children tracks
+ DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("mixer sync model from order keys, src = %1\n", enum_2_string (src)));
+
+ if (src == EditorSort) {
+
+ if (!Config->get_sync_all_route_ordering()) {
+ /* editor sort keys changed - we don't care */
+ return;
+ }
+
+ DEBUG_TRACE (DEBUG::OrderKeys, "reset mixer order key to match editor\n");
+
+ /* editor sort keys were changed, update the mixer sort
+ * keys since "sync mixer+editor order" is enabled.
+ */
+
+ boost::shared_ptr<RouteList> r = _session->get_routes ();
+
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ (*i)->sync_order_keys (src);
+ }
+ }
+
+ /* 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;
- for (std::map<int,int>::const_iterator i = keys.begin(); i != keys.end(); ++i) {
- neworder.push_back(i->second);
+ TreeModel::Children rows = track_model->children();
+ uint32_t n = 0;
+
+ if (rows.empty()) {
+ return;
}
- assert(neworder.size() == rows.size());
- if (changed) {
- strip_redisplay_does_not_reset_order_keys = true;
+ neworder.assign (rows.size(), 0);
+
+ for (TreeModel::Children::iterator ri = rows.begin(); ri != rows.end(); ++ri, ++n) {
+ boost::shared_ptr<Route> route = (*ri)[track_columns.route];
+ neworder[route->order_key (MixerSort)] = n;
+ DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("mixer change order for %1 to %2\n",
+ route->name(), route->order_key (MixerSort)));
+ }
+
+ {
+ Unwinder<bool> uw (ignore_reorder, true);
track_model->reorder (neworder);
- strip_redisplay_does_not_reset_order_keys = false;
}
+
+ redisplay_track_list ();
}
void
initial_track_display ();
- _session->RouteAdded.connect (_session_connections, invalidator (*this), boost::bind (&Mixer_UI::add_strip, this, _1), gui_context());
+ _session->RouteAdded.connect (_session_connections, invalidator (*this), boost::bind (&Mixer_UI::add_strips, this, _1), gui_context());
_session->route_group_added.connect (_session_connections, invalidator (*this), boost::bind (&Mixer_UI::add_route_group, this, _1), gui_context());
_session->route_group_removed.connect (_session_connections, invalidator (*this), boost::bind (&Mixer_UI::route_groups_changed, this), gui_context());
_session->route_groups_reordered.connect (_session_connections, invalidator (*this), boost::bind (&Mixer_UI::route_groups_changed, this), gui_context());
TreeModel::Children rows = track_model->children();
TreeModel::Children::iterator i;
- no_track_list_redisplay = true;
-
- for (i = rows.begin(); i != rows.end(); ++i) {
-
- TreeModel::Row row = (*i);
- MixerStrip* strip = row[track_columns.strip];
-
- if (strip == 0) {
- continue;
- }
-
- if (strip->route()->is_master() || strip->route()->is_monitor()) {
- continue;
+ {
+ Unwinder<bool> uw (no_track_list_redisplay, true);
+
+ for (i = rows.begin(); i != rows.end(); ++i) {
+
+ TreeModel::Row row = (*i);
+ MixerStrip* strip = row[track_columns.strip];
+
+ if (strip == 0) {
+ continue;
+ }
+
+ if (strip->route()->is_master() || strip->route()->is_monitor()) {
+ continue;
+ }
+
+ (*i)[track_columns.visible] = yn;
}
-
- (*i)[track_columns.visible] = yn;
}
- no_track_list_redisplay = false;
redisplay_track_list ();
}
TreeModel::Children rows = track_model->children();
TreeModel::Children::iterator i;
- no_track_list_redisplay = true;
-
- for (i = rows.begin(); i != rows.end(); ++i) {
- TreeModel::Row row = (*i);
- MixerStrip* strip = row[track_columns.strip];
-
- if (strip == 0) {
- continue;
- }
-
- if (strip->route()->is_master() || strip->route()->is_monitor()) {
- continue;
- }
-
- boost::shared_ptr<AudioTrack> at = strip->audio_track();
-
- switch (tracks) {
- case 0:
- (*i)[track_columns.visible] = yn;
- break;
-
- case 1:
- if (at) { /* track */
- (*i)[track_columns.visible] = yn;
+ {
+ Unwinder<bool> uw (no_track_list_redisplay, true);
+
+ for (i = rows.begin(); i != rows.end(); ++i) {
+ TreeModel::Row row = (*i);
+ MixerStrip* strip = row[track_columns.strip];
+
+ if (strip == 0) {
+ continue;
}
- break;
-
- case 2:
- if (!at) { /* bus */
+
+ if (strip->route()->is_master() || strip->route()->is_monitor()) {
+ continue;
+ }
+
+ boost::shared_ptr<AudioTrack> at = strip->audio_track();
+
+ switch (tracks) {
+ case 0:
(*i)[track_columns.visible] = yn;
+ break;
+
+ case 1:
+ if (at) { /* track */
+ (*i)[track_columns.visible] = yn;
+ }
+ break;
+
+ case 2:
+ if (!at) { /* bus */
+ (*i)[track_columns.visible] = yn;
+ }
+ break;
}
- break;
}
}
- no_track_list_redisplay = false;
redisplay_track_list ();
}
void
Mixer_UI::track_list_reorder (const TreeModel::Path&, const TreeModel::iterator&, int* /*new_order*/)
{
- strip_redisplay_does_not_sync_order_keys = true;
- redisplay_track_list ();
- strip_redisplay_does_not_sync_order_keys = false;
-}
-
-void
-Mixer_UI::track_list_change (const Gtk::TreeModel::Path&, const Gtk::TreeModel::iterator&)
-{
- // never reset order keys because of a property change
- strip_redisplay_does_not_reset_order_keys = true;
- redisplay_track_list ();
- strip_redisplay_does_not_reset_order_keys = false;
+ DEBUG_TRACE (DEBUG::OrderKeys, "mixer UI treeview reordered\n");
+ sync_order_keys_from_model ();
}
void
Mixer_UI::track_list_delete (const Gtk::TreeModel::Path&)
{
- /* this could require an order sync */
- if (_session && !_session->deletion_in_progress()) {
- redisplay_track_list ();
- }
+ /* this happens as the second step of a DnD within the treeview as well
+ as when a row/route is actually deleted.
+ */
+ DEBUG_TRACE (DEBUG::OrderKeys, "mixer UI treeview row deleted\n");
+ sync_order_keys_from_model ();
}
void
{
TreeModel::Children rows = track_model->children();
TreeModel::Children::iterator i;
- long regular_order = 0;
- long hidden_order = 999999; // arbitary high number
if (no_track_list_redisplay) {
return;
if (strip->route()->is_master() || strip->route()->is_monitor()) {
out_packer.reorder_child (*strip, -1);
-
- if (!strip_redisplay_does_not_reset_order_keys) {
- if (strip->route()->is_master()) {
- strip->route()->set_order_key (MixerSort, Route::MasterBusRemoteControlID);
- } else {
- strip->route()->set_order_key (MixerSort, Route::MonitorBusRemoteControlID);
- }
- }
} else {
strip_packer.reorder_child (*strip, -1); /* put at end */
-
- if (!strip_redisplay_does_not_reset_order_keys) {
- strip->route()->set_order_key (MixerSort, regular_order++);
- }
-
}
} else {
if (strip->route()->is_master() || strip->route()->is_monitor()) {
out_packer.pack_start (*strip, false, false);
- if (!strip_redisplay_does_not_reset_order_keys) {
- if (strip->route()->is_master()) {
- strip->route()->set_order_key (MixerSort, Route::MasterBusRemoteControlID);
- } else {
- strip->route()->set_order_key (MixerSort, Route::MonitorBusRemoteControlID);
- }
- }
} else {
strip_packer.pack_start (*strip, false, false);
-
- if (!strip_redisplay_does_not_reset_order_keys) {
- strip->route()->set_order_key (MixerSort, regular_order++);
- }
}
strip->set_packed (true);
}
strip_packer.remove (*strip);
strip->set_packed (false);
}
-
- if (!strip_redisplay_does_not_reset_order_keys) {
- strip->route()->set_order_key (MixerSort, hidden_order++);
- }
}
}
}
- if (!strip_redisplay_does_not_reset_order_keys && !strip_redisplay_does_not_sync_order_keys) {
- _session->sync_order_keys (MixerSort);
- }
-
_group_tabs->set_dirty ();
}
struct SignalOrderRouteSorter {
bool operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b) {
+ if (a->is_master() || a->is_monitor()) {
+ /* "a" is a special route (master, monitor, etc), and comes
+ * last in the mixer ordering
+ */
+ return false;
+ } else if (b->is_master() || b->is_monitor()) {
+ /* everything comes before b */
+ return true;
+ }
return a->order_key (MixerSort) < b->order_key (MixerSort);
+
}
};
copy.sort (sorter);
- no_track_list_redisplay = true;
-
- track_model->clear ();
-
- add_strip (copy);
+ {
+ Unwinder<bool> uw1 (no_track_list_redisplay, true);
+ Unwinder<bool> uw2 (ignore_reorder, true);
- no_track_list_redisplay = false;
+ track_model->clear ();
+ add_strips (copy);
+ }
redisplay_track_list ();
}
track_display.set_headers_visible (true);
track_model->signal_row_deleted().connect (sigc::mem_fun (*this, &Mixer_UI::track_list_delete));
- track_model->signal_row_changed().connect (sigc::mem_fun (*this, &Mixer_UI::track_list_change));
track_model->signal_rows_reordered().connect (sigc::mem_fun (*this, &Mixer_UI::track_list_reorder));
CellRendererToggle* track_list_visible_cell = dynamic_cast<CellRendererToggle*>(track_display.get_column_cell_renderer (1));
void scroll_left ();
void scroll_right ();
- void add_strip (ARDOUR::RouteList&);
+ void add_strips (ARDOUR::RouteList&);
void remove_strip (MixerStrip *);
MixerStrip* strip_by_route (boost::shared_ptr<ARDOUR::Route>);
bool track_display_button_press (GdkEventButton*);
void strip_width_changed ();
- void track_list_change (const Gtk::TreeModel::Path&,const Gtk::TreeModel::iterator&);
void track_list_delete (const Gtk::TreeModel::Path&);
void track_list_reorder (const Gtk::TreeModel::Path& path, const Gtk::TreeModel::iterator& iter, int* new_order);
Width _strip_width;
- void sync_order_keys (ARDOUR::RouteSortOrderKey);
- bool strip_redisplay_does_not_reset_order_keys;
- bool strip_redisplay_does_not_sync_order_keys;
- bool ignore_sync;
+ void sync_order_keys_from_model ();
+ void sync_model_from_order_keys (ARDOUR::RouteSortOrderKey);
+ bool ignore_reorder;
void parameter_changed (std::string const &);
void set_route_group_activation (ARDOUR::RouteGroup *, bool);
_session->engine().PortRegisteredOrUnregistered.connect (_session_connections, invalidator (*this), boost::bind (&PortMatrix::setup_global_ports, this), gui_context());
/* watch for route order keys changing, which changes the order of things in our global ports list(s) */
- _session->RouteOrderKeyChanged.connect (_session_connections, invalidator (*this), boost::bind (&PortMatrix::setup_global_ports_proxy, this), gui_context());
+ Route::SyncOrderKeys.connect (_session_connections, invalidator (*this), boost::bind (&PortMatrix::setup_global_ports_proxy, this, _1), gui_context());
/* Part 3: other stuff */
}
void
-PortMatrix::setup_global_ports_proxy ()
+PortMatrix::setup_global_ports_proxy (RouteSortOrderKey sk)
{
- /* Avoid a deadlock by calling this in an idle handler: see IOSelector::io_changed_proxy
- for a discussion.
- */
-
- Glib::signal_idle().connect_once (sigc::mem_fun (*this, &PortMatrix::setup_global_ports));
+ if (sk == EditorSort) {
+ /* Avoid a deadlock by calling this in an idle handler: see IOSelector::io_changed_proxy
+ for a discussion.
+ */
+
+ Glib::signal_idle().connect_once (sigc::mem_fun (*this, &PortMatrix::setup_global_ports));
+ }
}
void
void disassociate_all_on_channel (boost::weak_ptr<ARDOUR::Bundle>, uint32_t, int);
void disassociate_all_on_bundle (boost::weak_ptr<ARDOUR::Bundle>, int);
void setup_global_ports ();
- void setup_global_ports_proxy ();
+ void setup_global_ports_proxy (ARDOUR::RouteSortOrderKey);
void toggle_show_only_bundles ();
bool on_scroll_event (GdkEventScroll *);
boost::shared_ptr<ARDOUR::IO> io_from_bundle (boost::shared_ptr<ARDOUR::Bundle>) const;
dialog.add_button (Stock::APPLY, RESPONSE_ACCEPT);
} else {
Label* l = manage (new Label());
- l->set_markup (string_compose (_("Remote Control IDs are currently determined by track/bus ordering in %1\n\n\n"
+ l->set_markup (string_compose (_("Remote Control IDs are currently determined by track/bus ordering in %1\n\n"
+ "This %2 has remote control ID %3\n\n\n"
"<span size=\"small\" style=\"italic\">Use the User Interaction tab of the Preferences window if you want to change this</span>"),
- (Config->get_remote_model() == MixerOrdered ? _("the mixer") : ("the editor"))));
+ (Config->get_remote_model() == MixerOrdered ? _("the mixer") : ("the editor")),
+ (is_track() ? _("track") : _("bus")),
+ _route->remote_control_id()));
dialog.get_vbox()->pack_start (*l);
dialog.add_button (Stock::OK, RESPONSE_CANCEL);
}
extern uint64_t Layering;
extern uint64_t TempoMath;
extern uint64_t TempoMap;
+ extern uint64_t OrderKeys;
}
}
bool set_name (const std::string& str);
static void set_name_in_state (XMLNode &, const std::string &);
- int32_t order_key (RouteSortOrderKey) const;
- void set_order_key (RouteSortOrderKey, int32_t);
+ uint32_t order_key (RouteSortOrderKey) const;
+ bool has_order_key (RouteSortOrderKey) const;
+ void set_order_key (RouteSortOrderKey, uint32_t);
+ void sync_order_keys (RouteSortOrderKey);
bool is_hidden() const { return _flags & Hidden; }
bool is_master() const { return _flags & MasterOut; }
PBD::Signal0<void> meter_change;
PBD::Signal0<void> signal_latency_changed;
PBD::Signal0<void> initial_delay_changed;
- PBD::Signal0<void> order_key_changed;
/** Emitted with the process lock held */
PBD::Signal0<void> io_changed;
/* for things concerned about *any* route's RID changes */
static PBD::Signal0<void> RemoteControlIDChange;
-
- void sync_order_keys (RouteSortOrderKey);
static PBD::Signal1<void,RouteSortOrderKey> SyncOrderKeys;
bool has_external_redirects() const;
static uint32_t order_key_cnt;
- typedef std::map<RouteSortOrderKey,int32_t> OrderKeys;
+ typedef std::map<RouteSortOrderKey,uint32_t> OrderKeys;
OrderKeys order_keys;
uint32_t* _remote_control_id;
void send_mmc_locate (framepos_t);
int send_full_time_code (framepos_t);
- PBD::Signal0<void> RouteOrderKeyChanged;
-
bool step_editing() const { return (_step_editors > 0); }
void request_suspend_timecode_transmission ();
void setup_midi_machine_control ();
- void route_order_key_changed ();
-
void step_edit_status_change (bool);
uint32_t _step_editors;
};
enum RouteSortOrderKey {
- UndefinedSort,
EditorSort,
MixerSort
};
uint64_t PBD::DEBUG::Layering = PBD::new_debug_bit ("layering");
uint64_t PBD::DEBUG::TempoMath = PBD::new_debug_bit ("tempomath");
uint64_t PBD::DEBUG::TempoMap = PBD::new_debug_bit ("tempomap");
+uint64_t PBD::DEBUG::OrderKeys = PBD::new_debug_bit ("orderkeys");
REGISTER_ENUM (MixerSort);
REGISTER_ENUM (EditorSort);
- REGISTER_BITS (_RouteSortOrderKey);
+ REGISTER (_RouteSortOrderKey);
REGISTER_CLASS_ENUM (Source, Writable);
REGISTER_CLASS_ENUM (Source, CanRename);
Route::remote_control_id() const
{
switch (Config->get_remote_model()) {
- case MixerOrdered:
- return order_key (MixerSort) + 1;
- case EditorOrdered:
- return order_key (EditorSort) + 1;
case UserOrdered:
if (_remote_control_id) {
return *_remote_control_id;
}
+ break;
+ default:
+ break;
+ }
+
+ if (is_master()) {
+ return MasterBusRemoteControlID;
+ }
+
+ if (is_monitor()) {
+ return MonitorBusRemoteControlID;
}
- /* fall back to MixerSort as the default */
+ /* order keys are zero-based, remote control ID's are one-based
+ */
+
+ switch (Config->get_remote_model()) {
+ case EditorOrdered:
+ return order_key (EditorSort) + 1;
+ case MixerOrdered:
+ default:
+ return order_key (MixerSort) + 1;
+ }
+}
- return order_key (MixerSort) + 1;
+bool
+Route::has_order_key (RouteSortOrderKey key) const
+{
+ return (order_keys.find (key) != order_keys.end());
}
-int32_t
+uint32_t
Route::order_key (RouteSortOrderKey key) const
{
OrderKeys::const_iterator i = order_keys.find (key);
if (i == order_keys.end()) {
- return -1;
+ return 0;
}
return i->second;
}
void
-Route::set_order_key (RouteSortOrderKey key, int32_t n)
+Route::sync_order_keys (RouteSortOrderKey base)
{
- bool changed = false;
+ OrderKeys::iterator i = order_keys.find (base);
- /* This method looks more complicated than it should, but
- it's important that we don't emit order_key_changed unless
- it actually has, as expensive things happen on receipt of that
- signal.
- */
-
- if (order_keys.find (key) == order_keys.end() || order_keys[key] != n) {
- order_keys[key] = n;
- changed = true;
+ if (i == order_keys.end()) {
+ return;
}
- if (Config->get_sync_all_route_ordering()) {
- for (OrderKeys::iterator x = order_keys.begin(); x != order_keys.end(); ++x) {
+ for (OrderKeys::iterator k = order_keys.begin(); k != order_keys.end(); ++k) {
- /* we do not sync the signal order keys for mixer +
- * monitor because they are considered "external" to
- * the ordering of other routes.
+ if (k->first == MixerSort && (is_master() || is_monitor())) {
+ /* don't sync the mixer sort keys for master/monitor,
+ * since they are not part of the normal ordering.
*/
-
- if ((!is_master() && !is_monitor()) || x->first != MixerSort) {
- if (x->second != n) {
- x->second = n;
- changed = true;
- }
- }
+
+ continue;
+ }
+
+ if (k->first != base) {
+ k->second = i->second;
}
- }
-
- if (changed) {
- order_key_changed (); /* EMIT SIGNAL */
- _session.set_dirty ();
}
}
-/** Set all order keys to be the same as that for `base', if such a key
- * exists in this route.
- * @param base Base key.
- */
void
-Route::sync_order_keys (RouteSortOrderKey base)
+Route::set_order_key (RouteSortOrderKey key, uint32_t n)
{
- if (order_keys.empty()) {
- return;
- }
-
- OrderKeys::iterator i;
- int32_t key;
-
- if ((i = order_keys.find (base)) == order_keys.end()) {
- /* key doesn't exist, use the first existing key (during session initialization) */
- i = order_keys.begin();
- key = i->second;
- ++i;
- } else {
- /* key exists - use it and reset all others (actually, itself included) */
- key = i->second;
- i = order_keys.begin();
- }
-
- bool changed = false;
-
- for (; i != order_keys.end(); ++i) {
-
- /* we do not sync the signal order keys for mixer +
- * monitor because they are considered "external" to
- * the ordering of other routes.
- */
-
- if ((!is_master() && !is_monitor()) || i->first != MixerSort) {
- if (i->second != key) {
- i->second = key;
- changed = true;
- }
- }
- }
-
- if (changed) {
- order_key_changed (); /* EMIT SIGNAL */
+ if (order_keys.find (key) == order_keys.end() || order_keys[key] != n) {
+ order_keys[key] = n;
+ _session.set_dirty ();
}
}
{
ChanCount existing_inputs;
ChanCount existing_outputs;
+ uint32_t order = next_control_id();
count_existing_track_channels (existing_inputs, existing_outputs);
r->mute_changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this, _1));
r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
- r->order_key_changed.connect_same_thread (*this, boost::bind (&Session::route_order_key_changed, this));
if (r->is_master()) {
_master_out = r;
if (input_auto_connect || output_auto_connect) {
auto_connect_route (r, existing_inputs, existing_outputs, true, input_auto_connect);
}
+
+ /* order keys are a GUI responsibility but we need to set up
+ reasonable defaults because they also affect the remote control
+ ID in most situations.
+ */
+
+ if (!r->has_order_key (EditorSort)) {
+ if (r->is_hidden()) {
+ /* use an arbitrarily high value */
+ r->set_order_key (EditorSort, UINT_MAX);
+ r->set_order_key (MixerSort, UINT_MAX);
+ } else {
+ DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("while adding, set %1 to order key %2\n", r->name(), order));
+ r->set_order_key (EditorSort, order);
+ r->set_order_key (MixerSort, order);
+ order++;
+ }
+ }
}
if (_monitor_out && IO::connecting_legal) {
route->drop_references ();
- sync_order_keys (UndefinedSort);
-
Route::RemoteControlIDChange(); /* EMIT SIGNAL */
/* save the new state of the world */
automation_lists[al->id()] = al;
}
-void
-Session::sync_order_keys (RouteSortOrderKey base)
-{
- if (deletion_in_progress()) {
- return;
- }
-
- if (!Config->get_sync_all_route_ordering()) {
- /* leave order keys as they are */
- return;
- }
-
- boost::shared_ptr<RouteList> r = routes.reader ();
-
- for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- (*i)->sync_order_keys (base);
- }
-
- Route::SyncOrderKeys (base); // EMIT SIGNAL
-}
-
/** @return true if there is at least one record-enabled track, otherwise false */
bool
Session::have_rec_enabled_track () const
_locations->add (_session_range_location);
}
-/** Called when one of our routes' order keys has changed */
-void
-Session::route_order_key_changed ()
-{
- RouteOrderKeyChanged (); /* EMIT SIGNAL */
-}
-
void
Session::step_edit_status_change (bool yn)
{
{
int subtract = 0;
- /* the master and monitor bus remote ID's occupy a different
- * "namespace" than regular routes. their existence doesn't
+ /* the monitor bus remote ID is in a different
+ * "namespace" than regular routes. its existence doesn't
* affect normal (low) numbered routes.
*/
- if (_master_out) {
+ if (_monitor_out) {
subtract++;
}
- if (_monitor_out) {
- subtract++;
+ return nroutes() - subtract;
+}
+
+void
+Session::sync_order_keys (RouteSortOrderKey sort_key_changed)
+{
+ if (deletion_in_progress()) {
+ return;
}
- /* remote control IDs are based either on this
- value, or signal order, which is zero-based. so we have
- to ensure consistency of zero-based-ness for both
- sources of the number.
-
- we actually add 1 to the value to form an actual
- remote control ID, which is 1-based.
+ switch (Config->get_remote_model()) {
+ case MixerSort:
+ case EditorSort:
+ Route::RemoteControlIDChange (); /* EMIT SIGNAL */
+ break;
+ default:
+ break;
+ }
+
+ /* tell everyone that something has happened to the sort keys
+ and let them sync up with the change(s)
*/
- cerr << "Next control ID will be " << ntracks() + (nbusses() - subtract) << endl;
- return ntracks() + (nbusses() - subtract);
+ DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("Sync Order Keys, based on %1\n", enum_2_string (sort_key_changed)));
+
+ Route::SyncOrderKeys (sort_key_changed); /* EMIT SIGNAL */
}
bool
}
case ControllableDescriptor::RemoteControlID:
- cerr << "RID " << desc.rid() << endl;
r = route_by_remote_id (desc.rid());
break;
}
if (!r) {
- cerr << "no controllable with no route\n";
return c;
}
--send;
}
- cerr << "Look for send " << send << endl;
-
boost::shared_ptr<Processor> p = r->nth_send (send);
if (p) {
boost::shared_ptr<Send> s = boost::dynamic_pointer_cast<Send>(p);
boost::shared_ptr<Amp> a = s->amp();
- cerr << " looked for send " << send << " got " << s << " amp = " << a << endl;
-
if (a) {
c = s->amp()->gain_control();
}
} else if (p == "history-depth") {
set_history_depth (Config->get_history_depth());
} else if (p == "sync-all-route-ordering") {
- sync_order_keys (UndefinedSort);
+ /* XXX sync_order_keys (UndefinedSort); */
} else if (p == "initial-program-change") {
if (MIDI::Manager::instance()->mmc()->output_port() && Config->get_initial_program_change() >= 0) {
projects / ardour.git / commitdiff