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