gtk2_ardour/mixer_ui.cc

   1 /*
   2     Copyright (C) 2000-2004 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 #ifdef WAF_BUILD
  21 #include "gtk2ardour-config.h"
  22 #endif
  23
  24 #include <algorithm>
  25 #include <map>
  26 #include <sigc++/bind.h>
  27
  28 #include <gtkmm/accelmap.h>
  29
  30 #include "pbd/convert.h"
  31 #include "pbd/unwind.h"
  32
  33 #include <glibmm/threads.h>
  34
  35 #include <gtkmm2ext/gtk_ui.h>
  36 #include <gtkmm2ext/utils.h>
  37 #include <gtkmm2ext/tearoff.h>
  38 #include <gtkmm2ext/window_title.h>
  39
  40 #include "ardour/debug.h"
  41 #include "ardour/midi_track.h"
  42 #include "ardour/plugin_manager.h"
  43 #include "ardour/route_group.h"
  44 #include "ardour/session.h"
  45
  46 #include "keyboard.h"
  47 #include "mixer_ui.h"
  48 #include "mixer_strip.h"
  49 #include "monitor_section.h"
  50 #include "plugin_selector.h"
  51 #include "public_editor.h"
  52 #include "ardour_ui.h"
  53 #include "prompter.h"
  54 #include "utils.h"
  55 #include "route_sorter.h"
  56 #include "actions.h"
  57 #include "gui_thread.h"
  58 #include "mixer_group_tabs.h"
  59
  60 #include "i18n.h"
  61
  62 using namespace ARDOUR;
  63 using namespace PBD;
  64 using namespace Gtk;
  65 using namespace Glib;
  66 using namespace Gtkmm2ext;
  67 using namespace std;
  68
  69 using PBD::atoi;
  70 using PBD::Unwinder;
  71
  72 Mixer_UI* Mixer_UI::_instance = 0;
  73
  74 Mixer_UI*
  75 Mixer_UI::instance ()
  76 {
  77         if (!_instance) {
  78                 _instance  = new Mixer_UI;
  79         }
  80
  81         return _instance;
  82 }
  83
  84 Mixer_UI::Mixer_UI ()
  85         : Window (Gtk::WINDOW_TOPLEVEL)
  86         , VisibilityTracker (*((Gtk::Window*) this))
  87         , _visible (false)
  88         , no_track_list_redisplay (false)
  89         , in_group_row_change (false)
  90         , track_menu (0)
  91         , _monitor_section (0)
  92         , _strip_width (Config->get_default_narrow_ms() ? Narrow : Wide)
  93         , ignore_reorder (false)
  94         , _following_editor_selection (false)
  95 {
  96         /* allow this window to become the key focus window */
  97         set_flags (CAN_FOCUS);
  98
  99         Route::SyncOrderKeys.connect (*this, invalidator (*this), boost::bind (&Mixer_UI::sync_treeview_from_order_keys, this, _1), gui_context());
 100
 101         scroller.set_can_default (true);
 102         set_default (scroller);
 103
 104         scroller_base.set_flags (Gtk::CAN_FOCUS);
 105         scroller_base.add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
 106         scroller_base.set_name ("MixerWindow");
 107         scroller_base.signal_button_release_event().connect (sigc::mem_fun(*this, &Mixer_UI::strip_scroller_button_release));
 108         // add as last item of strip packer
 109         strip_packer.pack_end (scroller_base, true, true);
 110
 111         _group_tabs = new MixerGroupTabs (this);
 112         VBox* b = manage (new VBox);
 113         b->pack_start (*_group_tabs, PACK_SHRINK);
 114         b->pack_start (strip_packer);
 115         b->show_all ();
 116
 117         scroller.add (*b);
 118         scroller.set_policy (Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
 119
 120         setup_track_display ();
 121
 122         group_model = ListStore::create (group_columns);
 123         group_display.set_model (group_model);
 124         group_display.append_column (_("Group"), group_columns.text);
 125         group_display.append_column (_("Show"), group_columns.visible);
 126         group_display.get_column (0)->set_data (X_("colnum"), GUINT_TO_POINTER(0));
 127         group_display.get_column (1)->set_data (X_("colnum"), GUINT_TO_POINTER(1));
 128         group_display.get_column (0)->set_expand(true);
 129         group_display.get_column (1)->set_expand(false);
 130         group_display.set_name ("EditGroupList");
 131         group_display.get_selection()->set_mode (Gtk::SELECTION_SINGLE);
 132         group_display.set_reorderable (true);
 133         group_display.set_headers_visible (true);
 134         group_display.set_rules_hint (true);
 135
 136         /* name is directly editable */
 137
 138         CellRendererText* name_cell = dynamic_cast<CellRendererText*>(group_display.get_column_cell_renderer (0));
 139         name_cell->property_editable() = true;
 140         name_cell->signal_edited().connect (sigc::mem_fun (*this, &Mixer_UI::route_group_name_edit));
 141
 142         /* use checkbox for the active column */
 143
 144         CellRendererToggle* active_cell = dynamic_cast<CellRendererToggle*>(group_display.get_column_cell_renderer (1));
 145         active_cell->property_activatable() = true;
 146         active_cell->property_radio() = false;
 147
 148         group_model->signal_row_changed().connect (sigc::mem_fun (*this, &Mixer_UI::route_group_row_change));
 149         /* We use this to notice drag-and-drop reorders of the group list */
 150         group_model->signal_row_deleted().connect (sigc::mem_fun (*this, &Mixer_UI::route_group_row_deleted));
 151         group_display.signal_button_press_event().connect (sigc::mem_fun (*this, &Mixer_UI::group_display_button_press), false);
 152
 153         group_display_scroller.add (group_display);
 154         group_display_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
 155
 156         HBox* route_group_display_button_box = manage (new HBox());
 157
 158         Button* route_group_add_button = manage (new Button ());
 159         Button* route_group_remove_button = manage (new Button ());
 160
 161         Widget* w;
 162
 163         w = manage (new Image (Stock::ADD, ICON_SIZE_BUTTON));
 164         w->show();
 165         route_group_add_button->add (*w);
 166
 167         w = manage (new Image (Stock::REMOVE, ICON_SIZE_BUTTON));
 168         w->show();
 169         route_group_remove_button->add (*w);
 170
 171         route_group_display_button_box->set_homogeneous (true);
 172
 173         route_group_add_button->signal_clicked().connect (sigc::mem_fun (*this, &Mixer_UI::new_route_group));
 174         route_group_remove_button->signal_clicked().connect (sigc::mem_fun (*this, &Mixer_UI::remove_selected_route_group));
 175
 176         route_group_display_button_box->add (*route_group_add_button);
 177         route_group_display_button_box->add (*route_group_remove_button);
 178
 179         group_display_vbox.pack_start (group_display_scroller, true, true);
 180         group_display_vbox.pack_start (*route_group_display_button_box, false, false);
 181
 182         group_display_frame.set_name ("BaseFrame");
 183         group_display_frame.set_shadow_type (Gtk::SHADOW_IN);
 184         group_display_frame.add (group_display_vbox);
 185
 186         rhs_pane1.pack1 (track_display_frame);
 187         rhs_pane1.pack2 (group_display_frame);
 188
 189         list_vpacker.pack_start (rhs_pane1, true, true);
 190
 191         global_hpacker.pack_start (scroller, true, true);
 192 #ifdef GTKOSX
 193         /* current gtk-quartz has dirty updates on borders like this one */
 194         global_hpacker.pack_start (out_packer, false, false, 0);
 195 #else
 196         global_hpacker.pack_start (out_packer, false, false, 12);
 197 #endif
 198         list_hpane.pack1(list_vpacker, true, true);
 199         list_hpane.pack2(global_hpacker, true, false);
 200
 201         rhs_pane1.signal_size_allocate().connect (sigc::bind (sigc::mem_fun(*this, &Mixer_UI::pane_allocation_handler),
 202                                                         static_cast<Gtk::Paned*> (&rhs_pane1)));
 203         list_hpane.signal_size_allocate().connect (sigc::bind (sigc::mem_fun(*this, &Mixer_UI::pane_allocation_handler),
 204                                                          static_cast<Gtk::Paned*> (&list_hpane)));
 205
 206         global_vpacker.pack_start (list_hpane, true, true);
 207
 208         add (global_vpacker);
 209         set_name ("MixerWindow");
 210
 211         update_title ();
 212
 213         set_wmclass (X_("ardour_mixer"), PROGRAM_NAME);
 214
 215         signal_delete_event().connect (sigc::mem_fun (*this, &Mixer_UI::hide_window));
 216         add_events (Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK);
 217
 218         signal_configure_event().connect (sigc::mem_fun (*ARDOUR_UI::instance(), &ARDOUR_UI::configure_handler));
 219
 220         route_group_display_button_box->show();
 221         route_group_add_button->show();
 222         route_group_remove_button->show();
 223
 224         global_hpacker.show();
 225         global_vpacker.show();
 226         scroller.show();
 227         scroller_base.show();
 228         scroller_hpacker.show();
 229         mixer_scroller_vpacker.show();
 230         list_vpacker.show();
 231         group_display_button_label.show();
 232         group_display_button.show();
 233         group_display_scroller.show();
 234         group_display_vbox.show();
 235         group_display_frame.show();
 236         rhs_pane1.show();
 237         strip_packer.show();
 238         out_packer.show();
 239         list_hpane.show();
 240         group_display.show();
 241
 242         _in_group_rebuild_or_clear = false;
 243
 244         MixerStrip::CatchDeletion.connect (*this, invalidator (*this), boost::bind (&Mixer_UI::remove_strip, this, _1), gui_context());
 245
 246         MonitorSection::setup_knob_images ();
 247
 248 #ifndef DEFER_PLUGIN_SELECTOR_LOAD
 249         _plugin_selector = new PluginSelector (PluginManager::instance ());
 250 #endif
 251 }
 252
 253 Mixer_UI::~Mixer_UI ()
 254 {
 255         if (_monitor_section) {
 256                 delete _monitor_section;
 257         }
 258 }
 259
 260 void
 261 Mixer_UI::track_editor_selection ()
 262 {
 263         PublicEditor::instance().get_selection().TracksChanged.connect (sigc::mem_fun (*this, &Mixer_UI::follow_editor_selection));
 264 }
 265
 266
 267 void
 268 Mixer_UI::ensure_float (Window& win)
 269 {
 270         win.set_transient_for (*this);
 271 }
 272
 273 void
 274 Mixer_UI::show_window ()
 275 {
 276         present ();
 277         if (!_visible) {
 278                 set_window_pos_and_size ();
 279
 280                 /* show/hide group tabs as required */
 281                 parameter_changed ("show-group-tabs");
 282
 283                 /* now reset each strips width so the right widgets are shown */
 284                 MixerStrip* ms;
 285
 286                 TreeModel::Children rows = track_model->children();
 287                 TreeModel::Children::iterator ri;
 288
 289                 for (ri = rows.begin(); ri != rows.end(); ++ri) {
 290                         ms = (*ri)[track_columns.strip];
 291                         ms->set_width_enum (ms->get_width_enum (), ms->width_owner());
 292                         /* Fix visibility of mixer strip stuff */
 293                         ms->parameter_changed (X_("mixer-strip-visibility"));
 294                 }
 295         }
 296
 297         /* force focus into main area */
 298         scroller_base.grab_focus ();
 299
 300         _visible = true;
 301 }
 302
 303 bool
 304 Mixer_UI::hide_window (GdkEventAny *ev)
 305 {
 306         get_window_pos_and_size ();
 307
 308         _visible = false;
 309         return just_hide_it(ev, static_cast<Gtk::Window *>(this));
 310 }
 311
 312
 313 void
 314 Mixer_UI::add_strips (RouteList& routes)
 315 {
 316         MixerStrip* strip;
 317
 318         try {
 319                 no_track_list_redisplay = true;
 320                 track_display.set_model (Glib::RefPtr<ListStore>());
 321
 322                 for (RouteList::iterator x = routes.begin(); x != routes.end(); ++x) {
 323                         boost::shared_ptr<Route> route = (*x);
 324
 325                         if (route->is_auditioner()) {
 326                                 continue;
 327                         }
 328
 329                         if (route->is_monitor()) {
 330
 331                                 if (!_monitor_section) {
 332                                         _monitor_section = new MonitorSection (_session);
 333
 334                                         XMLNode* mnode = ARDOUR_UI::instance()->tearoff_settings (X_("monitor-section"));
 335                                         if (mnode) {
 336                                                 _monitor_section->tearoff().set_state (*mnode);
 337                                         }
 338                                 }
 339
 340                                 out_packer.pack_end (_monitor_section->tearoff(), false, false);
 341                                 _monitor_section->set_session (_session);
 342                                 _monitor_section->tearoff().show_all ();
 343
 344                                 route->DropReferences.connect (*this, invalidator(*this), boost::bind (&Mixer_UI::monitor_section_going_away, this), gui_context());
 345
 346                                 /* no regular strip shown for control out */
 347
 348                                 continue;
 349                         }
 350
 351                         strip = new MixerStrip (*this, _session, route);
 352                         strips.push_back (strip);
 353
 354                         Config->get_default_narrow_ms() ? _strip_width = Narrow : _strip_width = Wide;
 355
 356                         if (strip->width_owner() != strip) {
 357                                 strip->set_width_enum (_strip_width, this);
 358                         }
 359
 360                         show_strip (strip);
 361
 362                         TreeModel::Row row = *(track_model->append());
 363                         row[track_columns.text] = route->name();
 364                         row[track_columns.visible] = strip->route()->is_master() ? true : strip->marked_for_display();
 365                         row[track_columns.route] = route;
 366                         row[track_columns.strip] = strip;
 367
 368                         route->PropertyChanged.connect (*this, invalidator (*this), boost::bind (&Mixer_UI::strip_property_changed, this, _1, strip), gui_context());
 369
 370                         strip->WidthChanged.connect (sigc::mem_fun(*this, &Mixer_UI::strip_width_changed));
 371                         strip->signal_button_release_event().connect (sigc::bind (sigc::mem_fun(*this, &Mixer_UI::strip_button_release_event), strip));
 372                 }
 373
 374         } catch (...) {
 375         }
 376
 377         no_track_list_redisplay = false;
 378         track_display.set_model (track_model);
 379
 380         sync_order_keys_from_treeview ();
 381         redisplay_track_list ();
 382 }
 383
 384 void
 385 Mixer_UI::remove_strip (MixerStrip* strip)
 386 {
 387         if (_session && _session->deletion_in_progress()) {
 388                 /* its all being taken care of */
 389                 return;
 390         }
 391
 392         TreeModel::Children rows = track_model->children();
 393         TreeModel::Children::iterator ri;
 394         list<MixerStrip *>::iterator i;
 395
 396         if ((i = find (strips.begin(), strips.end(), strip)) != strips.end()) {
 397                 strips.erase (i);
 398         }
 399
 400         for (ri = rows.begin(); ri != rows.end(); ++ri) {
 401                 if ((*ri)[track_columns.strip] == strip) {
 402                         track_model->erase (ri);
 403                         break;
 404                 }
 405         }
 406 }
 407
 408 void
 409 Mixer_UI::reset_remote_control_ids ()
 410 {
 411         if (Config->get_remote_model() != MixerOrdered || !_session || _session->deletion_in_progress()) {
 412                 return;
 413         }
 414
 415         TreeModel::Children rows = track_model->children();
 416
 417         if (rows.empty()) {
 418                 return;
 419         }
 420
 421         DEBUG_TRACE (DEBUG::OrderKeys, "mixer resets remote control ids after remote model change\n");
 422
 423         TreeModel::Children::iterator ri;
 424         bool rid_change = false;
 425         uint32_t rid = 1;
 426         uint32_t invisible_key = UINT32_MAX;
 427
 428         for (ri = rows.begin(); ri != rows.end(); ++ri) {
 429                 boost::shared_ptr<Route> route = (*ri)[track_columns.route];
 430                 bool visible = (*ri)[track_columns.visible];
 431
 432                 if (!route->is_master() && !route->is_monitor()) {
 433
 434                         uint32_t new_rid = (visible ? rid : invisible_key--);
 435
 436                         if (new_rid != route->remote_control_id()) {
 437                                 route->set_remote_control_id_from_order_key (MixerSort, new_rid);
 438                                 rid_change = true;
 439                         }
 440
 441                         if (visible) {
 442                                 rid++;
 443                         }
 444                 }
 445         }
 446
 447         if (rid_change) {
 448                 /* tell the world that we changed the remote control IDs */
 449                 _session->notify_remote_id_change ();
 450         }
 451 }
 452
 453 void
 454 Mixer_UI::sync_order_keys_from_treeview ()
 455 {
 456         if (ignore_reorder || !_session || _session->deletion_in_progress()) {
 457                 return;
 458         }
 459
 460         TreeModel::Children rows = track_model->children();
 461
 462         if (rows.empty()) {
 463                 return;
 464         }
 465
 466         DEBUG_TRACE (DEBUG::OrderKeys, "mixer sync order keys from model\n");
 467
 468         TreeModel::Children::iterator ri;
 469         bool changed = false;
 470         bool rid_change = false;
 471         uint32_t order = 0;
 472         uint32_t rid = 1;
 473         uint32_t invisible_key = UINT32_MAX;
 474
 475         for (ri = rows.begin(); ri != rows.end(); ++ri) {
 476                 boost::shared_ptr<Route> route = (*ri)[track_columns.route];
 477                 bool visible = (*ri)[track_columns.visible];
 478
 479                 uint32_t old_key = route->order_key (MixerSort);
 480
 481                 if (order != old_key) {
 482                         route->set_order_key (MixerSort, order);
 483                         changed = true;
 484                 }
 485
 486                 if ((Config->get_remote_model() == MixerOrdered) && !route->is_master() && !route->is_monitor()) {
 487
 488                         uint32_t new_rid = (visible ? rid : invisible_key--);
 489
 490                         if (new_rid != route->remote_control_id()) {
 491                                 route->set_remote_control_id_from_order_key (MixerSort, new_rid);
 492                                 rid_change = true;
 493                         }
 494
 495                         if (visible) {
 496                                 rid++;
 497                         }
 498
 499                 }
 500
 501                 ++order;
 502         }
 503
 504         if (changed) {
 505                 /* tell everyone that we changed the mixer sort keys */
 506                 _session->sync_order_keys (MixerSort);
 507         }
 508
 509         if (rid_change) {
 510                 /* tell the world that we changed the remote control IDs */
 511                 _session->notify_remote_id_change ();
 512         }
 513 }
 514
 515 void
 516 Mixer_UI::sync_treeview_from_order_keys (RouteSortOrderKey src)
 517 {
 518         if (!_session || _session->deletion_in_progress()) {
 519                 return;
 520         }
 521
 522         DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("mixer sync model from order keys, src = %1\n", enum_2_string (src)));
 523
 524         if (src == EditorSort) {
 525
 526                 if (!Config->get_sync_all_route_ordering()) {
 527                         /* editor sort keys changed - we don't care */
 528                         return;
 529                 }
 530
 531                 DEBUG_TRACE (DEBUG::OrderKeys, "reset mixer order key to match editor\n");
 532
 533                 /* editor sort keys were changed, update the mixer sort
 534                  * keys since "sync mixer+editor order" is enabled.
 535                  */
 536
 537                 boost::shared_ptr<RouteList> r = _session->get_routes ();
 538
 539                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 540                         (*i)->sync_order_keys (src);
 541                 }
 542         }
 543
 544         /* we could get here after either a change in the Mixer or Editor sort
 545          * order, but either way, the mixer order keys reflect the intended
 546          * order for the GUI, so reorder the treeview model to match it.
 547          */
 548
 549         vector<int> neworder;
 550         TreeModel::Children rows = track_model->children();
 551         uint32_t old_order = 0;
 552         bool changed = false;
 553
 554         if (rows.empty()) {
 555                 return;
 556         }
 557
 558         OrderKeySortedRoutes sorted_routes;
 559
 560         for (TreeModel::Children::iterator ri = rows.begin(); ri != rows.end(); ++ri, ++old_order) {
 561                 boost::shared_ptr<Route> route = (*ri)[track_columns.route];
 562                 sorted_routes.push_back (RoutePlusOrderKey (route, old_order, route->order_key (MixerSort)));
 563         }
 564
 565         SortByNewDisplayOrder cmp;
 566
 567         sort (sorted_routes.begin(), sorted_routes.end(), cmp);
 568         neworder.assign (sorted_routes.size(), 0);
 569
 570         uint32_t n = 0;
 571
 572         for (OrderKeySortedRoutes::iterator sr = sorted_routes.begin(); sr != sorted_routes.end(); ++sr, ++n) {
 573
 574                 neworder[n] = sr->old_display_order;
 575
 576                 if (sr->old_display_order != n) {
 577                         changed = true;
 578                 }
 579
 580                 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("MIXER change order for %1 from %2 to %3\n",
 581                                                                sr->route->name(), sr->old_display_order, n));
 582         }
 583
 584         if (changed) {
 585                 Unwinder<bool> uw (ignore_reorder, true);
 586                 track_model->reorder (neworder);
 587         }
 588
 589         redisplay_track_list ();
 590 }
 591
 592 void
 593 Mixer_UI::follow_editor_selection ()
 594 {
 595         if (!Config->get_link_editor_and_mixer_selection() || _following_editor_selection) {
 596                 return;
 597         }
 598
 599         _following_editor_selection = true;
 600         _selection.block_routes_changed (true);
 601
 602         TrackSelection& s (PublicEditor::instance().get_selection().tracks);
 603
 604         _selection.clear_routes ();
 605
 606         for (TrackViewList::iterator i = s.begin(); i != s.end(); ++i) {
 607                 RouteTimeAxisView* rtav = dynamic_cast<RouteTimeAxisView*> (*i);
 608                 if (rtav) {
 609                         MixerStrip* ms = strip_by_route (rtav->route());
 610                         if (ms) {
 611                                 _selection.add (ms);
 612                         }
 613                 }
 614         }
 615
 616         _following_editor_selection = false;
 617         _selection.block_routes_changed (false);
 618 }
 619
 620
 621 MixerStrip*
 622 Mixer_UI::strip_by_route (boost::shared_ptr<Route> r)
 623 {
 624         for (list<MixerStrip *>::iterator i = strips.begin(); i != strips.end(); ++i) {
 625                 if ((*i)->route() == r) {
 626                         return (*i);
 627                 }
 628         }
 629
 630         return 0;
 631 }
 632
 633 bool
 634 Mixer_UI::strip_button_release_event (GdkEventButton *ev, MixerStrip *strip)
 635 {
 636         if (ev->button == 1) {
 637                 if (_selection.selected (strip)) {
 638                         /* primary-click: toggle selection state of strip */
 639                         if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
 640                                 _selection.remove (strip);
 641                         }
 642                 } else {
 643                         if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
 644                                 _selection.add (strip);
 645                         } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::RangeSelectModifier)) {
 646
 647                                 if (!_selection.selected(strip)) {
 648
 649                                         /* extend selection */
 650
 651                                         vector<MixerStrip*> tmp;
 652                                         bool accumulate = false;
 653
 654                                         tmp.push_back (strip);
 655
 656                                         for (list<MixerStrip*>::iterator i = strips.begin(); i != strips.end(); ++i) {
 657                                                 if ((*i) == strip) {
 658                                                         /* hit clicked strip, start accumulating till we hit the first
 659                                                            selected strip
 660                                                         */
 661                                                         if (accumulate) {
 662                                                                 /* done */
 663                                                                 break;
 664                                                         } else {
 665                                                                 accumulate = true;
 666                                                         }
 667                                                 } else if (_selection.selected (*i)) {
 668                                                         /* hit selected strip. if currently accumulating others,
 669                                                            we're done. if not accumulating others, start doing so.
 670                                                         */
 671                                                         if (accumulate) {
 672                                                                 /* done */
 673                                                                 break;
 674                                                         } else {
 675                                                                 accumulate = true;
 676                                                         }
 677                                                 } else {
 678                                                         if (accumulate) {
 679                                                                 tmp.push_back (*i);
 680                                                         }
 681                                                 }
 682                                         }
 683
 684                                         for (vector<MixerStrip*>::iterator i = tmp.begin(); i != tmp.end(); ++i) {
 685                                                 _selection.add (*i);
 686                                         }
 687                                 }
 688
 689                         } else {
 690                                 _selection.set (strip);
 691                         }
 692                 }
 693         }
 694
 695         return true;
 696 }
 697
 698 void
 699 Mixer_UI::set_session (Session* sess)
 700 {
 701         SessionHandlePtr::set_session (sess);
 702
 703         if (_plugin_selector) {
 704                 _plugin_selector->set_session (_session);
 705         }
 706
 707         _group_tabs->set_session (sess);
 708
 709         if (!_session) {
 710                 return;
 711         }
 712
 713         XMLNode* node = ARDOUR_UI::instance()->mixer_settings();
 714         set_state (*node);
 715
 716         update_title ();
 717
 718         initial_track_display ();
 719
 720         _session->RouteAdded.connect (_session_connections, invalidator (*this), boost::bind (&Mixer_UI::add_strips, this, _1), gui_context());
 721         _session->route_group_added.connect (_session_connections, invalidator (*this), boost::bind (&Mixer_UI::add_route_group, this, _1), gui_context());
 722         _session->route_group_removed.connect (_session_connections, invalidator (*this), boost::bind (&Mixer_UI::route_groups_changed, this), gui_context());
 723         _session->route_groups_reordered.connect (_session_connections, invalidator (*this), boost::bind (&Mixer_UI::route_groups_changed, this), gui_context());
 724         _session->config.ParameterChanged.connect (_session_connections, invalidator (*this), boost::bind (&Mixer_UI::parameter_changed, this, _1), gui_context());
 725         _session->DirtyChanged.connect (_session_connections, invalidator (*this), boost::bind (&Mixer_UI::update_title, this), gui_context());
 726         _session->StateSaved.connect (_session_connections, invalidator (*this), boost::bind (&Mixer_UI::update_title, this), gui_context());
 727
 728         Config->ParameterChanged.connect (*this, invalidator (*this), boost::bind (&Mixer_UI::parameter_changed, this, _1), gui_context ());
 729
 730         route_groups_changed ();
 731
 732         if (_visible) {
 733                 show_window();
 734
 735                 /* Bit of a hack; if we're here, we're opening the mixer because of our
 736                    instant XML state having a show-mixer property.  Fix up the corresponding
 737                    action state.
 738                 */
 739                 ActionManager::check_toggleaction ("<Actions>/Common/toggle-mixer");
 740         }
 741
 742         start_updating ();
 743 }
 744
 745 void
 746 Mixer_UI::session_going_away ()
 747 {
 748         ENSURE_GUI_THREAD (*this, &Mixer_UI::session_going_away);
 749
 750         _in_group_rebuild_or_clear = true;
 751         group_model->clear ();
 752         _in_group_rebuild_or_clear = false;
 753
 754         _selection.clear ();
 755         track_model->clear ();
 756
 757         for (list<MixerStrip *>::iterator i = strips.begin(); i != strips.end(); ++i) {
 758                 delete (*i);
 759         }
 760
 761         if (_monitor_section) {
 762                 _monitor_section->tearoff().hide_visible ();
 763         }
 764
 765         strips.clear ();
 766
 767         stop_updating ();
 768
 769         SessionHandlePtr::session_going_away ();
 770
 771         _session = 0;
 772         update_title ();
 773 }
 774
 775 void
 776 Mixer_UI::track_visibility_changed (std::string const & path)
 777 {
 778         if (_session && _session->deletion_in_progress()) {
 779                 return;
 780         }
 781
 782         TreeIter iter;
 783
 784         if ((iter = track_model->get_iter (path))) {
 785                 MixerStrip* strip = (*iter)[track_columns.strip];
 786                 if (strip) {
 787                         bool visible = (*iter)[track_columns.visible];
 788
 789                         if (strip->set_marked_for_display (!visible)) {
 790                                 update_track_visibility ();
 791                         }
 792                 }
 793         }
 794 }
 795
 796 void
 797 Mixer_UI::update_track_visibility ()
 798 {
 799         TreeModel::Children rows = track_model->children();
 800         TreeModel::Children::iterator i;
 801
 802         {
 803                 Unwinder<bool> uw (no_track_list_redisplay, true);
 804
 805                 for (i = rows.begin(); i != rows.end(); ++i) {
 806                         MixerStrip *strip = (*i)[track_columns.strip];
 807                         (*i)[track_columns.visible] = strip->marked_for_display ();
 808                 }
 809
 810                 /* force route order keys catch up with visibility changes
 811                  */
 812
 813                 sync_order_keys_from_treeview ();
 814         }
 815
 816         redisplay_track_list ();
 817 }
 818
 819 void
 820 Mixer_UI::show_strip (MixerStrip* ms)
 821 {
 822         TreeModel::Children rows = track_model->children();
 823         TreeModel::Children::iterator i;
 824
 825         for (i = rows.begin(); i != rows.end(); ++i) {
 826
 827                 MixerStrip* strip = (*i)[track_columns.strip];
 828                 if (strip == ms) {
 829                         (*i)[track_columns.visible] = true;
 830                         redisplay_track_list ();
 831                         break;
 832                 }
 833         }
 834 }
 835
 836 void
 837 Mixer_UI::hide_strip (MixerStrip* ms)
 838 {
 839         TreeModel::Children rows = track_model->children();
 840         TreeModel::Children::iterator i;
 841
 842         for (i = rows.begin(); i != rows.end(); ++i) {
 843
 844                 MixerStrip* strip = (*i)[track_columns.strip];
 845                 if (strip == ms) {
 846                         (*i)[track_columns.visible] = false;
 847                         redisplay_track_list ();
 848                         break;
 849                 }
 850         }
 851 }
 852
 853 gint
 854 Mixer_UI::start_updating ()
 855 {
 856     fast_screen_update_connection = ARDOUR_UI::instance()->SuperRapidScreenUpdate.connect (sigc::mem_fun(*this, &Mixer_UI::fast_update_strips));
 857     return 0;
 858 }
 859
 860 gint
 861 Mixer_UI::stop_updating ()
 862 {
 863     fast_screen_update_connection.disconnect();
 864     return 0;
 865 }
 866
 867 void
 868 Mixer_UI::fast_update_strips ()
 869 {
 870         if (is_mapped () && _session) {
 871                 for (list<MixerStrip *>::iterator i = strips.begin(); i != strips.end(); ++i) {
 872                         (*i)->fast_update ();
 873                 }
 874         }
 875 }
 876
 877 void
 878 Mixer_UI::set_all_strips_visibility (bool yn)
 879 {
 880         TreeModel::Children rows = track_model->children();
 881         TreeModel::Children::iterator i;
 882
 883         {
 884                 Unwinder<bool> uw (no_track_list_redisplay, true);
 885
 886                 for (i = rows.begin(); i != rows.end(); ++i) {
 887
 888                         TreeModel::Row row = (*i);
 889                         MixerStrip* strip = row[track_columns.strip];
 890
 891                         if (strip == 0) {
 892                                 continue;
 893                         }
 894
 895                         if (strip->route()->is_master() || strip->route()->is_monitor()) {
 896                                 continue;
 897                         }
 898
 899                         (*i)[track_columns.visible] = yn;
 900                 }
 901         }
 902
 903         redisplay_track_list ();
 904 }
 905
 906
 907 void
 908 Mixer_UI::set_all_audio_visibility (int tracks, bool yn)
 909 {
 910         TreeModel::Children rows = track_model->children();
 911         TreeModel::Children::iterator i;
 912
 913         {
 914                 Unwinder<bool> uw (no_track_list_redisplay, true);
 915
 916                 for (i = rows.begin(); i != rows.end(); ++i) {
 917                         TreeModel::Row row = (*i);
 918                         MixerStrip* strip = row[track_columns.strip];
 919
 920                         if (strip == 0) {
 921                                 continue;
 922                         }
 923
 924                         if (strip->route()->is_master() || strip->route()->is_monitor()) {
 925                                 continue;
 926                         }
 927
 928                         boost::shared_ptr<AudioTrack> at = strip->audio_track();
 929
 930                         switch (tracks) {
 931                         case 0:
 932                                 (*i)[track_columns.visible] = yn;
 933                                 break;
 934
 935                         case 1:
 936                                 if (at) { /* track */
 937                                         (*i)[track_columns.visible] = yn;
 938                                 }
 939                                 break;
 940
 941                         case 2:
 942                                 if (!at) { /* bus */
 943                                         (*i)[track_columns.visible] = yn;
 944                                 }
 945                                 break;
 946                         }
 947                 }
 948         }
 949
 950         redisplay_track_list ();
 951 }
 952
 953 void
 954 Mixer_UI::hide_all_routes ()
 955 {
 956         set_all_strips_visibility (false);
 957 }
 958
 959 void
 960 Mixer_UI::show_all_routes ()
 961 {
 962         set_all_strips_visibility (true);
 963 }
 964
 965 void
 966 Mixer_UI::show_all_audiobus ()
 967 {
 968         set_all_audio_visibility (2, true);
 969 }
 970 void
 971 Mixer_UI::hide_all_audiobus ()
 972 {
 973         set_all_audio_visibility (2, false);
 974 }
 975
 976 void
 977 Mixer_UI::show_all_audiotracks()
 978 {
 979         set_all_audio_visibility (1, true);
 980 }
 981 void
 982 Mixer_UI::hide_all_audiotracks ()
 983 {
 984         set_all_audio_visibility (1, false);
 985 }
 986
 987 void
 988 Mixer_UI::track_list_reorder (const TreeModel::Path&, const TreeModel::iterator&, int* /*new_order*/)
 989 {
 990         DEBUG_TRACE (DEBUG::OrderKeys, "mixer UI treeview reordered\n");
 991         sync_order_keys_from_treeview ();
 992 }
 993
 994 void
 995 Mixer_UI::track_list_delete (const Gtk::TreeModel::Path&)
 996 {
 997         /* this happens as the second step of a DnD within the treeview as well
 998            as when a row/route is actually deleted.
 999         */
1000         DEBUG_TRACE (DEBUG::OrderKeys, "mixer UI treeview row deleted\n");
1001         sync_order_keys_from_treeview ();
1002 }
1003
1004 void
1005 Mixer_UI::redisplay_track_list ()
1006 {
1007         TreeModel::Children rows = track_model->children();
1008         TreeModel::Children::iterator i;
1009
1010         if (no_track_list_redisplay) {
1011                 return;
1012         }
1013
1014         for (i = rows.begin(); i != rows.end(); ++i) {
1015
1016                 MixerStrip* strip = (*i)[track_columns.strip];
1017
1018                 if (strip == 0) {
1019                         /* we're in the middle of changing a row, don't worry */
1020                         continue;
1021                 }
1022
1023                 bool const visible = (*i)[track_columns.visible];
1024
1025                 if (visible) {
1026                         strip->set_gui_property ("visible", true);
1027
1028                         if (strip->packed()) {
1029
1030                                 if (strip->route()->is_master() || strip->route()->is_monitor()) {
1031                                         out_packer.reorder_child (*strip, -1);
1032
1033                                 } else {
1034                                         strip_packer.reorder_child (*strip, -1); /* put at end */
1035                                 }
1036
1037                         } else {
1038
1039                                 if (strip->route()->is_master() || strip->route()->is_monitor()) {
1040                                         out_packer.pack_start (*strip, false, false);
1041                                 } else {
1042                                         strip_packer.pack_start (*strip, false, false);
1043                                 }
1044                                 strip->set_packed (true);
1045                         }
1046
1047                 } else {
1048
1049                         strip->set_gui_property ("visible", false);
1050
1051                         if (strip->route()->is_master() || strip->route()->is_monitor()) {
1052                                 /* do nothing, these cannot be hidden */
1053                         } else {
1054                                 if (strip->packed()) {
1055                                         strip_packer.remove (*strip);
1056                                         strip->set_packed (false);
1057                                 }
1058                         }
1059                 }
1060         }
1061
1062         _group_tabs->set_dirty ();
1063 }
1064
1065 void
1066 Mixer_UI::strip_width_changed ()
1067 {
1068         _group_tabs->set_dirty ();
1069
1070 #ifdef GTKOSX
1071         TreeModel::Children rows = track_model->children();
1072         TreeModel::Children::iterator i;
1073         long order;
1074
1075         for (order = 0, i = rows.begin(); i != rows.end(); ++i, ++order) {
1076                 MixerStrip* strip = (*i)[track_columns.strip];
1077
1078                 if (strip == 0) {
1079                         continue;
1080                 }
1081
1082                 bool visible = (*i)[track_columns.visible];
1083
1084                 if (visible) {
1085                         strip->queue_draw();
1086                 }
1087         }
1088 #endif
1089
1090 }
1091
1092 struct SignalOrderRouteSorter {
1093     bool operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b) {
1094             if (a->is_master() || a->is_monitor()) {
1095                     /* "a" is a special route (master, monitor, etc), and comes
1096                      * last in the mixer ordering
1097                      */
1098                     return false;
1099             } else if (b->is_master() || b->is_monitor()) {
1100                     /* everything comes before b */
1101                     return true;
1102             }
1103             return a->order_key (MixerSort) < b->order_key (MixerSort);
1104
1105     }
1106 };
1107
1108 void
1109 Mixer_UI::initial_track_display ()
1110 {
1111         boost::shared_ptr<RouteList> routes = _session->get_routes();
1112         RouteList copy (*routes);
1113         SignalOrderRouteSorter sorter;
1114
1115         copy.sort (sorter);
1116
1117         {
1118                 Unwinder<bool> uw1 (no_track_list_redisplay, true);
1119                 Unwinder<bool> uw2 (ignore_reorder, true);
1120
1121                 track_model->clear ();
1122                 add_strips (copy);
1123         }
1124
1125         _session->sync_order_keys (MixerSort);
1126
1127         redisplay_track_list ();
1128 }
1129
1130 void
1131 Mixer_UI::show_track_list_menu ()
1132 {
1133         if (track_menu == 0) {
1134                 build_track_menu ();
1135         }
1136
1137         track_menu->popup (1, gtk_get_current_event_time());
1138 }
1139
1140 bool
1141 Mixer_UI::track_display_button_press (GdkEventButton* ev)
1142 {
1143         if (Keyboard::is_context_menu_event (ev)) {
1144                 show_track_list_menu ();
1145                 return true;
1146         }
1147
1148         return false;
1149 }
1150
1151 void
1152 Mixer_UI::build_track_menu ()
1153 {
1154         using namespace Menu_Helpers;
1155         using namespace Gtk;
1156
1157         track_menu = new Menu;
1158         track_menu->set_name ("ArdourContextMenu");
1159         MenuList& items = track_menu->items();
1160
1161         items.push_back (MenuElem (_("Show All"), sigc::mem_fun(*this, &Mixer_UI::show_all_routes)));
1162         items.push_back (MenuElem (_("Hide All"), sigc::mem_fun(*this, &Mixer_UI::hide_all_routes)));
1163         items.push_back (MenuElem (_("Show All Audio Tracks"), sigc::mem_fun(*this, &Mixer_UI::show_all_audiotracks)));
1164         items.push_back (MenuElem (_("Hide All Audio Tracks"), sigc::mem_fun(*this, &Mixer_UI::hide_all_audiotracks)));
1165         items.push_back (MenuElem (_("Show All Audio Busses"), sigc::mem_fun(*this, &Mixer_UI::show_all_audiobus)));
1166         items.push_back (MenuElem (_("Hide All Audio Busses"), sigc::mem_fun(*this, &Mixer_UI::hide_all_audiobus)));
1167
1168 }
1169
1170 void
1171 Mixer_UI::strip_property_changed (const PropertyChange& what_changed, MixerStrip* mx)
1172 {
1173         if (!what_changed.contains (ARDOUR::Properties::name)) {
1174                 return;
1175         }
1176
1177         ENSURE_GUI_THREAD (*this, &Mixer_UI::strip_name_changed, what_changed, mx)
1178
1179         TreeModel::Children rows = track_model->children();
1180         TreeModel::Children::iterator i;
1181
1182         for (i = rows.begin(); i != rows.end(); ++i) {
1183                 if ((*i)[track_columns.strip] == mx) {
1184                         (*i)[track_columns.text] = mx->route()->name();
1185                         return;
1186                 }
1187         }
1188
1189         error << _("track display list item for renamed strip not found!") << endmsg;
1190 }
1191
1192 bool
1193 Mixer_UI::group_display_button_press (GdkEventButton* ev)
1194 {
1195         TreeModel::Path path;
1196         TreeViewColumn* column;
1197         int cellx;
1198         int celly;
1199
1200         if (!group_display.get_path_at_pos ((int)ev->x, (int)ev->y, path, column, cellx, celly)) {
1201                 return false;
1202         }
1203
1204         TreeIter iter = group_model->get_iter (path);
1205         if (!iter) {
1206                 return false;
1207         }
1208
1209         RouteGroup* group = (*iter)[group_columns.group];
1210
1211         if (Keyboard::is_context_menu_event (ev)) {
1212                 _group_tabs->get_menu(group)->popup (1, ev->time);
1213                 return true;
1214         }
1215
1216         switch (GPOINTER_TO_UINT (column->get_data (X_("colnum")))) {
1217         case 0:
1218                 if (Keyboard::is_edit_event (ev)) {
1219                         if (group) {
1220                                 // edit_route_group (group);
1221 #ifdef GTKOSX
1222                                 group_display.queue_draw();
1223 #endif
1224                                 return true;
1225                         }
1226                 }
1227                 break;
1228
1229         case 1:
1230         {
1231                 bool visible = (*iter)[group_columns.visible];
1232                 (*iter)[group_columns.visible] = !visible;
1233 #ifdef GTKOSX
1234                 group_display.queue_draw();
1235 #endif
1236                 return true;
1237         }
1238
1239         default:
1240                 break;
1241         }
1242
1243         return false;
1244  }
1245
1246 void
1247 Mixer_UI::activate_all_route_groups ()
1248 {
1249         _session->foreach_route_group (sigc::bind (sigc::mem_fun (*this, &Mixer_UI::set_route_group_activation), true));
1250 }
1251
1252 void
1253 Mixer_UI::disable_all_route_groups ()
1254 {
1255         _session->foreach_route_group (sigc::bind (sigc::mem_fun (*this, &Mixer_UI::set_route_group_activation), false));
1256 }
1257
1258 void
1259 Mixer_UI::route_groups_changed ()
1260 {
1261         ENSURE_GUI_THREAD (*this, &Mixer_UI::route_groups_changed);
1262
1263         _in_group_rebuild_or_clear = true;
1264
1265         /* just rebuild the while thing */
1266
1267         group_model->clear ();
1268
1269         {
1270                 TreeModel::Row row;
1271                 row = *(group_model->append());
1272                 row[group_columns.visible] = true;
1273                 row[group_columns.text] = (_("-all-"));
1274                 row[group_columns.group] = 0;
1275         }
1276
1277         _session->foreach_route_group (sigc::mem_fun (*this, &Mixer_UI::add_route_group));
1278
1279         _group_tabs->set_dirty ();
1280         _in_group_rebuild_or_clear = false;
1281 }
1282
1283 void
1284 Mixer_UI::new_route_group ()
1285 {
1286         RouteList rl;
1287
1288         _group_tabs->run_new_group_dialog (rl);
1289 }
1290
1291 void
1292 Mixer_UI::remove_selected_route_group ()
1293 {
1294         Glib::RefPtr<TreeSelection> selection = group_display.get_selection();
1295         TreeView::Selection::ListHandle_Path rows = selection->get_selected_rows ();
1296
1297         if (rows.empty()) {
1298                 return;
1299         }
1300
1301         TreeView::Selection::ListHandle_Path::iterator i = rows.begin();
1302         TreeIter iter;
1303
1304         /* selection mode is single, so rows.begin() is it */
1305
1306         if ((iter = group_model->get_iter (*i))) {
1307
1308                 RouteGroup* rg = (*iter)[group_columns.group];
1309
1310                 if (rg) {
1311                         _session->remove_route_group (*rg);
1312                 }
1313         }
1314 }
1315
1316 void
1317 Mixer_UI::route_group_property_changed (RouteGroup* group, const PropertyChange& change)
1318 {
1319         if (in_group_row_change) {
1320                 return;
1321         }
1322
1323         /* force an update of any mixer strips that are using this group,
1324            otherwise mix group names don't change in mixer strips
1325         */
1326
1327         for (list<MixerStrip *>::iterator i = strips.begin(); i != strips.end(); ++i) {
1328                 if ((*i)->route_group() == group) {
1329                         (*i)->route_group_changed();
1330                 }
1331         }
1332
1333         TreeModel::iterator i;
1334         TreeModel::Children rows = group_model->children();
1335         Glib::RefPtr<TreeSelection> selection = group_display.get_selection();
1336
1337         in_group_row_change = true;
1338
1339         for (i = rows.begin(); i != rows.end(); ++i) {
1340                 if ((*i)[group_columns.group] == group) {
1341                         (*i)[group_columns.visible] = !group->is_hidden ();
1342                         (*i)[group_columns.text] = group->name ();
1343                         break;
1344                 }
1345         }
1346
1347         in_group_row_change = false;
1348
1349         if (change.contains (Properties::name)) {
1350                 _group_tabs->set_dirty ();
1351         }
1352
1353         for (list<MixerStrip*>::iterator j = strips.begin(); j != strips.end(); ++j) {
1354                 if ((*j)->route_group() == group) {
1355                         if (group->is_hidden ()) {
1356                                 hide_strip (*j);
1357                         } else {
1358                                 show_strip (*j);
1359                         }
1360                 }
1361         }
1362 }
1363
1364 void
1365 Mixer_UI::route_group_name_edit (const std::string& path, const std::string& new_text)
1366 {
1367         RouteGroup* group;
1368         TreeIter iter;
1369
1370         if ((iter = group_model->get_iter (path))) {
1371
1372                 if ((group = (*iter)[group_columns.group]) == 0) {
1373                         return;
1374                 }
1375
1376                 if (new_text != group->name()) {
1377                         group->set_name (new_text);
1378                 }
1379         }
1380 }
1381
1382 void
1383 Mixer_UI::route_group_row_change (const Gtk::TreeModel::Path&, const Gtk::TreeModel::iterator& iter)
1384 {
1385         RouteGroup* group;
1386
1387         if (in_group_row_change) {
1388                 return;
1389         }
1390
1391         if ((group = (*iter)[group_columns.group]) == 0) {
1392                 return;
1393         }
1394
1395         std::string name = (*iter)[group_columns.text];
1396
1397         if (name != group->name()) {
1398                 group->set_name (name);
1399         }
1400
1401         bool hidden = !(*iter)[group_columns.visible];
1402
1403         if (hidden != group->is_hidden ()) {
1404                 group->set_hidden (hidden, this);
1405         }
1406 }
1407
1408 /** Called when a group model row is deleted, but also when the model is
1409  *  reordered by a user drag-and-drop; the latter is what we are
1410  *  interested in here.
1411  */
1412 void
1413 Mixer_UI::route_group_row_deleted (Gtk::TreeModel::Path const &)
1414 {
1415         if (_in_group_rebuild_or_clear) {
1416                 return;
1417         }
1418
1419         /* Re-write the session's route group list so that the new order is preserved */
1420
1421         list<RouteGroup*> new_list;
1422
1423         Gtk::TreeModel::Children children = group_model->children();
1424         for (Gtk::TreeModel::Children::iterator i = children.begin(); i != children.end(); ++i) {
1425                 RouteGroup* g = (*i)[group_columns.group];
1426                 if (g) {
1427                         new_list.push_back (g);
1428                 }
1429         }
1430
1431         _session->reorder_route_groups (new_list);
1432 }
1433
1434
1435 void
1436 Mixer_UI::add_route_group (RouteGroup* group)
1437 {
1438         ENSURE_GUI_THREAD (*this, &Mixer_UI::add_route_group, group)
1439         bool focus = false;
1440
1441         in_group_row_change = true;
1442
1443         TreeModel::Row row = *(group_model->append());
1444         row[group_columns.visible] = !group->is_hidden ();
1445         row[group_columns.group] = group;
1446         if (!group->name().empty()) {
1447                 row[group_columns.text] = group->name();
1448         } else {
1449                 row[group_columns.text] = _("unnamed");
1450                 focus = true;
1451         }
1452
1453         group->PropertyChanged.connect (*this, invalidator (*this), boost::bind (&Mixer_UI::route_group_property_changed, this, group, _1), gui_context());
1454
1455         if (focus) {
1456                 TreeViewColumn* col = group_display.get_column (0);
1457                 CellRendererText* name_cell = dynamic_cast<CellRendererText*>(group_display.get_column_cell_renderer (0));
1458                 group_display.set_cursor (group_model->get_path (row), *col, *name_cell, true);
1459         }
1460
1461         _group_tabs->set_dirty ();
1462
1463         in_group_row_change = false;
1464 }
1465
1466 bool
1467 Mixer_UI::strip_scroller_button_release (GdkEventButton* ev)
1468 {
1469         using namespace Menu_Helpers;
1470
1471         if (Keyboard::is_context_menu_event (ev)) {
1472                 ARDOUR_UI::instance()->add_route (this);
1473                 return true;
1474         }
1475
1476         return false;
1477 }
1478
1479 void
1480 Mixer_UI::set_strip_width (Width w)
1481 {
1482         _strip_width = w;
1483
1484         for (list<MixerStrip*>::iterator i = strips.begin(); i != strips.end(); ++i) {
1485                 (*i)->set_width_enum (w, this);
1486         }
1487 }
1488
1489 void
1490 Mixer_UI::set_window_pos_and_size ()
1491 {
1492         resize (m_width, m_height);
1493         move (m_root_x, m_root_y);
1494 }
1495
1496         void
1497 Mixer_UI::get_window_pos_and_size ()
1498 {
1499         get_position(m_root_x, m_root_y);
1500         get_size(m_width, m_height);
1501 }
1502
1503 int
1504 Mixer_UI::set_state (const XMLNode& node)
1505 {
1506         const XMLProperty* prop;
1507         XMLNode* geometry;
1508
1509         m_width = default_width;
1510         m_height = default_height;
1511         m_root_x = 1;
1512         m_root_y = 1;
1513
1514         if ((geometry = find_named_node (node, "geometry")) != 0) {
1515
1516                 XMLProperty* prop;
1517
1518                 if ((prop = geometry->property("x_size")) == 0) {
1519                         prop = geometry->property ("x-size");
1520                 }
1521                 if (prop) {
1522                         m_width = atoi(prop->value());
1523                 }
1524                 if ((prop = geometry->property("y_size")) == 0) {
1525                         prop = geometry->property ("y-size");
1526                 }
1527                 if (prop) {
1528                         m_height = atoi(prop->value());
1529                 }
1530
1531                 if ((prop = geometry->property ("x_pos")) == 0) {
1532                         prop = geometry->property ("x-pos");
1533                 }
1534                 if (prop) {
1535                         m_root_x = atoi (prop->value());
1536
1537                 }
1538                 if ((prop = geometry->property ("y_pos")) == 0) {
1539                         prop = geometry->property ("y-pos");
1540                 }
1541                 if (prop) {
1542                         m_root_y = atoi (prop->value());
1543                 }
1544         }
1545
1546         set_window_pos_and_size ();
1547
1548         if ((prop = node.property ("narrow-strips"))) {
1549                 if (string_is_affirmative (prop->value())) {
1550                         set_strip_width (Narrow);
1551                 } else {
1552                         set_strip_width (Wide);
1553                 }
1554         }
1555
1556         if ((prop = node.property ("show-mixer"))) {
1557                 if (string_is_affirmative (prop->value())) {
1558                        _visible = true;
1559                 }
1560         }
1561
1562         return 0;
1563 }
1564
1565 XMLNode&
1566 Mixer_UI::get_state (void)
1567 {
1568         XMLNode* node = new XMLNode ("Mixer");
1569
1570         if (is_realized()) {
1571                 Glib::RefPtr<Gdk::Window> win = get_window();
1572
1573                 get_window_pos_and_size ();
1574
1575                 XMLNode* geometry = new XMLNode ("geometry");
1576                 char buf[32];
1577                 snprintf(buf, sizeof(buf), "%d", m_width);
1578                 geometry->add_property(X_("x_size"), string(buf));
1579                 snprintf(buf, sizeof(buf), "%d", m_height);
1580                 geometry->add_property(X_("y_size"), string(buf));
1581                 snprintf(buf, sizeof(buf), "%d", m_root_x);
1582                 geometry->add_property(X_("x_pos"), string(buf));
1583                 snprintf(buf, sizeof(buf), "%d", m_root_y);
1584                 geometry->add_property(X_("y_pos"), string(buf));
1585
1586                 // written only for compatibility, they are not used.
1587                 snprintf(buf, sizeof(buf), "%d", 0);
1588                 geometry->add_property(X_("x_off"), string(buf));
1589                 snprintf(buf, sizeof(buf), "%d", 0);
1590                 geometry->add_property(X_("y_off"), string(buf));
1591
1592                 snprintf(buf,sizeof(buf), "%d",gtk_paned_get_position (static_cast<Paned*>(&rhs_pane1)->gobj()));
1593                 geometry->add_property(X_("mixer_rhs_pane1_pos"), string(buf));
1594                 snprintf(buf,sizeof(buf), "%d",gtk_paned_get_position (static_cast<Paned*>(&list_hpane)->gobj()));
1595                 geometry->add_property(X_("mixer_list_hpane_pos"), string(buf));
1596
1597                 node->add_child_nocopy (*geometry);
1598         }
1599
1600         node->add_property ("narrow-strips", _strip_width == Narrow ? "yes" : "no");
1601
1602         node->add_property ("show-mixer", _visible ? "yes" : "no");
1603
1604         return *node;
1605 }
1606
1607
1608 void
1609 Mixer_UI::pane_allocation_handler (Allocation&, Gtk::Paned* which)
1610 {
1611         int pos;
1612         XMLProperty* prop = 0;
1613         char buf[32];
1614         XMLNode* node = ARDOUR_UI::instance()->mixer_settings();
1615         XMLNode* geometry;
1616         int height;
1617         static int32_t done[3] = { 0, 0, 0 };
1618
1619         height = default_height;
1620
1621         if ((geometry = find_named_node (*node, "geometry")) != 0) {
1622
1623                 if ((prop = geometry->property ("y_size")) == 0) {
1624                         prop = geometry->property ("y-size");
1625                 }
1626                 if (prop) {
1627                         height = atoi (prop->value());
1628                 }
1629         }
1630
1631         if (which == static_cast<Gtk::Paned*> (&rhs_pane1)) {
1632
1633                 if (done[0]) {
1634                         return;
1635                 }
1636
1637                 if (!geometry || (prop = geometry->property("mixer-rhs-pane1-pos")) == 0) {
1638                         pos = height / 3;
1639                         snprintf (buf, sizeof(buf), "%d", pos);
1640                 } else {
1641                         pos = atoi (prop->value());
1642                 }
1643
1644                 if ((done[0] = GTK_WIDGET(rhs_pane1.gobj())->allocation.height > pos)) {
1645                         rhs_pane1.set_position (pos);
1646                 }
1647
1648         } else if (which == static_cast<Gtk::Paned*> (&list_hpane)) {
1649
1650                 if (done[2]) {
1651                         return;
1652                 }
1653
1654                 if (!geometry || (prop = geometry->property("mixer-list-hpane-pos")) == 0) {
1655                         pos = 75;
1656                         snprintf (buf, sizeof(buf), "%d", pos);
1657                 } else {
1658                         pos = atoi (prop->value());
1659                 }
1660
1661                 if ((done[2] = GTK_WIDGET(list_hpane.gobj())->allocation.width > pos)) {
1662                         list_hpane.set_position (pos);
1663                 }
1664         }
1665 }
1666 void
1667 Mixer_UI::scroll_left ()
1668 {
1669         Adjustment* adj = scroller.get_hscrollbar()->get_adjustment();
1670         /* stupid GTK: can't rely on clamping across versions */
1671         scroller.get_hscrollbar()->set_value (max (adj->get_lower(), adj->get_value() - adj->get_step_increment()));
1672 }
1673
1674 void
1675 Mixer_UI::scroll_right ()
1676 {
1677         Adjustment* adj = scroller.get_hscrollbar()->get_adjustment();
1678         /* stupid GTK: can't rely on clamping across versions */
1679         scroller.get_hscrollbar()->set_value (min (adj->get_upper(), adj->get_value() + adj->get_step_increment()));
1680 }
1681
1682 bool
1683 Mixer_UI::on_key_press_event (GdkEventKey* ev)
1684 {
1685         /* focus widget gets first shot, then bindings, otherwise
1686            forward to main window
1687         */
1688
1689         if (gtk_window_propagate_key_event (GTK_WINDOW(gobj()), ev)) {
1690                 return true;
1691         }
1692
1693         KeyboardKey k (ev->state, ev->keyval);
1694
1695         if (bindings.activate (k, Bindings::Press)) {
1696                 return true;
1697         }
1698
1699         return forward_key_press (ev);
1700 }
1701
1702 bool
1703 Mixer_UI::on_key_release_event (GdkEventKey* ev)
1704 {
1705         if (gtk_window_propagate_key_event (GTK_WINDOW(gobj()), ev)) {
1706                 return true;
1707         }
1708
1709         KeyboardKey k (ev->state, ev->keyval);
1710
1711         if (bindings.activate (k, Bindings::Release)) {
1712                 return true;
1713         }
1714
1715         /* don't forward releases */
1716
1717         return true;
1718 }
1719
1720 bool
1721 Mixer_UI::on_scroll_event (GdkEventScroll* ev)
1722 {
1723         switch (ev->direction) {
1724         case GDK_SCROLL_LEFT:
1725                 scroll_left ();
1726                 return true;
1727         case GDK_SCROLL_UP:
1728                 if (ev->state & Keyboard::TertiaryModifier) {
1729                         scroll_left ();
1730                         return true;
1731                 }
1732                 return false;
1733
1734         case GDK_SCROLL_RIGHT:
1735                 scroll_right ();
1736                 return true;
1737
1738         case GDK_SCROLL_DOWN:
1739                 if (ev->state & Keyboard::TertiaryModifier) {
1740                         scroll_right ();
1741                         return true;
1742                 }
1743                 return false;
1744         }
1745
1746         return false;
1747 }
1748
1749
1750 void
1751 Mixer_UI::parameter_changed (string const & p)
1752 {
1753         if (p == "show-group-tabs") {
1754                 bool const s = _session->config.get_show_group_tabs ();
1755                 if (s) {
1756                         _group_tabs->show ();
1757                 } else {
1758                         _group_tabs->hide ();
1759                 }
1760         } else if (p == "default-narrow_ms") {
1761                 bool const s = Config->get_default_narrow_ms ();
1762                 for (list<MixerStrip*>::iterator i = strips.begin(); i != strips.end(); ++i) {
1763                         (*i)->set_width_enum (s ? Narrow : Wide, this);
1764                 }
1765         } else if (p == "remote-model") {
1766                 reset_remote_control_ids ();
1767         }
1768 }
1769
1770 void
1771 Mixer_UI::set_route_group_activation (RouteGroup* g, bool a)
1772 {
1773         g->set_active (a, this);
1774 }
1775
1776 PluginSelector*
1777 Mixer_UI::plugin_selector()
1778 {
1779 #ifdef DEFER_PLUGIN_SELECTOR_LOAD
1780         if (!_plugin_selector)
1781                 _plugin_selector = new PluginSelector (PluginManager::instance());
1782 #endif
1783
1784         return _plugin_selector;
1785 }
1786
1787 void
1788 Mixer_UI::setup_track_display ()
1789 {
1790         track_model = ListStore::create (track_columns);
1791         track_display.set_model (track_model);
1792         track_display.append_column (_("Strips"), track_columns.text);
1793         track_display.append_column (_("Show"), track_columns.visible);
1794         track_display.get_column (0)->set_data (X_("colnum"), GUINT_TO_POINTER(0));
1795         track_display.get_column (1)->set_data (X_("colnum"), GUINT_TO_POINTER(1));
1796         track_display.get_column (0)->set_expand(true);
1797         track_display.get_column (1)->set_expand(false);
1798         track_display.set_name (X_("EditGroupList"));
1799         track_display.get_selection()->set_mode (Gtk::SELECTION_NONE);
1800         track_display.set_reorderable (true);
1801         track_display.set_headers_visible (true);
1802
1803         track_model->signal_row_deleted().connect (sigc::mem_fun (*this, &Mixer_UI::track_list_delete));
1804         track_model->signal_rows_reordered().connect (sigc::mem_fun (*this, &Mixer_UI::track_list_reorder));
1805
1806         CellRendererToggle* track_list_visible_cell = dynamic_cast<CellRendererToggle*>(track_display.get_column_cell_renderer (1));
1807         track_list_visible_cell->property_activatable() = true;
1808         track_list_visible_cell->property_radio() = false;
1809         track_list_visible_cell->signal_toggled().connect (sigc::mem_fun (*this, &Mixer_UI::track_visibility_changed));
1810
1811         track_display.signal_button_press_event().connect (sigc::mem_fun (*this, &Mixer_UI::track_display_button_press), false);
1812
1813         track_display_scroller.add (track_display);
1814         track_display_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
1815
1816         VBox* v = manage (new VBox);
1817         v->show ();
1818         v->pack_start (track_display_scroller, true, true);
1819
1820         Button* b = manage (new Button);
1821         b->show ();
1822         Widget* w = manage (new Image (Stock::ADD, ICON_SIZE_BUTTON));
1823         w->show ();
1824         b->add (*w);
1825
1826         b->signal_clicked().connect (sigc::mem_fun (*this, &Mixer_UI::new_track_or_bus));
1827
1828         v->pack_start (*b, false, false);
1829
1830         track_display_frame.set_name("BaseFrame");
1831         track_display_frame.set_shadow_type (Gtk::SHADOW_IN);
1832         track_display_frame.add (*v);
1833
1834         track_display_scroller.show();
1835         track_display_frame.show();
1836         track_display.show();
1837 }
1838
1839 void
1840 Mixer_UI::new_track_or_bus ()
1841 {
1842         ARDOUR_UI::instance()->add_route (this);
1843 }
1844
1845
1846 void
1847 Mixer_UI::update_title ()
1848 {
1849         if (_session) {
1850                 string n;
1851
1852                 if (_session->snap_name() != _session->name()) {
1853                         n = _session->snap_name ();
1854                 } else {
1855                         n = _session->name ();
1856                 }
1857
1858                 if (_session->dirty ()) {
1859                         n = "*" + n;
1860                 }
1861
1862                 WindowTitle title (n);
1863                 title += S_("Window|Mixer");
1864                 title += Glib::get_application_name ();
1865                 set_title (title.get_string());
1866
1867         } else {
1868
1869                 WindowTitle title (S_("Window|Mixer"));
1870                 title += Glib::get_application_name ();
1871                 set_title (title.get_string());
1872         }
1873 }
1874
1875 MixerStrip*
1876 Mixer_UI::strip_by_x (int x)
1877 {
1878         for (list<MixerStrip*>::iterator i = strips.begin(); i != strips.end(); ++i) {
1879                 int x1, x2, y;
1880
1881                 (*i)->translate_coordinates (*this, 0, 0, x1, y);
1882                 x2 = x1 + (*i)->get_width();
1883
1884                 if (x >= x1 && x <= x2) {
1885                         return (*i);
1886                 }
1887         }
1888
1889         return 0;
1890 }
1891
1892 void
1893 Mixer_UI::set_route_targets_for_operation ()
1894 {
1895         _route_targets.clear ();
1896
1897         if (!_selection.empty()) {
1898                 _route_targets = _selection.routes;
1899                 return;
1900         }
1901
1902         /* nothing selected ... try to get mixer strip at mouse */
1903
1904         int x, y;
1905         get_pointer (x, y);
1906
1907         MixerStrip* ms = strip_by_x (x);
1908
1909         if (ms) {
1910                 _route_targets.insert (ms);
1911         }
1912 }
1913
1914 void
1915 Mixer_UI::monitor_section_going_away ()
1916 {
1917         if (_monitor_section) {
1918                 out_packer.remove (_monitor_section->tearoff());
1919                 _monitor_section->set_session (0);
1920         }
1921 }
1922
1923 void
1924 Mixer_UI::toggle_midi_input_active (bool flip_others)
1925 {
1926         boost::shared_ptr<RouteList> rl (new RouteList);
1927         bool onoff;
1928
1929         set_route_targets_for_operation ();
1930
1931         for (RouteUISelection::iterator r = _route_targets.begin(); r != _route_targets.end(); ++r) {
1932                 boost::shared_ptr<MidiTrack> mt = (*r)->midi_track();
1933
1934                 if (mt) {
1935                         rl->push_back ((*r)->route());
1936                         onoff = !mt->input_active();
1937                 }
1938         }
1939
1940         _session->set_exclusive_input_active (rl, onoff, flip_others);
1941 }
1942