gtk2_ardour/editor_route_list.cc

   1 /*
   2     Copyright (C) 2000 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include <algorithm>
  21 #include <cstdlib>
  22 #include <cmath>
  23
  24 #include "editor.h"
  25 #include "keyboard.h"
  26 #include "ardour_ui.h"
  27 #include "audio_time_axis.h"
  28 #include "mixer_strip.h"
  29 #include "gui_thread.h"
  30 #include "actions.h"
  31
  32 #include <ardour/route.h>
  33 #include <ardour/audio_track.h>
  34 #include <ardour/route_group.h>
  35
  36 #include "i18n.h"
  37
  38 using namespace sigc;
  39 using namespace ARDOUR;
  40 using namespace PBD;
  41 using namespace Gtk;
  42 using namespace Glib;
  43
  44 const char* _order_key = N_("editor");
  45
  46 void
  47 Editor::handle_new_route (Session::RouteList& routes)
  48 {
  49         ENSURE_GUI_THREAD(bind (mem_fun(*this, &Editor::handle_new_route), routes));
  50
  51         TimeAxisView *tv;
  52         AudioTimeAxisView *atv;
  53         TreeModel::Row parent;
  54         TreeModel::Row row;
  55
  56         route_redisplay_does_not_sync_order_keys = true;
  57         no_route_list_redisplay = true;
  58
  59         for (Session::RouteList::iterator x = routes.begin(); x != routes.end(); ++x) {
  60                 boost::shared_ptr<Route> route = (*x);
  61
  62                 if (route->hidden()) {
  63                         continue;
  64                 }
  65
  66                 tv = new AudioTimeAxisView (*this, *session, route, *track_canvas);
  67                 //cerr << "Editor::handle_new_route() called on " << route->name() << endl;//DEBUG
  68                 row = *(route_display_model->append ());
  69
  70                 row[route_display_columns.route] = route;
  71                 row[route_display_columns.text] = route->name();
  72                 row[route_display_columns.visible] = tv->marked_for_display();
  73                 row[route_display_columns.tv] = tv;
  74
  75                 RouteGroup *group = route->edit_group();
  76                 if (group) {
  77                         if (tv->marked_for_display()) {
  78                                 group->set_hidden(false, this);
  79                                 group_flags_changed(this, group);
  80                         }
  81                 }
  82
  83                 track_views.push_back (tv);
  84
  85                 if ((atv = dynamic_cast<AudioTimeAxisView*> (tv)) != 0) {
  86                         /* added a new fresh one at the end */
  87                         if (atv->route()->order_key(_order_key) == -1) {
  88                                 atv->route()->set_order_key (_order_key, route_display_model->children().size()-1);
  89                         }
  90                         atv->effective_gain_display ();
  91                 }
  92
  93                 route->gui_changed.connect (mem_fun(*this, &Editor::handle_gui_changes));
  94                 tv->GoingAway.connect (bind (mem_fun(*this, &Editor::remove_route), tv));
  95         }
  96
  97         no_route_list_redisplay = false;
  98
  99         redisplay_route_list ();
 100
 101         if (show_editor_mixer_when_tracks_arrive) {
 102                 show_editor_mixer (true);
 103         }
 104
 105         route_redisplay_does_not_sync_order_keys = false;
 106 }
 107
 108 void
 109 Editor::handle_gui_changes (const string & what, void *src)
 110 {
 111         ENSURE_GUI_THREAD(bind (mem_fun(*this, &Editor::handle_gui_changes), what, src));
 112
 113         if (what == "track_height") {
 114                 /* Optional :make tracks change height while it happens, instead
 115                    of on first-idle
 116                 */
 117                 //track_canvas->update_now ();
 118                 redisplay_route_list ();
 119         }
 120
 121         if (what == "visible_tracks") {
 122                 redisplay_route_list ();
 123         }
 124 }
 125
 126 void
 127 Editor::remove_route (TimeAxisView *tv)
 128 {
 129         ENSURE_GUI_THREAD(bind (mem_fun(*this, &Editor::remove_route), tv));
 130
 131         TrackViewList::iterator i;
 132         TreeModel::Children rows = route_display_model->children();
 133         TreeModel::Children::iterator ri;
 134         boost::shared_ptr<Route> route;
 135         TimeAxisView* next_tv = 0;
 136
 137         if (tv == entered_track) {
 138                 entered_track = 0;
 139         }
 140
 141         /* the core model has changed, there is no need to sync
 142            view orders.
 143         */
 144
 145         route_redisplay_does_not_sync_order_keys = true;
 146
 147         for (ri = rows.begin(); ri != rows.end(); ++ri) {
 148                 if ((*ri)[route_display_columns.tv] == tv) {
 149                         route = (*ri)[route_display_columns.route];
 150                         route_display_model->erase (ri);
 151                         break;
 152                 }
 153         }
 154
 155         route_redisplay_does_not_sync_order_keys = false;
 156
 157         if ((i = find (track_views.begin(), track_views.end(), tv)) != track_views.end()) {
 158                 i = track_views.erase (i);
 159
 160                 if (track_views.empty()) {
 161                         next_tv = 0;
 162                 } else if (i == track_views.end()) {
 163                         next_tv = track_views.front();
 164                 } else {
 165                         next_tv = (*i);
 166                 }
 167         }
 168
 169         if (current_mixer_strip && (current_mixer_strip->route() == route)) {
 170
 171                 if (next_tv) {
 172                         set_selected_mixer_strip (*next_tv);
 173                 } else {
 174                         /* make the editor mixer strip go away by setting the
 175                          * button to inactive (which also unticks the menu option)
 176                          */
 177
 178                         ActionManager::uncheck_toggleaction ("<Actions>/Editor/show-editor-mixer");
 179                 }
 180         }
 181 }
 182
 183 void
 184 Editor::route_name_changed (TimeAxisView *tv)
 185 {
 186         ENSURE_GUI_THREAD(bind (mem_fun(*this, &Editor::route_name_changed), tv));
 187
 188         TreeModel::Children rows = route_display_model->children();
 189         TreeModel::Children::iterator i;
 190
 191         for (i = rows.begin(); i != rows.end(); ++i) {
 192                 if ((*i)[route_display_columns.tv] == tv) {
 193                         (*i)[route_display_columns.text] = tv->name();
 194                         break;
 195                 }
 196         }
 197 }
 198
 199 void
 200 Editor::update_route_visibility ()
 201 {
 202         TreeModel::Children rows = route_display_model->children();
 203         TreeModel::Children::iterator i;
 204
 205         no_route_list_redisplay = true;
 206
 207         for (i = rows.begin(); i != rows.end(); ++i) {
 208                 TimeAxisView *tv = (*i)[route_display_columns.tv];
 209                 (*i)[route_display_columns.visible] = tv->marked_for_display ();
 210         }
 211
 212         no_route_list_redisplay = false;
 213         redisplay_route_list ();
 214 }
 215
 216 void
 217 Editor::hide_track_in_display (TimeAxisView& tv, bool temponly)
 218 {
 219         TreeModel::Children rows = route_display_model->children();
 220         TreeModel::Children::iterator i;
 221
 222         for (i = rows.begin(); i != rows.end(); ++i) {
 223                 if ((*i)[route_display_columns.tv] == &tv) {
 224                         (*i)[route_display_columns.visible] = false;
 225                         break;
 226                 }
 227         }
 228
 229         AudioTimeAxisView* atv = dynamic_cast<AudioTimeAxisView*> (&tv);
 230
 231         if (atv && current_mixer_strip && (atv->route() == current_mixer_strip->route())) {
 232                 // this will hide the mixer strip
 233                 set_selected_mixer_strip (tv);
 234         }
 235 }
 236
 237 void
 238 Editor::show_track_in_display (TimeAxisView& tv)
 239 {
 240         TreeModel::Children rows = route_display_model->children();
 241         TreeModel::Children::iterator i;
 242
 243         for (i = rows.begin(); i != rows.end(); ++i) {
 244                 if ((*i)[route_display_columns.tv] == &tv) {
 245                         (*i)[route_display_columns.visible] = true;
 246                         break;
 247                 }
 248         }
 249 }
 250
 251 void
 252 Editor::sync_order_keys (const char *src)
 253 {
 254         vector<int> neworder;
 255         TreeModel::Children rows = route_display_model->children();
 256         TreeModel::Children::iterator ri;
 257
 258         if ((strcmp (src, _order_key) == 0) || !session || (session->state_of_the_state() & Session::Loading) || rows.empty()) {
 259                 return;
 260         }
 261
 262         for (ri = rows.begin(); ri != rows.end(); ++ri) {
 263                 neworder.push_back (0);
 264         }
 265
 266         bool changed = false;
 267         int order;
 268
 269         for (order = 0, ri = rows.begin(); ri != rows.end(); ++ri, ++order) {
 270                 boost::shared_ptr<Route> route = (*ri)[route_display_columns.route];
 271
 272                 int old_key = order;
 273                 int new_key = route->order_key (_order_key);
 274
 275                 neworder[new_key] = old_key;
 276
 277                 if (new_key != old_key) {
 278                         changed = true;
 279                 }
 280         }
 281
 282         if (changed) {
 283                 route_redisplay_does_not_reset_order_keys = true;
 284                 route_display_model->reorder (neworder);
 285                 route_redisplay_does_not_reset_order_keys = false;
 286         }
 287 }
 288
 289 void
 290 Editor::redisplay_route_list ()
 291 {
 292         TreeModel::Children rows = route_display_model->children();
 293         TreeModel::Children::iterator i;
 294         uint32_t position;
 295         uint32_t order;
 296         int n;
 297
 298         if (no_route_list_redisplay) {
 299                 return;
 300         }
 301
 302         if (session && (rows.size() > session->nroutes())) {
 303                 /* temporary condition during a drag-n-drop */
 304                 return;
 305         }
 306
 307         for (n = 0, order = 0, position = 0, i = rows.begin(); i != rows.end(); ++i) {
 308                 TimeAxisView *tv = (*i)[route_display_columns.tv];
 309                 boost::shared_ptr<Route> route = (*i)[route_display_columns.route];
 310
 311                 if (tv == 0) {
 312                         // just a "title" row
 313                         continue;
 314                 }
 315
 316                 if (!route_redisplay_does_not_reset_order_keys) {
 317
 318                         /* this reorder is caused by user action, so reassign sort order keys
 319                            to tracks.
 320                         */
 321
 322                         route->set_order_key (_order_key, order);
 323                 }
 324
 325                 bool visible = (*i)[route_display_columns.visible];
 326
 327                 if (visible) {
 328                         tv->set_marked_for_display (true);
 329                         position += tv->show_at (position, n, &edit_controls_vbox);
 330                         tv->clip_to_viewport ();
 331                 } else {
 332                         tv->set_marked_for_display (false);
 333                         tv->hide ();
 334                 }
 335
 336                 ++order;
 337                 ++n;
 338         }
 339
 340         /* whenever we go idle, update the track view list to reflect the new order.
 341            we can't do this here, because we could mess up something that is traversing
 342            the track order and has caused a redisplay of the list.
 343         */
 344
 345         Glib::signal_idle().connect (mem_fun (*this, &Editor::sync_track_view_list_and_route_list));
 346
 347         full_canvas_height = position + canvas_timebars_vsize;
 348         vertical_adjustment.set_upper (full_canvas_height);
 349         if ((vertical_adjustment.get_value() + canvas_height) > vertical_adjustment.get_upper()) {
 350                 /*
 351                    We're increasing the size of the canvas while the bottom is visible.
 352                    We scroll down to keep in step with the controls layout.
 353                 */
 354                 vertical_adjustment.set_value (full_canvas_height - canvas_height);
 355         }
 356
 357         if (!route_redisplay_does_not_reset_order_keys && !route_redisplay_does_not_sync_order_keys) {
 358                 session->sync_order_keys (_order_key);
 359         }
 360 }
 361
 362 bool
 363 Editor::sync_track_view_list_and_route_list ()
 364 {
 365         TreeModel::Children rows = route_display_model->children();
 366         TreeModel::Children::iterator i;
 367
 368         track_views.clear ();
 369
 370         for (i = rows.begin(); i != rows.end(); ++i) {
 371                 TimeAxisView *tv = (*i)[route_display_columns.tv];
 372                 track_views.push_back (tv);
 373         }
 374
 375         return false; // do not call again (until needed)
 376 }
 377
 378 void
 379 Editor::hide_all_tracks (bool with_select)
 380 {
 381         TreeModel::Children rows = route_display_model->children();
 382         TreeModel::Children::iterator i;
 383
 384         no_route_list_redisplay = true;
 385
 386         for (i = rows.begin(); i != rows.end(); ++i) {
 387
 388                 TreeModel::Row row = (*i);
 389                 TimeAxisView *tv = row[route_display_columns.tv];
 390
 391                 if (tv == 0) {
 392                         continue;
 393                 }
 394
 395                 row[route_display_columns.visible] = false;
 396         }
 397
 398         no_route_list_redisplay = false;
 399         redisplay_route_list ();
 400
 401         /* XXX this seems like a hack and half, but its not clear where to put this
 402            otherwise.
 403         */
 404
 405         //reset_scrolling_region ();
 406 }
 407
 408 void
 409 Editor::build_route_list_menu ()
 410 {
 411         using namespace Menu_Helpers;
 412         using namespace Gtk;
 413
 414         route_list_menu = new Menu;
 415
 416         MenuList& items = route_list_menu->items();
 417         route_list_menu->set_name ("ArdourContextMenu");
 418
 419         items.push_back (MenuElem (_("Show All"), mem_fun(*this, &Editor::show_all_routes)));
 420         items.push_back (MenuElem (_("Hide All"), mem_fun(*this, &Editor::hide_all_routes)));
 421         items.push_back (MenuElem (_("Show All Audio Tracks"), mem_fun(*this, &Editor::show_all_audiotracks)));
 422         items.push_back (MenuElem (_("Hide All Audio Tracks"), mem_fun(*this, &Editor::hide_all_audiotracks)));
 423         items.push_back (MenuElem (_("Show All Audio Busses"), mem_fun(*this, &Editor::show_all_audiobus)));
 424         items.push_back (MenuElem (_("Hide All Audio Busses"), mem_fun(*this, &Editor::hide_all_audiobus)));
 425
 426 }
 427
 428 void
 429 Editor::set_all_tracks_visibility (bool yn)
 430 {
 431         TreeModel::Children rows = route_display_model->children();
 432         TreeModel::Children::iterator i;
 433
 434         no_route_list_redisplay = true;
 435
 436         for (i = rows.begin(); i != rows.end(); ++i) {
 437
 438                 TreeModel::Row row = (*i);
 439                 TimeAxisView* tv = row[route_display_columns.tv];
 440
 441                 if (tv == 0) {
 442                         continue;
 443                 }
 444
 445                 (*i)[route_display_columns.visible] = yn;
 446         }
 447
 448         no_route_list_redisplay = false;
 449         redisplay_route_list ();
 450 }
 451
 452 void
 453 Editor::set_all_audio_visibility (int tracks, bool yn)
 454 {
 455         TreeModel::Children rows = route_display_model->children();
 456         TreeModel::Children::iterator i;
 457
 458         no_route_list_redisplay = true;
 459
 460         for (i = rows.begin(); i != rows.end(); ++i) {
 461                 TreeModel::Row row = (*i);
 462                 TimeAxisView* tv = row[route_display_columns.tv];
 463                 AudioTimeAxisView* atv;
 464
 465                 if (tv == 0) {
 466                         continue;
 467                 }
 468
 469                 if ((atv = dynamic_cast<AudioTimeAxisView*>(tv)) != 0) {
 470                         switch (tracks) {
 471                         case 0:
 472                                 (*i)[route_display_columns.visible] = yn;
 473                                 break;
 474
 475                         case 1:
 476                                 if (atv->is_audio_track()) {
 477                                         (*i)[route_display_columns.visible] = yn;
 478                                 }
 479                                 break;
 480
 481                         case 2:
 482                                 if (!atv->is_audio_track()) {
 483                                         (*i)[route_display_columns.visible] = yn;
 484                                 }
 485                                 break;
 486                         }
 487                 }
 488         }
 489
 490         no_route_list_redisplay = false;
 491         redisplay_route_list ();
 492 }
 493
 494 void
 495 Editor::hide_all_routes ()
 496 {
 497         set_all_tracks_visibility (false);
 498 }
 499
 500 void
 501 Editor::show_all_routes ()
 502 {
 503         set_all_tracks_visibility (true);
 504 }
 505
 506 void
 507 Editor::show_all_audiobus ()
 508 {
 509         set_all_audio_visibility (2, true);
 510 }
 511 void
 512 Editor::hide_all_audiobus ()
 513 {
 514         set_all_audio_visibility (2, false);
 515 }
 516
 517 void
 518 Editor::show_all_audiotracks()
 519 {
 520         set_all_audio_visibility (1, true);
 521 }
 522 void
 523 Editor::hide_all_audiotracks ()
 524 {
 525         set_all_audio_visibility (1, false);
 526 }
 527
 528 bool
 529 Editor::route_list_display_button_press (GdkEventButton* ev)
 530 {
 531         if (Keyboard::is_context_menu_event (ev)) {
 532                 show_route_list_menu ();
 533                 return true;
 534         }
 535
 536         TreeIter iter;
 537         TreeModel::Path path;
 538         TreeViewColumn* column;
 539         int cellx;
 540         int celly;
 541
 542         if (!route_list_display.get_path_at_pos ((int)ev->x, (int)ev->y, path, column, cellx, celly)) {
 543                 return false;
 544         }
 545
 546         switch (GPOINTER_TO_UINT (column->get_data (X_("colnum")))) {
 547         case 0:
 548                 if ((iter = route_display_model->get_iter (path))) {
 549                         TimeAxisView* tv = (*iter)[route_display_columns.tv];
 550                         if (tv) {
 551                                 bool visible = (*iter)[route_display_columns.visible];
 552                                 (*iter)[route_display_columns.visible] = !visible;
 553                         }
 554                 }
 555                 return true;
 556
 557         case 1:
 558                 /* allow normal processing to occur */
 559                 return false;
 560
 561         default:
 562                 break;
 563         }
 564
 565         return false;
 566 }
 567
 568 void
 569 Editor::show_route_list_menu()
 570 {
 571         if (route_list_menu == 0) {
 572                 build_route_list_menu ();
 573         }
 574
 575         route_list_menu->popup (1, gtk_get_current_event_time());
 576 }
 577
 578 bool
 579 Editor::route_list_selection_filter (const Glib::RefPtr<TreeModel>& model, const TreeModel::Path& path, bool yn)
 580 {
 581         return true;
 582 }
 583
 584 struct EditorOrderRouteSorter {
 585     bool operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b) {
 586             /* use of ">" forces the correct sort order */
 587             return a->order_key (_order_key) < b->order_key (_order_key);
 588     }
 589 };
 590
 591 void
 592 Editor::initial_route_list_display ()
 593 {
 594         boost::shared_ptr<Session::RouteList> routes = session->get_routes();
 595         Session::RouteList r (*routes);
 596         EditorOrderRouteSorter sorter;
 597
 598         r.sort (sorter);
 599
 600         no_route_list_redisplay = true;
 601
 602         route_display_model->clear ();
 603
 604         handle_new_route (r);
 605
 606         no_route_list_redisplay = false;
 607
 608         redisplay_route_list ();
 609 }
 610
 611 void
 612 Editor::track_list_reorder (const Gtk::TreeModel::Path& path,const Gtk::TreeModel::iterator& iter, int* new_order)
 613 {
 614         route_redisplay_does_not_sync_order_keys = true;
 615         session->set_remote_control_ids();
 616         redisplay_route_list ();
 617         route_redisplay_does_not_sync_order_keys = false;
 618 }
 619
 620 void
 621 Editor::route_list_change (const Gtk::TreeModel::Path& path,const Gtk::TreeModel::iterator& iter)
 622 {
 623         /* never reset order keys because of a property change */
 624         route_redisplay_does_not_reset_order_keys = true;
 625         session->set_remote_control_ids();
 626         redisplay_route_list ();
 627         route_redisplay_does_not_reset_order_keys = false;
 628 }
 629
 630 void
 631 Editor::route_list_delete (const Gtk::TreeModel::Path& path)
 632 {
 633         /* this could require an order reset & sync */
 634         session->set_remote_control_ids();
 635         redisplay_route_list ();
 636 }
 637
 638 void
 639 Editor::route_list_display_drag_data_received (const RefPtr<Gdk::DragContext>& context,
 640                                                 int x, int y,
 641                                                 const SelectionData& data,
 642                                                 guint info, guint time)
 643 {
 644         if (data.get_target() == "GTK_TREE_MODEL_ROW") {
 645                 route_list_display.on_drag_data_received (context, x, y, data, info, time);
 646                 return;
 647         }
 648         context->drag_finish (true, false, time);
 649 }
 650
 651 void
 652 Editor::foreach_time_axis_view (sigc::slot<void,TimeAxisView&> theslot)
 653 {
 654         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
 655                 theslot (**i);
 656         }
 657 }
 658
 659 void
 660 Editor::move_selected_tracks (bool up)
 661 {
 662         if (selection->tracks.empty()) {
 663                 return;
 664         }
 665
 666         typedef pair<TimeAxisView*,boost::shared_ptr<Route> > ViewRoute;
 667         list<ViewRoute> view_routes;
 668         vector<int> neworder;
 669         TreeModel::Children rows = route_display_model->children();
 670         TreeModel::Children::iterator ri;
 671
 672         for (ri = rows.begin(); ri != rows.end(); ++ri) {
 673                 TimeAxisView* tv = (*ri)[route_display_columns.tv];
 674                 boost::shared_ptr<Route> route = (*ri)[route_display_columns.route];
 675
 676                 view_routes.push_back (ViewRoute (tv, route));
 677         }
 678
 679         list<ViewRoute>::iterator trailing;
 680         list<ViewRoute>::iterator leading;
 681
 682         if (up) {
 683
 684                 trailing = view_routes.begin();
 685                 leading = view_routes.begin();
 686
 687                 ++leading;
 688
 689                 while (leading != view_routes.end()) {
 690                         if (selection->selected (leading->first)) {
 691                                 view_routes.insert (trailing, ViewRoute (leading->first, leading->second));
 692                                 leading = view_routes.erase (leading);
 693                         } else {
 694                                 ++leading;
 695                                 ++trailing;
 696                         }
 697                 }
 698
 699         } else {
 700
 701                 /* if we could use reverse_iterator in list::insert, this code
 702                    would be a beautiful reflection of the code above. but we can't
 703                    and so it looks like a bit of a mess.
 704                 */
 705
 706                 trailing = view_routes.end();
 707                 leading = view_routes.end();
 708
 709                 --leading; if (leading == view_routes.begin()) { return; }
 710                 --leading;
 711                 --trailing;
 712
 713                 while (1) {
 714
 715                         if (selection->selected (leading->first)) {
 716                                 list<ViewRoute>::iterator tmp;
 717
 718                                 /* need to insert *after* trailing, not *before* it,
 719                                    which is what insert (iter, val) normally does.
 720                                 */
 721
 722                                 tmp = trailing;
 723                                 tmp++;
 724
 725                                 view_routes.insert (tmp, ViewRoute (leading->first, leading->second));
 726
 727                                 /* can't use iter = cont.erase (iter); form here, because
 728                                    we need iter to move backwards.
 729                                 */
 730
 731                                 tmp = leading;
 732                                 --tmp;
 733
 734                                 bool done = false;
 735
 736                                 if (leading == view_routes.begin()) {
 737                                         /* the one we've just inserted somewhere else
 738                                            was the first in the list. erase this copy,
 739                                            and then break, because we're done.
 740                                         */
 741                                         done = true;
 742                                 }
 743
 744                                 view_routes.erase (leading);
 745
 746                                 if (done) {
 747                                         break;
 748                                 }
 749
 750                                 leading = tmp;
 751
 752                         } else {
 753                                 if (leading == view_routes.begin()) {
 754                                         break;
 755                                 }
 756                                 --leading;
 757                                 --trailing;
 758                         }
 759                 };
 760         }
 761
 762         for (leading = view_routes.begin(); leading != view_routes.end(); ++leading) {
 763                 neworder.push_back (leading->second->order_key (_order_key));
 764         }
 765
 766         route_display_model->reorder (neworder);
 767
 768         session->sync_order_keys (_order_key);
 769 }