gtk2_ardour/editor_route_groups.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 <cstdlib>
  21 #include <cmath>
  22
  23 #include <gtkmm2ext/stop_signal.h>
  24 #include <gtkmm2ext/gtk_ui.h>
  25 #include "ardour/route_group.h"
  26
  27 #include "editor.h"
  28 #include "keyboard.h"
  29 #include "marker.h"
  30 #include "time_axis_view.h"
  31 #include "prompter.h"
  32 #include "gui_thread.h"
  33 #include "editor_group_tabs.h"
  34 #include "route_group_dialog.h"
  35 #include "route_time_axis.h"
  36 #include "editor_routes.h"
  37 #include "editor_route_groups.h"
  38
  39 #include "ardour/route.h"
  40 #include "ardour/session.h"
  41
  42 #include "i18n.h"
  43
  44 using namespace std;
  45 using namespace sigc;
  46 using namespace ARDOUR;
  47 using namespace PBD;
  48 using namespace Gtk;
  49
  50 EditorRouteGroups::EditorRouteGroups (Editor* e)
  51         : EditorComponent (e),
  52           _menu (0),
  53           _in_row_change (false)
  54
  55 {
  56         _model = ListStore::create (_columns);
  57         _display.set_model (_model);
  58
  59         _display.append_column (_("Name"), _columns.text);
  60
  61         _display.append_column (_("G"), _columns.gain);
  62         _display.append_column (_("R"), _columns.record);
  63         _display.append_column (_("M"), _columns.mute);
  64         _display.append_column (_("S"), _columns.solo);
  65         _display.append_column (_("Sel"), _columns.select);
  66         _display.append_column (_("E"), _columns.edits);
  67
  68         _display.append_column (_("Show"), _columns.is_visible);
  69
  70         _display.get_column (0)->set_data (X_("colnum"), GUINT_TO_POINTER(0));
  71         _display.get_column (1)->set_data (X_("colnum"), GUINT_TO_POINTER(1));
  72         _display.get_column (2)->set_data (X_("colnum"), GUINT_TO_POINTER(2));
  73         _display.get_column (3)->set_data (X_("colnum"), GUINT_TO_POINTER(3));
  74         _display.get_column (4)->set_data (X_("colnum"), GUINT_TO_POINTER(4));
  75         _display.get_column (5)->set_data (X_("colnum"), GUINT_TO_POINTER(5));
  76         _display.get_column (6)->set_data (X_("colnum"), GUINT_TO_POINTER(6));
  77         _display.get_column (7)->set_data (X_("colnum"), GUINT_TO_POINTER(7));
  78
  79         _display.get_column (0)->set_expand (true);
  80         _display.get_column (1)->set_expand (false);
  81         _display.get_column (2)->set_expand (false);
  82         _display.get_column (3)->set_expand (false);
  83         _display.get_column (4)->set_expand (false);
  84         _display.get_column (5)->set_expand (false);
  85         _display.get_column (6)->set_expand (false);
  86         _display.get_column (7)->set_expand (false);
  87
  88         _display.set_headers_visible (true);
  89
  90         /* name is directly editable */
  91
  92         CellRendererText* name_cell = dynamic_cast<CellRendererText*>(_display.get_column_cell_renderer (0));
  93         name_cell->property_editable() = true;
  94         name_cell->signal_edited().connect (mem_fun (*this, &EditorRouteGroups::name_edit));
  95
  96         /* use checkbox for the active + visible columns */
  97
  98         CellRendererToggle* active_cell = dynamic_cast<CellRendererToggle*>(_display.get_column_cell_renderer (1));
  99         active_cell->property_activatable() = true;
 100         active_cell->property_radio() = false;
 101
 102         active_cell = dynamic_cast<CellRendererToggle*>(_display.get_column_cell_renderer (2));
 103         active_cell->property_activatable() = true;
 104         active_cell->property_radio() = false;
 105
 106         active_cell = dynamic_cast<CellRendererToggle*>(_display.get_column_cell_renderer (3));
 107         active_cell->property_activatable() = true;
 108         active_cell->property_radio() = false;
 109
 110         active_cell = dynamic_cast<CellRendererToggle*>(_display.get_column_cell_renderer (4));
 111         active_cell->property_activatable() = true;
 112         active_cell->property_radio() = false;
 113
 114         active_cell = dynamic_cast<CellRendererToggle*>(_display.get_column_cell_renderer (5));
 115         active_cell->property_activatable() = true;
 116         active_cell->property_radio() = false;
 117
 118         active_cell = dynamic_cast<CellRendererToggle*>(_display.get_column_cell_renderer (6));
 119         active_cell->property_activatable() = true;
 120         active_cell->property_radio() = false;
 121
 122         active_cell = dynamic_cast<CellRendererToggle*>(_display.get_column_cell_renderer (7));
 123         active_cell->property_activatable() = true;
 124         active_cell->property_radio() = false;
 125
 126         _model->signal_row_changed().connect (mem_fun (*this, &EditorRouteGroups::row_change));
 127
 128         _display.set_name ("EditGroupList");
 129         _display.get_selection()->set_mode (SELECTION_SINGLE);
 130         _display.set_headers_visible (true);
 131         _display.set_reorderable (false);
 132         _display.set_rules_hint (true);
 133         _display.set_size_request (75, -1);
 134
 135         _scroller.add (_display);
 136         _scroller.set_policy (POLICY_AUTOMATIC, POLICY_AUTOMATIC);
 137
 138         _display.signal_button_press_event().connect (mem_fun(*this, &EditorRouteGroups::button_press_event), false);
 139
 140         _display_packer = new VBox;
 141         HBox* button_box = manage (new HBox());
 142         button_box->set_homogeneous (true);
 143
 144         Button* add_button = manage (new Button ());
 145         Button* remove_button = manage (new Button ());
 146
 147         Widget* w;
 148
 149         w = manage (new Image (Stock::ADD, ICON_SIZE_BUTTON));
 150         w->show();
 151         add_button->add (*w);
 152
 153         w = manage (new Image (Stock::REMOVE, ICON_SIZE_BUTTON));
 154         w->show();
 155         remove_button->add (*w);
 156
 157         add_button->signal_clicked().connect (mem_fun (*this, &EditorRouteGroups::new_route_group));
 158         remove_button->signal_clicked().connect (mem_fun (*this, &EditorRouteGroups::remove_selected));
 159
 160         button_box->pack_start (*add_button);
 161         button_box->pack_start (*remove_button);
 162
 163         _display_packer->pack_start (_scroller, true, true);
 164         _display_packer->pack_start (*button_box, false, false);
 165 }
 166
 167
 168 Gtk::Menu*
 169 EditorRouteGroups::menu (RouteGroup* g)
 170 {
 171         using namespace Gtk::Menu_Helpers;
 172
 173         delete _menu;
 174
 175         Menu* new_from = new Menu;
 176         MenuList& f = new_from->items ();
 177         f.push_back (MenuElem (_("Selection..."), mem_fun (*this, &EditorRouteGroups::new_from_selection)));
 178         f.push_back (MenuElem (_("Record Enabled..."), mem_fun (*this, &EditorRouteGroups::new_from_rec_enabled)));
 179         f.push_back (MenuElem (_("Soloed..."), mem_fun (*this, &EditorRouteGroups::new_from_soloed)));
 180
 181         _menu = new Menu;
 182         _menu->set_name ("ArdourContextMenu");
 183         MenuList& items = _menu->items();
 184
 185         items.push_back (MenuElem (_("New..."), mem_fun(*this, &EditorRouteGroups::new_route_group)));
 186         items.push_back (MenuElem (_("New From"), *new_from));
 187         if (g) {
 188                 items.push_back (MenuElem (_("Edit..."), bind (mem_fun (*this, &EditorRouteGroups::edit), g)));
 189                 items.push_back (MenuElem (_("Fit to Window"), bind (mem_fun (*_editor, &Editor::fit_route_group), g)));
 190                 items.push_back (MenuElem (_("Subgroup"), bind (mem_fun (*this, &EditorRouteGroups::subgroup), g)));
 191                 items.push_back (MenuElem (_("Collect"), bind (mem_fun (*this, &EditorRouteGroups::collect), g)));
 192         }
 193         items.push_back (SeparatorElem());
 194         items.push_back (MenuElem (_("Activate All"), mem_fun(*this, &EditorRouteGroups::activate_all)));
 195         items.push_back (MenuElem (_("Disable All"), mem_fun(*this, &EditorRouteGroups::disable_all)));
 196
 197         return _menu;
 198 }
 199
 200 void
 201 EditorRouteGroups::subgroup (RouteGroup* g)
 202 {
 203         g->make_subgroup ();
 204 }
 205
 206 void
 207 EditorRouteGroups::unsubgroup (RouteGroup* g)
 208 {
 209         g->destroy_subgroup ();
 210 }
 211
 212 void
 213 EditorRouteGroups::activate_all ()
 214 {
 215         _session->foreach_route_group (
 216                 bind (mem_fun (*this, &EditorRouteGroups::set_activation), true)
 217                 );
 218 }
 219
 220 void
 221 EditorRouteGroups::disable_all ()
 222 {
 223         _session->foreach_route_group (
 224                 bind (mem_fun (*this, &EditorRouteGroups::set_activation), false)
 225                 );
 226 }
 227
 228 void
 229 EditorRouteGroups::set_activation (RouteGroup* g, bool a)
 230 {
 231         g->set_active (a, this);
 232 }
 233
 234 void
 235 EditorRouteGroups::new_route_group ()
 236 {
 237         RouteGroup* g = new RouteGroup (
 238                 *_session,
 239                 "",
 240                 RouteGroup::Active,
 241                 (RouteGroup::Property) (RouteGroup::Mute | RouteGroup::Solo | RouteGroup::Edit)
 242                 );
 243
 244         RouteGroupDialog d (g, Gtk::Stock::NEW);
 245         int const r = d.do_run ();
 246
 247         if (r == Gtk::RESPONSE_OK) {
 248                 _session->add_route_group (g);
 249         } else {
 250                 delete g;
 251         }
 252 }
 253
 254 void
 255 EditorRouteGroups::run_new_group_dialog (const RouteList& rl)
 256 {
 257         RouteGroup* g = new RouteGroup (
 258                 *_session,
 259                 "",
 260                 RouteGroup::Active,
 261                 (RouteGroup::Property) (RouteGroup::Mute | RouteGroup::Solo | RouteGroup::Edit | RouteGroup::RecEnable)
 262                 );
 263
 264         RouteGroupDialog d (g, Gtk::Stock::NEW);
 265         int const r = d.do_run ();
 266
 267         switch (r) {
 268         case Gtk::RESPONSE_OK:
 269         case Gtk::RESPONSE_ACCEPT:
 270                 _session->add_route_group (g);
 271                 for (RouteList::const_iterator i = rl.begin(); i != rl.end(); ++i) {
 272                         (*i)->set_route_group (g, this);
 273                 }
 274                 break;
 275         default:
 276                 delete g;
 277         }
 278 }
 279
 280 void
 281 EditorRouteGroups::new_from_selection ()
 282 {
 283         if (_editor->get_selection().tracks.empty()) {
 284                 return;
 285         }
 286
 287         RouteList rl;
 288
 289         for (TrackSelection::iterator i = _editor->get_selection().tracks.begin(); i != _editor->get_selection().tracks.end(); ++i) {
 290                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*i);
 291                 if (rtv) {
 292                         rl.push_back (rtv->route());
 293                 }
 294         }
 295
 296         if (rl.empty()) {
 297                 return;
 298         }
 299
 300         run_new_group_dialog (rl);
 301 }
 302
 303 void
 304 EditorRouteGroups::new_from_rec_enabled ()
 305 {
 306         RouteList rl;
 307
 308         for (Editor::TrackViewList::const_iterator i = _editor->get_track_views().begin(); i != _editor->get_track_views().end(); ++i) {
 309                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*i);
 310                 if (rtv && rtv->route()->record_enabled()) {
 311                         rl.push_back (rtv->route());
 312                 }
 313         }
 314
 315         if (rl.empty()) {
 316                 return;
 317         }
 318
 319         run_new_group_dialog (rl);
 320 }
 321
 322 void
 323 EditorRouteGroups::new_from_soloed ()
 324 {
 325         RouteList rl;
 326
 327         for (Editor::TrackViewList::const_iterator i = _editor->get_track_views().begin(); i != _editor->get_track_views().end(); ++i) {
 328                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*i);
 329                 if (rtv && !rtv->route()->is_master() && rtv->route()->soloed()) {
 330                         rl.push_back (rtv->route());
 331                 }
 332         }
 333
 334         if (rl.empty()) {
 335                 return;
 336         }
 337
 338         run_new_group_dialog (rl);
 339 }
 340
 341 void
 342 EditorRouteGroups::edit (RouteGroup* g)
 343 {
 344         RouteGroupDialog d (g, Gtk::Stock::APPLY);
 345         d.do_run ();
 346 }
 347
 348 void
 349 EditorRouteGroups::remove_selected ()
 350 {
 351         Glib::RefPtr<TreeSelection> selection = _display.get_selection();
 352         TreeView::Selection::ListHandle_Path rows = selection->get_selected_rows ();
 353
 354         if (rows.empty()) {
 355                 return;
 356         }
 357
 358         TreeView::Selection::ListHandle_Path::iterator i = rows.begin();
 359         TreeIter iter;
 360
 361         /* selection mode is single, so rows.begin() is it */
 362
 363         if ((iter = _model->get_iter (*i))) {
 364
 365                 RouteGroup* rg = (*iter)[_columns.routegroup];
 366
 367                 if (rg) {
 368                         _session->remove_route_group (*rg);
 369                 }
 370         }
 371 }
 372
 373 void
 374 EditorRouteGroups::button_clicked ()
 375 {
 376         new_route_group ();
 377 }
 378
 379 gint
 380 EditorRouteGroups::button_press_event (GdkEventButton* ev)
 381 {
 382         TreeModel::Path path;
 383         TreeIter iter;
 384         RouteGroup* group = 0;
 385         TreeViewColumn* column;
 386         int cellx;
 387         int celly;
 388
 389         bool const p = _display.get_path_at_pos ((int)ev->x, (int)ev->y, path, column, cellx, celly);
 390
 391         if (p) {
 392                 iter = _model->get_iter (path);
 393         }
 394
 395         if (iter) {
 396                 group = (*iter)[_columns.routegroup];
 397         }
 398
 399         if (Keyboard::is_context_menu_event (ev)) {
 400                 menu(group)->popup (1, ev->time);
 401                 return true;
 402         }
 403
 404         if (!p) {
 405                 return 1;
 406         }
 407
 408         switch (GPOINTER_TO_UINT (column->get_data (X_("colnum")))) {
 409         case 0:
 410                 if (Keyboard::is_edit_event (ev)) {
 411                         if ((iter = _model->get_iter (path))) {
 412                                 if ((group = (*iter)[_columns.routegroup]) != 0) {
 413                                         // edit_route_group (group);
 414 #ifdef GTKOSX
 415                                         _display.queue_draw();
 416 #endif
 417                                         return true;
 418                                 }
 419                         }
 420
 421                 }
 422                 break;
 423
 424         case 1:
 425                 if ((iter = _model->get_iter (path))) {
 426                         bool gain = (*iter)[_columns.gain];
 427                         (*iter)[_columns.gain] = !gain;
 428 #ifdef GTKOSX
 429                         _display.queue_draw();
 430 #endif
 431                         return true;
 432                 }
 433                 break;
 434
 435         case 2:
 436                 if ((iter = _model->get_iter (path))) {
 437                         bool record = (*iter)[_columns.record];
 438                         (*iter)[_columns.record] = !record;
 439 #ifdef GTKOSX
 440                         _display.queue_draw();
 441 #endif
 442                         return true;
 443                 }
 444                 break;
 445
 446         case 3:
 447                 if ((iter = _model->get_iter (path))) {
 448                         bool mute = (*iter)[_columns.mute];
 449                         (*iter)[_columns.mute] = !mute;
 450 #ifdef GTKOSX
 451                         _display.queue_draw();
 452 #endif
 453                         return true;
 454                 }
 455                 break;
 456
 457         case 4:
 458                 if ((iter = _model->get_iter (path))) {
 459                         bool solo = (*iter)[_columns.solo];
 460                         (*iter)[_columns.solo] = !solo;
 461 #ifdef GTKOSX
 462                         _display.queue_draw();
 463 #endif
 464                         return true;
 465                 }
 466                 break;
 467
 468         case 5:
 469                 if ((iter = _model->get_iter (path))) {
 470                         bool select = (*iter)[_columns.select];
 471                         (*iter)[_columns.select] = !select;
 472 #ifdef GTKOSX
 473                         _display.queue_draw();
 474 #endif
 475                         return true;
 476                 }
 477                 break;
 478
 479         case 6:
 480                 if ((iter = _model->get_iter (path))) {
 481                         bool edits = (*iter)[_columns.edits];
 482                         (*iter)[_columns.edits] = !edits;
 483 #ifdef GTKOSX
 484                         _display.queue_draw();
 485 #endif
 486                         return true;
 487                 }
 488                 break;
 489
 490         case 7:
 491                 if ((iter = _model->get_iter (path))) {
 492                         bool visible = (*iter)[_columns.is_visible];
 493                         (*iter)[_columns.is_visible] = !visible;
 494 #ifdef GTKOSX
 495                         _display.queue_draw();
 496 #endif
 497                         return true;
 498                 }
 499                 break;
 500
 501         default:
 502                 break;
 503         }
 504
 505         return false;
 506  }
 507
 508 void
 509 EditorRouteGroups::row_change (const Gtk::TreeModel::Path&, const Gtk::TreeModel::iterator& iter)
 510 {
 511         RouteGroup* group;
 512
 513         if (_in_row_change) {
 514                 return;
 515         }
 516
 517         if ((group = (*iter)[_columns.routegroup]) == 0) {
 518                 return;
 519         }
 520
 521         if ((*iter)[_columns.is_visible]) {
 522                 for (Editor::TrackViewList::const_iterator j = _editor->get_track_views().begin(); j != _editor->get_track_views().end(); ++j) {
 523                         if ((*j)->route_group() == group) {
 524                                 _editor->_routes->show_track_in_display (**j);
 525                         }
 526                 }
 527         } else {
 528                 for (Editor::TrackViewList::const_iterator j = _editor->get_track_views().begin(); j != _editor->get_track_views().end(); ++j) {
 529                         if ((*j)->route_group() == group) {
 530                                 _editor->hide_track_in_display (**j);
 531                         }
 532                 }
 533         }
 534
 535         group->set_property (RouteGroup::Gain, (*iter)[_columns.gain]);
 536         group->set_property (RouteGroup::RecEnable, (*iter)[_columns.record]);
 537         group->set_property (RouteGroup::Mute, (*iter)[_columns.mute]);
 538         group->set_property (RouteGroup::Solo, (*iter)[_columns.solo]);
 539         group->set_property (RouteGroup::Select, (*iter)[_columns.select]);
 540         group->set_property (RouteGroup::Edit, (*iter)[_columns.edits]);
 541
 542         string name = (*iter)[_columns.text];
 543
 544         if (name != group->name()) {
 545                 group->set_name (name);
 546         }
 547 }
 548
 549 void
 550 EditorRouteGroups::add (RouteGroup* group)
 551 {
 552         ENSURE_GUI_THREAD (bind (mem_fun(*this, &EditorRouteGroups::add), group));
 553         bool focus = false;
 554
 555         TreeModel::Row row = *(_model->append());
 556
 557         row[_columns.is_visible] = !group->is_hidden();
 558         row[_columns.gain] = group->property(RouteGroup::Gain);
 559         row[_columns.record] = group->property(RouteGroup::RecEnable);
 560         row[_columns.mute] = group->property(RouteGroup::Mute);
 561         row[_columns.solo] = group->property(RouteGroup::Solo);
 562         row[_columns.select] = group->property(RouteGroup::Select);
 563         row[_columns.edits] = group->property(RouteGroup::Edit);
 564
 565         _in_row_change = true;
 566
 567         row[_columns.routegroup] = group;
 568
 569         if (!group->name().empty()) {
 570                 row[_columns.text] = group->name();
 571         } else {
 572                 row[_columns.text] = _("unnamed");
 573                 focus = true;
 574         }
 575
 576         group->FlagsChanged.connect (bind (mem_fun (*this, &EditorRouteGroups::flags_changed), group));
 577
 578         if (focus) {
 579                 TreeViewColumn* col = _display.get_column (0);
 580                 CellRendererText* name_cell = dynamic_cast<CellRendererText*>(_display.get_column_cell_renderer (0));
 581                 _display.set_cursor (_model->get_path (row), *col, *name_cell, true);
 582         }
 583
 584         _in_row_change = false;
 585
 586         _editor->_group_tabs->set_dirty ();
 587 }
 588
 589 void
 590 EditorRouteGroups::groups_changed ()
 591 {
 592         ENSURE_GUI_THREAD (mem_fun (*this, &EditorRouteGroups::groups_changed));
 593
 594         /* just rebuild the while thing */
 595
 596         _model->clear ();
 597
 598         {
 599                 TreeModel::Row row;
 600                 row = *(_model->append());
 601                 row[_columns.is_visible] = true;
 602                 row[_columns.text] = (_("-all-"));
 603                 row[_columns.routegroup] = 0;
 604         }
 605
 606         _session->foreach_route_group (mem_fun (*this, &EditorRouteGroups::add));
 607 }
 608
 609 void
 610 EditorRouteGroups::flags_changed (void* src, RouteGroup* group)
 611 {
 612         ENSURE_GUI_THREAD (bind (mem_fun(*this, &EditorRouteGroups::flags_changed), src, group));
 613
 614         _in_row_change = true;
 615
 616         Gtk::TreeModel::Children children = _model->children();
 617
 618         for(Gtk::TreeModel::Children::iterator iter = children.begin(); iter != children.end(); ++iter) {
 619                 if (group == (*iter)[_columns.routegroup]) {
 620                         (*iter)[_columns.is_visible] = !group->is_hidden();
 621                         (*iter)[_columns.text] = group->name();
 622                         (*iter)[_columns.gain] = group->property(RouteGroup::Gain);
 623                         (*iter)[_columns.record] = group->property(RouteGroup::RecEnable);
 624                         (*iter)[_columns.mute] = group->property(RouteGroup::Mute);
 625                         (*iter)[_columns.solo] = group->property(RouteGroup::Solo);
 626                         (*iter)[_columns.select] = group->property(RouteGroup::Select);
 627                         (*iter)[_columns.edits] = group->property(RouteGroup::Edit);
 628                 }
 629         }
 630
 631         _in_row_change = false;
 632
 633         _editor->_group_tabs->set_dirty ();
 634 }
 635
 636 void
 637 EditorRouteGroups::name_edit (const Glib::ustring& path, const Glib::ustring& new_text)
 638 {
 639         RouteGroup* group;
 640         TreeIter iter;
 641
 642         if ((iter = _model->get_iter (path))) {
 643
 644                 if ((group = (*iter)[_columns.routegroup]) == 0) {
 645                         return;
 646                 }
 647
 648                 if (new_text != group->name()) {
 649                         group->set_name (new_text);
 650                 }
 651         }
 652 }
 653
 654 void
 655 EditorRouteGroups::clear ()
 656 {
 657         _display.set_model (Glib::RefPtr<Gtk::TreeStore> (0));
 658         _model->clear ();
 659         _display.set_model (_model);
 660 }
 661
 662 void
 663 EditorRouteGroups::connect_to_session (Session* s)
 664 {
 665         EditorComponent::connect_to_session (s);
 666
 667         _session_connections.push_back (_session->route_group_added.connect (mem_fun (*this, &EditorRouteGroups::add)));
 668         _session_connections.push_back (_session->route_group_removed.connect (mem_fun (*this, &EditorRouteGroups::groups_changed)));
 669
 670         groups_changed ();
 671 }
 672
 673 struct CollectSorter {
 674         bool operator () (Route* a, Route* b) {
 675                 return a->order_key (N_ ("editor")) < b->order_key (N_ ("editor"));
 676         }
 677 };
 678
 679 /** Collect all members of a RouteGroup so that they are together in the Editor.
 680  *  @param g Group to collect.
 681  */
 682 void
 683 EditorRouteGroups::collect (RouteGroup* g)
 684 {
 685         list<Route*> routes = g->route_list ();
 686         routes.sort (CollectSorter ());
 687         int const N = routes.size ();
 688
 689         list<Route*>::iterator i = routes.begin ();
 690         Editor::TrackViewList::const_iterator j = _editor->get_track_views().begin();
 691
 692         int diff = 0;
 693         int coll = -1;
 694         while (i != routes.end() && j != _editor->get_track_views().end()) {
 695
 696                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*j);
 697                 if (rtv) {
 698
 699                         boost::shared_ptr<Route> r = rtv->route ();
 700                         int const k = r->order_key (N_ ("editor"));
 701
 702                         if (*i == r.get()) {
 703
 704                                 if (coll == -1) {
 705                                         coll = k;
 706                                         diff = N - 1;
 707                                 } else {
 708                                         --diff;
 709                                 }
 710
 711                                 r->set_order_key (N_ ("editor"), coll);
 712
 713                                 ++coll;
 714                                 ++i;
 715
 716                         } else {
 717
 718                                 r->set_order_key (N_ ("editor"), k + diff);
 719
 720                         }
 721                 }
 722
 723                 ++j;
 724         }
 725
 726         _editor->_routes->sync_order_keys ("");
 727 }