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/stacktrace.h"
  32 #include "pbd/unwind.h"
  33
  34 #include <glibmm/threads.h>
  35
  36 #include <gtkmm2ext/gtk_ui.h>
  37 #include <gtkmm2ext/utils.h>
  38 #include <gtkmm2ext/tearoff.h>
  39 #include <gtkmm2ext/window_title.h>
  40 #include <gtkmm2ext/doi.h>
  41
  42 #include "ardour/amp.h"
  43 #include "ardour/debug.h"
  44 #include "ardour/midi_track.h"
  45 #include "ardour/plugin_manager.h"
  46 #include "ardour/route_group.h"
  47 #include "ardour/route_sorters.h"
  48 #include "ardour/session.h"
  49
  50 #include "keyboard.h"
  51 #include "mixer_ui.h"
  52 #include "mixer_strip.h"
  53 #include "monitor_section.h"
  54 #include "plugin_selector.h"
  55 #include "public_editor.h"
  56 #include "ardour_ui.h"
  57 #include "prompter.h"
  58 #include "utils.h"
  59 #include "route_sorter.h"
  60 #include "actions.h"
  61 #include "gui_thread.h"
  62 #include "mixer_group_tabs.h"
  63 #include "timers.h"
  64 #include "ui_config.h"
  65
  66 #include "i18n.h"
  67
  68 using namespace ARDOUR;
  69 using namespace ARDOUR_UI_UTILS;
  70 using namespace PBD;
  71 using namespace Gtk;
  72 using namespace Glib;
  73 using namespace Gtkmm2ext;
  74 using namespace std;
  75
  76 using PBD::atoi;
  77 using PBD::Unwinder;
  78
  79 Mixer_UI* Mixer_UI::_instance = 0;
  80
  81 Mixer_UI*
  82 Mixer_UI::instance ()
  83 {
  84         if (!_instance) {
  85                 _instance  = new Mixer_UI;
  86         }
  87
  88         return _instance;
  89 }
  90
  91 Mixer_UI::Mixer_UI ()
  92         : Tabbable (_content, _("Mixer"))
  93         , no_track_list_redisplay (false)
  94         , in_group_row_change (false)
  95         , track_menu (0)
  96         , _monitor_section (0)
  97         , _plugin_selector (0)
  98         , _strip_width (UIConfiguration::instance().get_default_narrow_ms() ? Narrow : Wide)
  99         , ignore_reorder (false)
 100         , _in_group_rebuild_or_clear (false)
 101         , _route_deletion_in_progress (false)
 102         , _following_editor_selection (false)
 103         , _maximised (false)
 104         , _show_mixer_list (true)
 105 {
 106         Route::SyncOrderKeys.connect (*this, invalidator (*this), boost::bind (&Mixer_UI::sync_treeview_from_order_keys, this), gui_context());
 107
 108         scroller.set_can_default (true);
 109         // set_default (scroller);
 110
 111         scroller_base.set_flags (Gtk::CAN_FOCUS);
 112         scroller_base.add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
 113         scroller_base.set_name ("MixerWindow");
 114         scroller_base.signal_button_release_event().connect (sigc::mem_fun(*this, &Mixer_UI::strip_scroller_button_release));
 115         // add as last item of strip packer
 116         strip_packer.pack_end (scroller_base, true, true);
 117
 118         _group_tabs = new MixerGroupTabs (this);
 119         VBox* b = manage (new VBox);
 120         b->pack_start (*_group_tabs, PACK_SHRINK);
 121         b->pack_start (strip_packer);
 122         b->show_all ();
 123
 124         scroller.add (*b);
 125         scroller.set_policy (Gtk::POLICY_ALWAYS, Gtk::POLICY_AUTOMATIC);
 126
 127         setup_track_display ();
 128
 129         group_model = ListStore::create (group_columns);
 130         group_display.set_model (group_model);
 131         group_display.append_column (_("Group"), group_columns.text);
 132         group_display.append_column (_("Show"), group_columns.visible);
 133         group_display.get_column (0)->set_data (X_("colnum"), GUINT_TO_POINTER(0));
 134         group_display.get_column (1)->set_data (X_("colnum"), GUINT_TO_POINTER(1));
 135         group_display.get_column (0)->set_expand(true);
 136         group_display.get_column (1)->set_expand(false);
 137         group_display.set_name ("EditGroupList");
 138         group_display.get_selection()->set_mode (Gtk::SELECTION_SINGLE);
 139         group_display.set_reorderable (true);
 140         group_display.set_headers_visible (true);
 141         group_display.set_rules_hint (true);
 142         group_display.set_can_focus(false);
 143
 144         /* name is directly editable */
 145
 146         CellRendererText* name_cell = dynamic_cast<CellRendererText*>(group_display.get_column_cell_renderer (0));
 147         name_cell->property_editable() = true;
 148         name_cell->signal_edited().connect (sigc::mem_fun (*this, &Mixer_UI::route_group_name_edit));
 149
 150         /* use checkbox for the active column */
 151
 152         CellRendererToggle* active_cell = dynamic_cast<CellRendererToggle*>(group_display.get_column_cell_renderer (1));
 153         active_cell->property_activatable() = true;
 154         active_cell->property_radio() = false;
 155
 156         group_model->signal_row_changed().connect (sigc::mem_fun (*this, &Mixer_UI::route_group_row_change));
 157         /* We use this to notice drag-and-drop reorders of the group list */
 158         group_model->signal_row_deleted().connect (sigc::mem_fun (*this, &Mixer_UI::route_group_row_deleted));
 159         group_display.signal_button_press_event().connect (sigc::mem_fun (*this, &Mixer_UI::group_display_button_press), false);
 160
 161         group_display_scroller.add (group_display);
 162         group_display_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
 163
 164         HBox* route_group_display_button_box = manage (new HBox());
 165
 166         Button* route_group_add_button = manage (new Button ());
 167         Button* route_group_remove_button = manage (new Button ());
 168
 169         Widget* w;
 170
 171         w = manage (new Image (Stock::ADD, ICON_SIZE_BUTTON));
 172         w->show();
 173         route_group_add_button->add (*w);
 174
 175         w = manage (new Image (Stock::REMOVE, ICON_SIZE_BUTTON));
 176         w->show();
 177         route_group_remove_button->add (*w);
 178
 179         route_group_display_button_box->set_homogeneous (true);
 180
 181         route_group_add_button->signal_clicked().connect (sigc::mem_fun (*this, &Mixer_UI::new_route_group));
 182         route_group_remove_button->signal_clicked().connect (sigc::mem_fun (*this, &Mixer_UI::remove_selected_route_group));
 183
 184         route_group_display_button_box->add (*route_group_add_button);
 185         route_group_display_button_box->add (*route_group_remove_button);
 186
 187         group_display_vbox.pack_start (group_display_scroller, true, true);
 188         group_display_vbox.pack_start (*route_group_display_button_box, false, false);
 189
 190         group_display_frame.set_name ("BaseFrame");
 191         group_display_frame.set_shadow_type (Gtk::SHADOW_IN);
 192         group_display_frame.add (group_display_vbox);
 193
 194         favorite_plugins_model = PluginTreeStore::create (favorite_plugins_columns);
 195         favorite_plugins_display.set_model (favorite_plugins_model);
 196         favorite_plugins_display.append_column (_("Favorite Plugins"), favorite_plugins_columns.name);
 197         favorite_plugins_display.set_name ("EditGroupList");
 198         favorite_plugins_display.get_selection()->set_mode (Gtk::SELECTION_SINGLE);
 199         favorite_plugins_display.set_reorderable (false);
 200         favorite_plugins_display.set_headers_visible (true);
 201         favorite_plugins_display.set_rules_hint (true);
 202         favorite_plugins_display.set_can_focus (false);
 203         favorite_plugins_display.add_object_drag (favorite_plugins_columns.plugin.index(), "PluginPresetPtr");
 204         favorite_plugins_display.set_drag_column (favorite_plugins_columns.name.index());
 205         favorite_plugins_display.signal_row_activated().connect (sigc::mem_fun (*this, &Mixer_UI::plugin_row_activated));
 206         favorite_plugins_display.signal_button_press_event().connect (sigc::mem_fun (*this, &Mixer_UI::plugin_row_button_press), false);
 207         favorite_plugins_display.signal_drop.connect (sigc::mem_fun (*this, &Mixer_UI::plugin_drop));
 208         favorite_plugins_display.signal_row_expanded().connect (sigc::mem_fun (*this, &Mixer_UI::save_favorite_ui_state));
 209         favorite_plugins_display.signal_row_collapsed().connect (sigc::mem_fun (*this, &Mixer_UI::save_favorite_ui_state));
 210         favorite_plugins_model->signal_row_has_child_toggled().connect (sigc::mem_fun (*this, &Mixer_UI::sync_treeview_favorite_ui_state));
 211
 212         favorite_plugins_scroller.add (favorite_plugins_display);
 213         favorite_plugins_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
 214
 215         favorite_plugins_frame.set_name ("BaseFrame");
 216         favorite_plugins_frame.set_shadow_type (Gtk::SHADOW_IN);
 217         favorite_plugins_frame.add (favorite_plugins_scroller);
 218
 219         rhs_pane1.pack1 (favorite_plugins_frame, false, true);
 220         rhs_pane1.pack2 (track_display_frame);
 221         rhs_pane2.pack1 (rhs_pane1);
 222         rhs_pane2.pack2 (group_display_frame);
 223
 224         list_vpacker.pack_start (rhs_pane2, true, true);
 225
 226         global_hpacker.pack_start (scroller, true, true);
 227         global_hpacker.pack_start (out_packer, false, false, 0);
 228
 229         list_hpane.pack1(list_vpacker, false, true);
 230         list_hpane.pack2(global_hpacker, true, false);
 231
 232         rhs_pane1.signal_size_allocate().connect (sigc::bind (sigc::mem_fun(*this, &Mixer_UI::pane_allocation_handler),
 233                                                         static_cast<Gtk::Paned*> (&rhs_pane1)));
 234         rhs_pane2.signal_size_allocate().connect (sigc::bind (sigc::mem_fun(*this, &Mixer_UI::pane_allocation_handler),
 235                                                         static_cast<Gtk::Paned*> (&rhs_pane2)));
 236         list_hpane.signal_size_allocate().connect (sigc::bind (sigc::mem_fun(*this, &Mixer_UI::pane_allocation_handler),
 237                                                          static_cast<Gtk::Paned*> (&list_hpane)));
 238
 239         _content.pack_start (list_hpane, true, true);
 240
 241         update_title ();
 242
 243         route_group_display_button_box->show();
 244         route_group_add_button->show();
 245         route_group_remove_button->show();
 246
 247         _content.show ();
 248         _content.set_name ("MixerWindow");
 249
 250         global_hpacker.show();
 251         scroller.show();
 252         scroller_base.show();
 253         scroller_hpacker.show();
 254         mixer_scroller_vpacker.show();
 255         list_vpacker.show();
 256         group_display_button_label.show();
 257         group_display_button.show();
 258         group_display_scroller.show();
 259         favorite_plugins_scroller.show();
 260         group_display_vbox.show();
 261         group_display_frame.show();
 262         favorite_plugins_frame.show();
 263         rhs_pane1.show();
 264         rhs_pane2.show();
 265         strip_packer.show();
 266         out_packer.show();
 267         list_hpane.show();
 268         group_display.show();
 269         favorite_plugins_display.show();
 270
 271         MixerStrip::CatchDeletion.connect (*this, invalidator (*this), boost::bind (&Mixer_UI::remove_strip, this, _1), gui_context());
 272
 273 #ifndef DEFER_PLUGIN_SELECTOR_LOAD
 274         _plugin_selector = new PluginSelector (PluginManager::instance ());
 275 #else
 276 #error implement deferred Plugin-Favorite list
 277 #endif
 278         PluginManager::instance ().PluginListChanged.connect (*this, invalidator (*this), boost::bind (&Mixer_UI::refill_favorite_plugins, this), gui_context());
 279         PluginManager::instance ().PluginStatusesChanged.connect (*this, invalidator (*this), boost::bind (&Mixer_UI::refill_favorite_plugins, this), gui_context());
 280         ARDOUR::Plugin::PresetsChanged.connect (*this, invalidator (*this), boost::bind (&Mixer_UI::refill_favorite_plugins, this), gui_context());
 281 }
 282
 283 Mixer_UI::~Mixer_UI ()
 284 {
 285         if (_monitor_section) {
 286                 monitor_section_detached ();
 287                 delete _monitor_section;
 288         }
 289         delete _plugin_selector;
 290 }
 291
 292 void
 293 Mixer_UI::track_editor_selection ()
 294 {
 295         PublicEditor::instance().get_selection().TracksChanged.connect (sigc::mem_fun (*this, &Mixer_UI::follow_editor_selection));
 296 }
 297
 298 Gtk::Notebook*
 299 Mixer_UI::use_own_window ()
 300 {
 301         /* This is called after a drop of a tab onto the root window. Its
 302          * responsibility is to return the notebook that this Mixer_UI should
 303          * be packed into before the drop handling is completed. It is not
 304          * responsible for actually taking care of this packing
 305          */
 306
 307         if (_parent_window) {
 308                 return 0;
 309         }
 310
 311         create_own_window ();
 312
 313         return (Gtk::Notebook*) _parent_window->get_child();
 314 }
 315
 316 void
 317 Mixer_UI::create_own_window ()
 318 {
 319         if (_parent_window) {
 320                 return;
 321         }
 322
 323         _parent_window = new Window (Gtk::WINDOW_TOPLEVEL);
 324         Notebook* notebook = manage (new Notebook);
 325
 326         notebook->set_show_tabs (false);
 327         notebook->show_all ();
 328
 329         _parent_window->add (*notebook);
 330
 331         /* allow parent window to become the key focus window */
 332         _parent_window->set_flags (CAN_FOCUS);
 333
 334         /* handle window manager close/delete event sensibly */
 335         _parent_window->signal_delete_event().connect (sigc::mem_fun (*this, &Mixer_UI::hide_window));
 336
 337         set_window_pos_and_size ();
 338         update_title ();
 339 }
 340
 341 void
 342 Mixer_UI::show_window ()
 343 {
 344         if (_parent_window) {
 345                 _parent_window->present ();
 346         }
 347
 348         if (!_visible) { /* was hidden, update status */
 349
 350                 set_window_pos_and_size ();
 351
 352                 /* show/hide group tabs as required */
 353                 parameter_changed ("show-group-tabs");
 354
 355                 /* now reset each strips width so the right widgets are shown */
 356                 MixerStrip* ms;
 357
 358                 TreeModel::Children rows = track_model->children();
 359                 TreeModel::Children::iterator ri;
 360
 361                 for (ri = rows.begin(); ri != rows.end(); ++ri) {
 362                         ms = (*ri)[track_columns.strip];
 363                         ms->set_width_enum (ms->get_width_enum (), ms->width_owner());
 364                         /* Fix visibility of mixer strip stuff */
 365                         ms->parameter_changed (X_("mixer-element-visibility"));
 366                 }
 367         }
 368
 369         if (!_parent_window) {
 370                 /* not in its own window, just switch main tabs to show mixer */
 371                 int pagenum = ARDOUR_UI::instance()->tabs().page_num (*this);
 372                 ARDOUR_UI::instance()->tabs().set_current_page (pagenum);
 373         }
 374
 375         /* force focus into main area */
 376         scroller_base.grab_focus ();
 377         _visible = true;
 378 }
 379
 380 bool
 381 Mixer_UI::hide_window (GdkEventAny *ev)
 382 {
 383         if (_parent_window) {
 384                 /* unpack Mixer_UI from parent, put it back in the main tabbed
 385                  * notebook
 386                  */
 387
 388                 get_window_pos_and_size ();
 389
 390                 get_parent()->remove (*this);
 391                 ARDOUR_UI::instance()->tabs().insert_page (*this, _("Mixer"), 1);
 392                 ARDOUR_UI::instance()->tabs().set_tab_detachable (*this);
 393                 ARDOUR_UI::instance()->tabs().set_current_page (0);
 394
 395                 show_all ();
 396
 397                 delete_when_idle (_parent_window);
 398                 _parent_window = 0;
 399         }
 400
 401         ARDOUR_UI::instance()->tabs().set_current_page (0);
 402
 403         _visible = false;
 404
 405         return true;
 406 }
 407
 408 void
 409 Mixer_UI::add_strips (RouteList& routes)
 410 {
 411         bool from_scratch = track_model->children().size() == 0;
 412         Gtk::TreeModel::Children::iterator insert_iter = track_model->children().end();
 413
 414         for (Gtk::TreeModel::Children::iterator it = track_model->children().begin(); it != track_model->children().end(); ++it) {
 415                 boost::shared_ptr<Route> r = (*it)[track_columns.route];
 416
 417                 if (r->order_key() == (routes.front()->order_key() + routes.size())) {
 418                         insert_iter = it;
 419                         break;
 420                 }
 421         }
 422
 423         if(!from_scratch) {
 424                 _selection.clear_routes ();
 425         }
 426
 427         MixerStrip* strip;
 428
 429         try {
 430                 no_track_list_redisplay = true;
 431                 track_display.set_model (Glib::RefPtr<ListStore>());
 432
 433                 for (RouteList::iterator x = routes.begin(); x != routes.end(); ++x) {
 434                         boost::shared_ptr<Route> route = (*x);
 435
 436                         if (route->is_auditioner()) {
 437                                 continue;
 438                         }
 439
 440                         if (route->is_monitor()) {
 441
 442                                 if (!_monitor_section) {
 443                                         _monitor_section = new MonitorSection (_session);
 444
 445                                         XMLNode* mnode = ARDOUR_UI::instance()->tearoff_settings (X_("monitor-section"));
 446                                         if (mnode) {
 447                                                 _monitor_section->tearoff().set_state (*mnode);
 448                                         }
 449                                 }
 450
 451                                 out_packer.pack_end (_monitor_section->tearoff(), false, false);
 452                                 _monitor_section->set_session (_session);
 453                                 _monitor_section->tearoff().show_all ();
 454
 455                                 _monitor_section->tearoff().Detach.connect (sigc::mem_fun(*this, &Mixer_UI::monitor_section_detached));
 456                                 _monitor_section->tearoff().Attach.connect (sigc::mem_fun(*this, &Mixer_UI::monitor_section_attached));
 457
 458                                 monitor_section_attached ();
 459
 460                                 route->DropReferences.connect (*this, invalidator(*this), boost::bind (&Mixer_UI::monitor_section_going_away, this), gui_context());
 461
 462                                 /* no regular strip shown for control out */
 463
 464                                 continue;
 465                         }
 466
 467                         strip = new MixerStrip (*this, _session, route);
 468                         strips.push_back (strip);
 469
 470                         UIConfiguration::instance().get_default_narrow_ms() ? _strip_width = Narrow : _strip_width = Wide;
 471
 472                         if (strip->width_owner() != strip) {
 473                                 strip->set_width_enum (_strip_width, this);
 474                         }
 475
 476                         show_strip (strip);
 477
 478                         TreeModel::Row row = *(track_model->insert(insert_iter));
 479                         row[track_columns.text] = route->name();
 480                         row[track_columns.visible] = strip->route()->is_master() ? true : strip->marked_for_display();
 481                         row[track_columns.route] = route;
 482                         row[track_columns.strip] = strip;
 483
 484                         if (!from_scratch) {
 485                                 _selection.add (strip);
 486                         }
 487
 488                         route->PropertyChanged.connect (*this, invalidator (*this), boost::bind (&Mixer_UI::strip_property_changed, this, _1, strip), gui_context());
 489
 490                         strip->WidthChanged.connect (sigc::mem_fun(*this, &Mixer_UI::strip_width_changed));
 491                         strip->signal_button_release_event().connect (sigc::bind (sigc::mem_fun(*this, &Mixer_UI::strip_button_release_event), strip));
 492                 }
 493
 494         } catch (...) {
 495         }
 496
 497         no_track_list_redisplay = false;
 498         track_display.set_model (track_model);
 499
 500         sync_order_keys_from_treeview ();
 501         redisplay_track_list ();
 502 }
 503
 504 void
 505 Mixer_UI::deselect_all_strip_processors ()
 506 {
 507         for (list<MixerStrip *>::iterator i = strips.begin(); i != strips.end(); ++i) {
 508                 (*i)->deselect_all_processors();
 509         }
 510 }
 511
 512 void
 513 Mixer_UI::select_none ()
 514 {
 515         _selection.clear_routes();
 516         deselect_all_strip_processors();
 517 }
 518
 519 void
 520 Mixer_UI::delete_processors ()
 521 {
 522         for (list<MixerStrip *>::iterator i = strips.begin(); i != strips.end(); ++i) {
 523                 (*i)->delete_processors();
 524         }
 525 }
 526
 527
 528 void
 529 Mixer_UI::remove_strip (MixerStrip* strip)
 530 {
 531         if (_session && _session->deletion_in_progress()) {
 532                 /* its all being taken care of */
 533                 return;
 534         }
 535
 536         TreeModel::Children rows = track_model->children();
 537         TreeModel::Children::iterator ri;
 538         list<MixerStrip *>::iterator i;
 539
 540         if ((i = find (strips.begin(), strips.end(), strip)) != strips.end()) {
 541                 strips.erase (i);
 542         }
 543
 544         for (ri = rows.begin(); ri != rows.end(); ++ri) {
 545                 if ((*ri)[track_columns.strip] == strip) {
 546                         PBD::Unwinder<bool> uw (_route_deletion_in_progress, true);
 547                         track_model->erase (ri);
 548                         break;
 549                 }
 550         }
 551 }
 552
 553 void
 554 Mixer_UI::reset_remote_control_ids ()
 555 {
 556         if (Config->get_remote_model() == UserOrdered || !_session || _session->deletion_in_progress()) {
 557                 return;
 558         }
 559
 560         TreeModel::Children rows = track_model->children();
 561
 562         if (rows.empty()) {
 563                 return;
 564         }
 565
 566         DEBUG_TRACE (DEBUG::OrderKeys, "mixer resets remote control ids after remote model change\n");
 567
 568         TreeModel::Children::iterator ri;
 569         bool rid_change = false;
 570         uint32_t rid = 1;
 571         uint32_t invisible_key = UINT32_MAX;
 572
 573         for (ri = rows.begin(); ri != rows.end(); ++ri) {
 574
 575                 /* skip two special values */
 576
 577                 if (rid == Route::MasterBusRemoteControlID) {
 578                         rid++;
 579                 }
 580
 581                 if (rid == Route::MonitorBusRemoteControlID) {
 582                         rid++;
 583                 }
 584
 585                 boost::shared_ptr<Route> route = (*ri)[track_columns.route];
 586                 bool visible = (*ri)[track_columns.visible];
 587
 588                 if (!route->is_master() && !route->is_monitor()) {
 589
 590                         uint32_t new_rid = (visible ? rid : invisible_key--);
 591
 592                         if (new_rid != route->remote_control_id()) {
 593                                 route->set_remote_control_id_explicit (new_rid);
 594                                 rid_change = true;
 595                         }
 596
 597                         if (visible) {
 598                                 rid++;
 599                         }
 600                 }
 601         }
 602
 603         if (rid_change) {
 604                 /* tell the world that we changed the remote control IDs */
 605                 _session->notify_remote_id_change ();
 606         }
 607 }
 608
 609 void
 610 Mixer_UI::sync_order_keys_from_treeview ()
 611 {
 612         if (ignore_reorder || !_session || _session->deletion_in_progress()) {
 613                 return;
 614         }
 615
 616         TreeModel::Children rows = track_model->children();
 617
 618         if (rows.empty()) {
 619                 return;
 620         }
 621
 622         DEBUG_TRACE (DEBUG::OrderKeys, "mixer sync order keys from model\n");
 623
 624         TreeModel::Children::iterator ri;
 625         bool changed = false;
 626         bool rid_change = false;
 627         uint32_t order = 0;
 628         uint32_t rid = 1;
 629         uint32_t invisible_key = UINT32_MAX;
 630
 631         for (ri = rows.begin(); ri != rows.end(); ++ri) {
 632                 boost::shared_ptr<Route> route = (*ri)[track_columns.route];
 633                 bool visible = (*ri)[track_columns.visible];
 634
 635                 uint32_t old_key = route->order_key ();
 636
 637                 if (order != old_key) {
 638                         route->set_order_key (order);
 639                         changed = true;
 640                 }
 641
 642                 if ((Config->get_remote_model() == MixerOrdered) && !route->is_master() && !route->is_monitor()) {
 643
 644                         uint32_t new_rid = (visible ? rid : invisible_key--);
 645
 646                         if (new_rid != route->remote_control_id()) {
 647                                 route->set_remote_control_id_explicit (new_rid);
 648                                 rid_change = true;
 649                         }
 650
 651                         if (visible) {
 652                                 rid++;
 653                         }
 654
 655                 }
 656
 657                 ++order;
 658         }
 659
 660         if (changed) {
 661                 /* tell everyone that we changed the mixer sort keys */
 662                 _session->sync_order_keys ();
 663         }
 664
 665         if (rid_change) {
 666                 /* tell the world that we changed the remote control IDs */
 667                 _session->notify_remote_id_change ();
 668         }
 669 }
 670
 671 void
 672 Mixer_UI::sync_treeview_from_order_keys ()
 673 {
 674         if (!_session || _session->deletion_in_progress()) {
 675                 return;
 676         }
 677
 678         DEBUG_TRACE (DEBUG::OrderKeys, "mixer sync model from order keys.\n");
 679
 680         /* we could get here after either a change in the Mixer or Editor sort
 681          * order, but either way, the mixer order keys reflect the intended
 682          * order for the GUI, so reorder the treeview model to match it.
 683          */
 684
 685         vector<int> neworder;
 686         TreeModel::Children rows = track_model->children();
 687         uint32_t old_order = 0;
 688         bool changed = false;
 689
 690         if (rows.empty()) {
 691                 return;
 692         }
 693
 694         OrderKeySortedRoutes sorted_routes;
 695
 696         for (TreeModel::Children::iterator ri = rows.begin(); ri != rows.end(); ++ri, ++old_order) {
 697                 boost::shared_ptr<Route> route = (*ri)[track_columns.route];
 698                 sorted_routes.push_back (RoutePlusOrderKey (route, old_order, route->order_key ()));
 699         }
 700
 701         SortByNewDisplayOrder cmp;
 702
 703         sort (sorted_routes.begin(), sorted_routes.end(), cmp);
 704         neworder.assign (sorted_routes.size(), 0);
 705
 706         uint32_t n = 0;
 707
 708         for (OrderKeySortedRoutes::iterator sr = sorted_routes.begin(); sr != sorted_routes.end(); ++sr, ++n) {
 709
 710                 neworder[n] = sr->old_display_order;
 711
 712                 if (sr->old_display_order != n) {
 713                         changed = true;
 714                 }
 715
 716                 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("MIXER change order for %1 from %2 to %3\n",
 717                                                                sr->route->name(), sr->old_display_order, n));
 718         }
 719
 720         if (changed) {
 721                 Unwinder<bool> uw (ignore_reorder, true);
 722                 track_model->reorder (neworder);
 723         }
 724
 725         redisplay_track_list ();
 726 }
 727
 728 void
 729 Mixer_UI::follow_editor_selection ()
 730 {
 731         if (_following_editor_selection) {
 732                 return;
 733         }
 734
 735         _following_editor_selection = true;
 736         _selection.block_routes_changed (true);
 737
 738         TrackSelection& s (PublicEditor::instance().get_selection().tracks);
 739
 740         _selection.clear_routes ();
 741
 742         for (TrackViewList::iterator i = s.begin(); i != s.end(); ++i) {
 743                 RouteTimeAxisView* rtav = dynamic_cast<RouteTimeAxisView*> (*i);
 744                 if (rtav) {
 745                         MixerStrip* ms = strip_by_route (rtav->route());
 746                         if (ms) {
 747                                 _selection.add (ms);
 748                         }
 749                 }
 750         }
 751
 752         _following_editor_selection = false;
 753         _selection.block_routes_changed (false);
 754 }
 755
 756
 757 MixerStrip*
 758 Mixer_UI::strip_by_route (boost::shared_ptr<Route> r)
 759 {
 760         for (list<MixerStrip *>::iterator i = strips.begin(); i != strips.end(); ++i) {
 761                 if ((*i)->route() == r) {
 762                         return (*i);
 763                 }
 764         }
 765
 766         return 0;
 767 }
 768
 769 bool
 770 Mixer_UI::strip_button_release_event (GdkEventButton *ev, MixerStrip *strip)
 771 {
 772         if (ev->button == 1) {
 773                 if (_selection.selected (strip)) {
 774                         /* primary-click: toggle selection state of strip */
 775                         if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
 776                                 _selection.remove (strip);
 777                         } else if (_selection.routes.size() > 1) {
 778                                 /* de-select others */
 779                                 _selection.set (strip);
 780                         }
 781                 } else {
 782                         if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
 783                                 _selection.add (strip);
 784                         } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::RangeSelectModifier)) {
 785
 786                                 if (!_selection.selected(strip)) {
 787
 788                                         /* extend selection */
 789
 790                                         vector<MixerStrip*> tmp;
 791                                         bool accumulate = false;
 792                                         bool found_another = false;
 793
 794                                         tmp.push_back (strip);
 795
 796                                         for (list<MixerStrip*>::iterator i = strips.begin(); i != strips.end(); ++i) {
 797                                                 if ((*i) == strip) {
 798                                                         /* hit clicked strip, start accumulating till we hit the first
 799                                                            selected strip
 800                                                         */
 801                                                         if (accumulate) {
 802                                                                 /* done */
 803                                                                 break;
 804                                                         } else {
 805                                                                 accumulate = true;
 806                                                         }
 807                                                 } else if (_selection.selected (*i)) {
 808                                                         /* hit selected strip. if currently accumulating others,
 809                                                            we're done. if not accumulating others, start doing so.
 810                                                         */
 811                                                         found_another = true;
 812                                                         if (accumulate) {
 813                                                                 /* done */
 814                                                                 break;
 815                                                         } else {
 816                                                                 accumulate = true;
 817                                                         }
 818                                                 } else {
 819                                                         if (accumulate) {
 820                                                                 tmp.push_back (*i);
 821                                                         }
 822                                                 }
 823                                         }
 824
 825                                         if (found_another) {
 826                                                 for (vector<MixerStrip*>::iterator i = tmp.begin(); i != tmp.end(); ++i) {
 827                                                         _selection.add (*i);
 828                                                 }
 829                                         } else
 830                                                 _selection.set (strip);  //user wants to start a range selection, but there aren't any others selected yet
 831                                 }
 832
 833                         } else {
 834                                 _selection.set (strip);
 835                         }
 836                 }
 837         }
 838
 839         return true;
 840 }
 841
 842 void
 843 Mixer_UI::set_session (Session* sess)
 844 {
 845         SessionHandlePtr::set_session (sess);
 846
 847         if (_plugin_selector) {
 848                 _plugin_selector->set_session (_session);
 849         }
 850
 851         _group_tabs->set_session (sess);
 852
 853         if (!_session) {
 854                 return;
 855         }
 856
 857         refill_favorite_plugins();
 858
 859         XMLNode* node = ARDOUR_UI::instance()->mixer_settings();
 860         set_state (*node, 0);
 861
 862         update_title ();
 863
 864         initial_track_display ();
 865
 866         _session->RouteAdded.connect (_session_connections, invalidator (*this), boost::bind (&Mixer_UI::add_strips, this, _1), gui_context());
 867         _session->route_group_added.connect (_session_connections, invalidator (*this), boost::bind (&Mixer_UI::add_route_group, this, _1), gui_context());
 868         _session->route_group_removed.connect (_session_connections, invalidator (*this), boost::bind (&Mixer_UI::route_groups_changed, this), gui_context());
 869         _session->route_groups_reordered.connect (_session_connections, invalidator (*this), boost::bind (&Mixer_UI::route_groups_changed, this), gui_context());
 870         _session->config.ParameterChanged.connect (_session_connections, invalidator (*this), boost::bind (&Mixer_UI::parameter_changed, this, _1), gui_context());
 871         _session->DirtyChanged.connect (_session_connections, invalidator (*this), boost::bind (&Mixer_UI::update_title, this), gui_context());
 872         _session->StateSaved.connect (_session_connections, invalidator (*this), boost::bind (&Mixer_UI::update_title, this), gui_context());
 873
 874         Config->ParameterChanged.connect (*this, invalidator (*this), boost::bind (&Mixer_UI::parameter_changed, this, _1), gui_context ());
 875
 876         route_groups_changed ();
 877
 878         if (_visible) {
 879                 show_window();
 880         }
 881         start_updating ();
 882 }
 883
 884 void
 885 Mixer_UI::session_going_away ()
 886 {
 887         ENSURE_GUI_THREAD (*this, &Mixer_UI::session_going_away);
 888
 889         _in_group_rebuild_or_clear = true;
 890         group_model->clear ();
 891         _in_group_rebuild_or_clear = false;
 892
 893         _selection.clear ();
 894         track_model->clear ();
 895
 896         for (list<MixerStrip *>::iterator i = strips.begin(); i != strips.end(); ++i) {
 897                 delete (*i);
 898         }
 899
 900         if (_monitor_section) {
 901                 _monitor_section->tearoff().hide_visible ();
 902         }
 903
 904         monitor_section_detached ();
 905
 906         strips.clear ();
 907
 908         stop_updating ();
 909
 910         SessionHandlePtr::session_going_away ();
 911
 912         _session = 0;
 913         update_title ();
 914 }
 915
 916 void
 917 Mixer_UI::track_visibility_changed (std::string const & path)
 918 {
 919         if (_session && _session->deletion_in_progress()) {
 920                 return;
 921         }
 922
 923         TreeIter iter;
 924
 925         if ((iter = track_model->get_iter (path))) {
 926                 MixerStrip* strip = (*iter)[track_columns.strip];
 927                 if (strip) {
 928                         bool visible = (*iter)[track_columns.visible];
 929
 930                         if (strip->set_marked_for_display (!visible)) {
 931                                 update_track_visibility ();
 932                         }
 933                 }
 934         }
 935 }
 936
 937 void
 938 Mixer_UI::update_track_visibility ()
 939 {
 940         TreeModel::Children rows = track_model->children();
 941         TreeModel::Children::iterator i;
 942
 943         {
 944                 Unwinder<bool> uw (no_track_list_redisplay, true);
 945
 946                 for (i = rows.begin(); i != rows.end(); ++i) {
 947                         MixerStrip *strip = (*i)[track_columns.strip];
 948                         (*i)[track_columns.visible] = strip->marked_for_display ();
 949                 }
 950
 951                 /* force route order keys catch up with visibility changes
 952                  */
 953
 954                 sync_order_keys_from_treeview ();
 955         }
 956
 957         redisplay_track_list ();
 958 }
 959
 960 void
 961 Mixer_UI::show_strip (MixerStrip* ms)
 962 {
 963         TreeModel::Children rows = track_model->children();
 964         TreeModel::Children::iterator i;
 965
 966         for (i = rows.begin(); i != rows.end(); ++i) {
 967
 968                 MixerStrip* strip = (*i)[track_columns.strip];
 969                 if (strip == ms) {
 970                         (*i)[track_columns.visible] = true;
 971                         redisplay_track_list ();
 972                         break;
 973                 }
 974         }
 975 }
 976
 977 void
 978 Mixer_UI::hide_strip (MixerStrip* ms)
 979 {
 980         TreeModel::Children rows = track_model->children();
 981         TreeModel::Children::iterator i;
 982
 983         for (i = rows.begin(); i != rows.end(); ++i) {
 984
 985                 MixerStrip* strip = (*i)[track_columns.strip];
 986                 if (strip == ms) {
 987                         (*i)[track_columns.visible] = false;
 988                         redisplay_track_list ();
 989                         break;
 990                 }
 991         }
 992 }
 993
 994 gint
 995 Mixer_UI::start_updating ()
 996 {
 997     fast_screen_update_connection = Timers::super_rapid_connect (sigc::mem_fun(*this, &Mixer_UI::fast_update_strips));
 998     return 0;
 999 }
1000
1001 gint
1002 Mixer_UI::stop_updating ()
1003 {
1004     fast_screen_update_connection.disconnect();
1005     return 0;
1006 }
1007
1008 void
1009 Mixer_UI::fast_update_strips ()
1010 {
1011         if (_content.is_mapped () && _session) {
1012                 for (list<MixerStrip *>::iterator i = strips.begin(); i != strips.end(); ++i) {
1013                         (*i)->fast_update ();
1014                 }
1015         }
1016 }
1017
1018 void
1019 Mixer_UI::show_window ()
1020 {
1021         Tabbable::show_window ();
1022
1023         /* show/hide group tabs as required */
1024         parameter_changed ("show-group-tabs");
1025
1026         /* now reset each strips width so the right widgets are shown */
1027         MixerStrip* ms;
1028
1029         TreeModel::Children rows = track_model->children();
1030         TreeModel::Children::iterator ri;
1031
1032         for (ri = rows.begin(); ri != rows.end(); ++ri) {
1033                 ms = (*ri)[track_columns.strip];
1034                 ms->set_width_enum (ms->get_width_enum (), ms->width_owner());
1035                 /* Fix visibility of mixer strip stuff */
1036                 ms->parameter_changed (X_("mixer-element-visibility"));
1037         }
1038
1039         /* force focus into main area */
1040         scroller_base.grab_focus ();
1041 }
1042
1043 void
1044 Mixer_UI::set_all_strips_visibility (bool yn)
1045 {
1046         TreeModel::Children rows = track_model->children();
1047         TreeModel::Children::iterator i;
1048
1049         {
1050                 Unwinder<bool> uw (no_track_list_redisplay, true);
1051
1052                 for (i = rows.begin(); i != rows.end(); ++i) {
1053
1054                         TreeModel::Row row = (*i);
1055                         MixerStrip* strip = row[track_columns.strip];
1056
1057                         if (strip == 0) {
1058                                 continue;
1059                         }
1060
1061                         if (strip->route()->is_master() || strip->route()->is_monitor()) {
1062                                 continue;
1063                         }
1064
1065                         (*i)[track_columns.visible] = yn;
1066                 }
1067         }
1068
1069         redisplay_track_list ();
1070 }
1071
1072
1073 void
1074 Mixer_UI::set_all_audio_midi_visibility (int tracks, bool yn)
1075 {
1076         TreeModel::Children rows = track_model->children();
1077         TreeModel::Children::iterator i;
1078
1079         {
1080                 Unwinder<bool> uw (no_track_list_redisplay, true);
1081
1082                 for (i = rows.begin(); i != rows.end(); ++i) {
1083                         TreeModel::Row row = (*i);
1084                         MixerStrip* strip = row[track_columns.strip];
1085
1086                         if (strip == 0) {
1087                                 continue;
1088                         }
1089
1090                         if (strip->route()->is_master() || strip->route()->is_monitor()) {
1091                                 continue;
1092                         }
1093
1094                         boost::shared_ptr<AudioTrack> at = strip->audio_track();
1095                         boost::shared_ptr<MidiTrack> mt = strip->midi_track();
1096
1097                         switch (tracks) {
1098                         case 0:
1099                                 (*i)[track_columns.visible] = yn;
1100                                 break;
1101
1102                         case 1:
1103                                 if (at) { /* track */
1104                                         (*i)[track_columns.visible] = yn;
1105                                 }
1106                                 break;
1107
1108                         case 2:
1109                                 if (!at && !mt) { /* bus */
1110                                         (*i)[track_columns.visible] = yn;
1111                                 }
1112                                 break;
1113
1114                         case 3:
1115                                 if (mt) { /* midi-track */
1116                                         (*i)[track_columns.visible] = yn;
1117                                 }
1118                                 break;
1119                         }
1120                 }
1121         }
1122
1123         redisplay_track_list ();
1124 }
1125
1126 void
1127 Mixer_UI::hide_all_routes ()
1128 {
1129         set_all_strips_visibility (false);
1130 }
1131
1132 void
1133 Mixer_UI::show_all_routes ()
1134 {
1135         set_all_strips_visibility (true);
1136 }
1137
1138 void
1139 Mixer_UI::show_all_audiobus ()
1140 {
1141         set_all_audio_midi_visibility (2, true);
1142 }
1143 void
1144 Mixer_UI::hide_all_audiobus ()
1145 {
1146         set_all_audio_midi_visibility (2, false);
1147 }
1148
1149 void
1150 Mixer_UI::show_all_audiotracks()
1151 {
1152         set_all_audio_midi_visibility (1, true);
1153 }
1154 void
1155 Mixer_UI::hide_all_audiotracks ()
1156 {
1157         set_all_audio_midi_visibility (1, false);
1158 }
1159
1160 void
1161 Mixer_UI::show_all_miditracks()
1162 {
1163         set_all_audio_midi_visibility (3, true);
1164 }
1165 void
1166 Mixer_UI::hide_all_miditracks ()
1167 {
1168         set_all_audio_midi_visibility (3, false);
1169 }
1170
1171
1172 void
1173 Mixer_UI::track_list_reorder (const TreeModel::Path&, const TreeModel::iterator&, int* /*new_order*/)
1174 {
1175         DEBUG_TRACE (DEBUG::OrderKeys, "mixer UI treeview reordered\n");
1176         sync_order_keys_from_treeview ();
1177 }
1178
1179 void
1180 Mixer_UI::track_list_delete (const Gtk::TreeModel::Path&)
1181 {
1182         /* this happens as the second step of a DnD within the treeview as well
1183            as when a row/route is actually deleted.
1184
1185            if it was a deletion then we have to force a redisplay because
1186            order keys may not have changed.
1187         */
1188
1189         DEBUG_TRACE (DEBUG::OrderKeys, "mixer UI treeview row deleted\n");
1190         sync_order_keys_from_treeview ();
1191
1192         if (_route_deletion_in_progress) {
1193                 redisplay_track_list ();
1194         }
1195 }
1196
1197 void
1198 Mixer_UI::redisplay_track_list ()
1199 {
1200         TreeModel::Children rows = track_model->children();
1201         TreeModel::Children::iterator i;
1202
1203         if (no_track_list_redisplay) {
1204                 return;
1205         }
1206
1207         for (i = rows.begin(); i != rows.end(); ++i) {
1208
1209                 MixerStrip* strip = (*i)[track_columns.strip];
1210
1211                 if (strip == 0) {
1212                         /* we're in the middle of changing a row, don't worry */
1213                         continue;
1214                 }
1215
1216                 bool const visible = (*i)[track_columns.visible];
1217
1218                 if (visible) {
1219                         strip->set_gui_property ("visible", true);
1220
1221                         if (strip->packed()) {
1222
1223                                 if (strip->route()->is_master() || strip->route()->is_monitor()) {
1224                                         out_packer.reorder_child (*strip, -1);
1225
1226                                 } else {
1227                                         strip_packer.reorder_child (*strip, -1); /* put at end */
1228                                 }
1229
1230                         } else {
1231
1232                                 if (strip->route()->is_master() || strip->route()->is_monitor()) {
1233                                         out_packer.pack_start (*strip, false, false);
1234                                 } else {
1235                                         strip_packer.pack_start (*strip, false, false);
1236                                 }
1237                                 strip->set_packed (true);
1238                         }
1239
1240                 } else {
1241
1242                         strip->set_gui_property ("visible", false);
1243
1244                         if (strip->route()->is_master() || strip->route()->is_monitor()) {
1245                                 /* do nothing, these cannot be hidden */
1246                         } else {
1247                                 if (strip->packed()) {
1248                                         strip_packer.remove (*strip);
1249                                         strip->set_packed (false);
1250                                 }
1251                         }
1252                 }
1253         }
1254
1255         _group_tabs->set_dirty ();
1256 }
1257
1258 void
1259 Mixer_UI::strip_width_changed ()
1260 {
1261         _group_tabs->set_dirty ();
1262
1263 #ifdef GTKOSX
1264         TreeModel::Children rows = track_model->children();
1265         TreeModel::Children::iterator i;
1266         long order;
1267
1268         for (order = 0, i = rows.begin(); i != rows.end(); ++i, ++order) {
1269                 MixerStrip* strip = (*i)[track_columns.strip];
1270
1271                 if (strip == 0) {
1272                         continue;
1273                 }
1274
1275                 bool visible = (*i)[track_columns.visible];
1276
1277                 if (visible) {
1278                         strip->queue_draw();
1279                 }
1280         }
1281 #endif
1282
1283 }
1284
1285 void
1286 Mixer_UI::initial_track_display ()
1287 {
1288         boost::shared_ptr<RouteList> routes = _session->get_routes();
1289         RouteList copy (*routes);
1290         ARDOUR::SignalOrderRouteSorter sorter;
1291
1292         copy.sort (sorter);
1293
1294         {
1295                 Unwinder<bool> uw1 (no_track_list_redisplay, true);
1296                 Unwinder<bool> uw2 (ignore_reorder, true);
1297
1298                 track_model->clear ();
1299                 add_strips (copy);
1300         }
1301
1302         _session->sync_order_keys ();
1303
1304         redisplay_track_list ();
1305 }
1306
1307 void
1308 Mixer_UI::show_track_list_menu ()
1309 {
1310         if (track_menu == 0) {
1311                 build_track_menu ();
1312         }
1313
1314         track_menu->popup (1, gtk_get_current_event_time());
1315 }
1316
1317 bool
1318 Mixer_UI::track_display_button_press (GdkEventButton* ev)
1319 {
1320         if (Keyboard::is_context_menu_event (ev)) {
1321                 show_track_list_menu ();
1322                 return true;
1323         }
1324
1325         return false;
1326 }
1327
1328 void
1329 Mixer_UI::build_track_menu ()
1330 {
1331         using namespace Menu_Helpers;
1332         using namespace Gtk;
1333
1334         track_menu = new Menu;
1335         track_menu->set_name ("ArdourContextMenu");
1336         MenuList& items = track_menu->items();
1337
1338         items.push_back (MenuElem (_("Show All"), sigc::mem_fun(*this, &Mixer_UI::show_all_routes)));
1339         items.push_back (MenuElem (_("Hide All"), sigc::mem_fun(*this, &Mixer_UI::hide_all_routes)));
1340         items.push_back (MenuElem (_("Show All Audio Tracks"), sigc::mem_fun(*this, &Mixer_UI::show_all_audiotracks)));
1341         items.push_back (MenuElem (_("Hide All Audio Tracks"), sigc::mem_fun(*this, &Mixer_UI::hide_all_audiotracks)));
1342         items.push_back (MenuElem (_("Show All Audio Busses"), sigc::mem_fun(*this, &Mixer_UI::show_all_audiobus)));
1343         items.push_back (MenuElem (_("Hide All Audio Busses"), sigc::mem_fun(*this, &Mixer_UI::hide_all_audiobus)));
1344         items.push_back (MenuElem (_("Show All Midi Tracks"), sigc::mem_fun (*this, &Mixer_UI::show_all_miditracks)));
1345         items.push_back (MenuElem (_("Hide All Midi Tracks"), sigc::mem_fun (*this, &Mixer_UI::hide_all_miditracks)));
1346
1347 }
1348
1349 void
1350 Mixer_UI::strip_property_changed (const PropertyChange& what_changed, MixerStrip* mx)
1351 {
1352         if (!what_changed.contains (ARDOUR::Properties::name)) {
1353                 return;
1354         }
1355
1356         ENSURE_GUI_THREAD (*this, &Mixer_UI::strip_name_changed, what_changed, mx)
1357
1358         TreeModel::Children rows = track_model->children();
1359         TreeModel::Children::iterator i;
1360
1361         for (i = rows.begin(); i != rows.end(); ++i) {
1362                 if ((*i)[track_columns.strip] == mx) {
1363                         (*i)[track_columns.text] = mx->route()->name();
1364                         return;
1365                 }
1366         }
1367
1368         error << _("track display list item for renamed strip not found!") << endmsg;
1369 }
1370
1371 bool
1372 Mixer_UI::group_display_button_press (GdkEventButton* ev)
1373 {
1374         TreeModel::Path path;
1375         TreeViewColumn* column;
1376         int cellx;
1377         int celly;
1378
1379         if (!group_display.get_path_at_pos ((int)ev->x, (int)ev->y, path, column, cellx, celly)) {
1380                 _group_tabs->get_menu(0)->popup (1, ev->time);
1381                 return true;
1382         }
1383
1384         TreeIter iter = group_model->get_iter (path);
1385         if (!iter) {
1386                 _group_tabs->get_menu(0)->popup (1, ev->time);
1387                 return true;
1388         }
1389
1390         RouteGroup* group = (*iter)[group_columns.group];
1391
1392         if (Keyboard::is_context_menu_event (ev)) {
1393                 _group_tabs->get_menu(group)->popup (1, ev->time);
1394                 return true;
1395         }
1396
1397         switch (GPOINTER_TO_UINT (column->get_data (X_("colnum")))) {
1398         case 0:
1399                 if (Keyboard::is_edit_event (ev)) {
1400                         if (group) {
1401                                 // edit_route_group (group);
1402 #ifdef GTKOSX
1403                                 group_display.queue_draw();
1404 #endif
1405                                 return true;
1406                         }
1407                 }
1408                 break;
1409
1410         case 1:
1411         {
1412                 bool visible = (*iter)[group_columns.visible];
1413                 (*iter)[group_columns.visible] = !visible;
1414 #ifdef GTKOSX
1415                 group_display.queue_draw();
1416 #endif
1417                 return true;
1418         }
1419
1420         default:
1421                 break;
1422         }
1423
1424         return false;
1425  }
1426
1427 void
1428 Mixer_UI::activate_all_route_groups ()
1429 {
1430         _session->foreach_route_group (sigc::bind (sigc::mem_fun (*this, &Mixer_UI::set_route_group_activation), true));
1431 }
1432
1433 void
1434 Mixer_UI::disable_all_route_groups ()
1435 {
1436         _session->foreach_route_group (sigc::bind (sigc::mem_fun (*this, &Mixer_UI::set_route_group_activation), false));
1437 }
1438
1439 void
1440 Mixer_UI::route_groups_changed ()
1441 {
1442         ENSURE_GUI_THREAD (*this, &Mixer_UI::route_groups_changed);
1443
1444         _in_group_rebuild_or_clear = true;
1445
1446         /* just rebuild the while thing */
1447
1448         group_model->clear ();
1449
1450 #if 0
1451         /* this is currently not used,
1452          * Mixer_UI::group_display_button_press() has a case for it,
1453          * and a commented edit_route_group() but that's n/a since 2011.
1454          *
1455          * This code is left as reminder that
1456          * row[group_columns.group] = 0 has special meaning.
1457          */
1458         {
1459                 TreeModel::Row row;
1460                 row = *(group_model->append());
1461                 row[group_columns.visible] = true;
1462                 row[group_columns.text] = (_("-all-"));
1463                 row[group_columns.group] = 0;
1464         }
1465 #endif
1466
1467         _session->foreach_route_group (sigc::mem_fun (*this, &Mixer_UI::add_route_group));
1468
1469         _group_tabs->set_dirty ();
1470         _in_group_rebuild_or_clear = false;
1471 }
1472
1473 void
1474 Mixer_UI::new_route_group ()
1475 {
1476         RouteList rl;
1477
1478         _group_tabs->run_new_group_dialog (rl);
1479 }
1480
1481 void
1482 Mixer_UI::remove_selected_route_group ()
1483 {
1484         Glib::RefPtr<TreeSelection> selection = group_display.get_selection();
1485         TreeView::Selection::ListHandle_Path rows = selection->get_selected_rows ();
1486
1487         if (rows.empty()) {
1488                 return;
1489         }
1490
1491         TreeView::Selection::ListHandle_Path::iterator i = rows.begin();
1492         TreeIter iter;
1493
1494         /* selection mode is single, so rows.begin() is it */
1495
1496         if ((iter = group_model->get_iter (*i))) {
1497
1498                 RouteGroup* rg = (*iter)[group_columns.group];
1499
1500                 if (rg) {
1501                         _session->remove_route_group (*rg);
1502                 }
1503         }
1504 }
1505
1506 void
1507 Mixer_UI::route_group_property_changed (RouteGroup* group, const PropertyChange& change)
1508 {
1509         if (in_group_row_change) {
1510                 return;
1511         }
1512
1513         /* force an update of any mixer strips that are using this group,
1514            otherwise mix group names don't change in mixer strips
1515         */
1516
1517         for (list<MixerStrip *>::iterator i = strips.begin(); i != strips.end(); ++i) {
1518                 if ((*i)->route_group() == group) {
1519                         (*i)->route_group_changed();
1520                 }
1521         }
1522
1523         TreeModel::iterator i;
1524         TreeModel::Children rows = group_model->children();
1525         Glib::RefPtr<TreeSelection> selection = group_display.get_selection();
1526
1527         in_group_row_change = true;
1528
1529         for (i = rows.begin(); i != rows.end(); ++i) {
1530                 if ((*i)[group_columns.group] == group) {
1531                         (*i)[group_columns.visible] = !group->is_hidden ();
1532                         (*i)[group_columns.text] = group->name ();
1533                         break;
1534                 }
1535         }
1536
1537         in_group_row_change = false;
1538
1539         if (change.contains (Properties::name)) {
1540                 _group_tabs->set_dirty ();
1541         }
1542
1543         for (list<MixerStrip*>::iterator j = strips.begin(); j != strips.end(); ++j) {
1544                 if ((*j)->route_group() == group) {
1545                         if (group->is_hidden ()) {
1546                                 hide_strip (*j);
1547                         } else {
1548                                 show_strip (*j);
1549                         }
1550                 }
1551         }
1552 }
1553
1554 void
1555 Mixer_UI::show_mixer_list (bool yn)
1556 {
1557         if (yn) {
1558                 list_vpacker.show ();
1559
1560                 //if user wants to show the pane, we should make sure that it is wide enough to be visible
1561                 int width = list_hpane.get_position();
1562                 if (width < 40)
1563                         list_hpane.set_position(40);
1564         } else {
1565                 list_vpacker.hide ();
1566         }
1567
1568         _show_mixer_list = yn;
1569 }
1570
1571 void
1572 Mixer_UI::show_monitor_section (bool yn)
1573 {
1574         if (!monitor_section()) {
1575                 return;
1576         }
1577         if (monitor_section()->tearoff().torn_off()) {
1578                 return;
1579         }
1580
1581         if (yn) {
1582                 monitor_section()->tearoff().show();
1583         } else {
1584                 monitor_section()->tearoff().hide();
1585         }
1586 }
1587
1588 void
1589 Mixer_UI::route_group_name_edit (const std::string& path, const std::string& new_text)
1590 {
1591         RouteGroup* group;
1592         TreeIter iter;
1593
1594         if ((iter = group_model->get_iter (path))) {
1595
1596                 if ((group = (*iter)[group_columns.group]) == 0) {
1597                         return;
1598                 }
1599
1600                 if (new_text != group->name()) {
1601                         group->set_name (new_text);
1602                 }
1603         }
1604 }
1605
1606 void
1607 Mixer_UI::route_group_row_change (const Gtk::TreeModel::Path&, const Gtk::TreeModel::iterator& iter)
1608 {
1609         RouteGroup* group;
1610
1611         if (in_group_row_change) {
1612                 return;
1613         }
1614
1615         if ((group = (*iter)[group_columns.group]) == 0) {
1616                 return;
1617         }
1618
1619         std::string name = (*iter)[group_columns.text];
1620
1621         if (name != group->name()) {
1622                 group->set_name (name);
1623         }
1624
1625         bool hidden = !(*iter)[group_columns.visible];
1626
1627         if (hidden != group->is_hidden ()) {
1628                 group->set_hidden (hidden, this);
1629         }
1630 }
1631
1632 /** Called when a group model row is deleted, but also when the model is
1633  *  reordered by a user drag-and-drop; the latter is what we are
1634  *  interested in here.
1635  */
1636 void
1637 Mixer_UI::route_group_row_deleted (Gtk::TreeModel::Path const &)
1638 {
1639         if (_in_group_rebuild_or_clear) {
1640                 return;
1641         }
1642
1643         /* Re-write the session's route group list so that the new order is preserved */
1644
1645         list<RouteGroup*> new_list;
1646
1647         Gtk::TreeModel::Children children = group_model->children();
1648         for (Gtk::TreeModel::Children::iterator i = children.begin(); i != children.end(); ++i) {
1649                 RouteGroup* g = (*i)[group_columns.group];
1650                 if (g) {
1651                         new_list.push_back (g);
1652                 }
1653         }
1654
1655         _session->reorder_route_groups (new_list);
1656 }
1657
1658
1659 void
1660 Mixer_UI::add_route_group (RouteGroup* group)
1661 {
1662         ENSURE_GUI_THREAD (*this, &Mixer_UI::add_route_group, group)
1663         bool focus = false;
1664
1665         in_group_row_change = true;
1666
1667         TreeModel::Row row = *(group_model->append());
1668         row[group_columns.visible] = !group->is_hidden ();
1669         row[group_columns.group] = group;
1670         if (!group->name().empty()) {
1671                 row[group_columns.text] = group->name();
1672         } else {
1673                 row[group_columns.text] = _("unnamed");
1674                 focus = true;
1675         }
1676
1677         group->PropertyChanged.connect (*this, invalidator (*this), boost::bind (&Mixer_UI::route_group_property_changed, this, group, _1), gui_context());
1678
1679         if (focus) {
1680                 TreeViewColumn* col = group_display.get_column (0);
1681                 CellRendererText* name_cell = dynamic_cast<CellRendererText*>(group_display.get_column_cell_renderer (0));
1682                 group_display.set_cursor (group_model->get_path (row), *col, *name_cell, true);
1683         }
1684
1685         _group_tabs->set_dirty ();
1686
1687         in_group_row_change = false;
1688 }
1689
1690 bool
1691 Mixer_UI::strip_scroller_button_release (GdkEventButton* ev)
1692 {
1693         using namespace Menu_Helpers;
1694
1695         if (Keyboard::is_context_menu_event (ev)) {
1696                 // ARDOUR_UI::instance()->add_route (this);
1697                 return true;
1698         }
1699
1700         return false;
1701 }
1702
1703 void
1704 Mixer_UI::set_strip_width (Width w, bool save)
1705 {
1706         _strip_width = w;
1707
1708         for (list<MixerStrip*>::iterator i = strips.begin(); i != strips.end(); ++i) {
1709                 (*i)->set_width_enum (w, save ? (*i)->width_owner() : this);
1710         }
1711 }
1712
1713
1714 struct PluginStateSorter {
1715 public:
1716         bool operator() (PluginInfoPtr a, PluginInfoPtr b) const {
1717                 std::list<std::string>::const_iterator aiter = std::find(_user.begin(), _user.end(), (*a).unique_id);
1718                 std::list<std::string>::const_iterator biter = std::find(_user.begin(), _user.end(), (*b).unique_id);
1719                 if (aiter != _user.end() && biter != _user.end()) {
1720                         return std::distance (_user.begin(), aiter)  < std::distance (_user.begin(), biter);
1721                 }
1722                 if (aiter != _user.end()) {
1723                         return true;
1724                 }
1725                 if (biter != _user.end()) {
1726                         return false;
1727                 }
1728                 return ARDOUR::cmp_nocase((*a).name, (*b).name) == -1;
1729         }
1730
1731         PluginStateSorter(std::list<std::string> user) : _user (user)  {}
1732 private:
1733         std::list<std::string> _user;
1734 };
1735
1736 int
1737 Mixer_UI::set_state (const XMLNode& node, int version)
1738 {
1739         const XMLProperty* prop;
1740         XMLNode* geometry;
1741
1742         m_width = default_width;
1743         m_height = default_height;
1744         m_root_x = 1;
1745         m_root_y = 1;
1746
1747         if ((geometry = find_named_node (node, "geometry")) != 0) {
1748
1749                 /* if there's a geometry node, we have our own window */
1750
1751                 create_own_window ();
1752                 Gtk::Notebook* notebook = (Gtk::Notebook*) _parent_window->get_child();
1753                 Gtk::Widget* parent = get_parent();
1754                 if (parent) {
1755                         ((Gtk::Container*)parent)->remove (*this);
1756                 }
1757                 notebook->append_page (*this, _("Mixer"));
1758
1759                 XMLProperty* prop;
1760
1761                 if ((prop = geometry->property("x_size")) == 0) {
1762                         prop = geometry->property ("x-size");
1763                 }
1764                 if (prop) {
1765                         m_width = atoi(prop->value());
1766                 }
1767                 if ((prop = geometry->property("y_size")) == 0) {
1768                         prop = geometry->property ("y-size");
1769                 }
1770                 if (prop) {
1771                         m_height = atoi(prop->value());
1772                 }
1773
1774                 if ((prop = geometry->property ("x_pos")) == 0) {
1775                         prop = geometry->property ("x-pos");
1776                 }
1777                 if (prop) {
1778                         m_root_x = atoi (prop->value());
1779
1780                 }
1781                 if ((prop = geometry->property ("y_pos")) == 0) {
1782                         prop = geometry->property ("y-pos");
1783                 }
1784                 if (prop) {
1785                         m_root_y = atoi (prop->value());
1786                 }
1787         }
1788
1789         if ((prop = node.property ("narrow-strips"))) {
1790                 if (string_is_affirmative (prop->value())) {
1791                         set_strip_width (Narrow);
1792                 } else {
1793                         set_strip_width (Wide);
1794                 }
1795         }
1796
1797         if ((prop = node.property ("show-mixer"))) {
1798                 if (string_is_affirmative (prop->value())) {
1799                        _visible = true;
1800                 }
1801         }
1802
1803         if ((prop = node.property ("maximised"))) {
1804                 bool yn = string_is_affirmative (prop->value());
1805                 Glib::RefPtr<Action> act = ActionManager::get_action (X_("Common"), X_("ToggleMaximalMixer"));
1806                 assert (act);
1807                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
1808                 bool fs = tact && tact->get_active();
1809                 if (yn ^ fs) {
1810                         ActionManager::do_action ("Common", "ToggleMaximalMixer");
1811                 }
1812         }
1813
1814         if ((prop = node.property ("show-mixer-list"))) {
1815                 bool yn = string_is_affirmative (prop->value());
1816                 Glib::RefPtr<Action> act = ActionManager::get_action (X_("Common"), X_("ToggleMixerList"));
1817                 assert (act);
1818                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
1819
1820                 /* do it twice to force the change */
1821                 tact->set_active (!yn);
1822                 tact->set_active (yn);
1823         }
1824
1825
1826         XMLNode* plugin_order;
1827         if ((plugin_order = find_named_node (node, "PluginOrder")) != 0) {
1828                 store_current_favorite_order ();
1829                 std::list<string> order;
1830                 const XMLNodeList& kids = plugin_order->children("PluginInfo");
1831                 XMLNodeConstIterator i;
1832                 for (i = kids.begin(); i != kids.end(); ++i) {
1833                         if ((prop = (*i)->property ("unique-id"))) {
1834                                 std::string unique_id = prop->value();
1835                                 order.push_back (unique_id);
1836                                 if ((prop = (*i)->property ("expanded"))) {
1837                                         favorite_ui_state[unique_id] = string_is_affirmative (prop->value());
1838                                 }
1839                         }
1840                 }
1841                 PluginStateSorter cmp (order);
1842                 favorite_order.sort (cmp);
1843                 sync_treeview_from_favorite_order ();
1844         }
1845         return 0;
1846 }
1847
1848 XMLNode&
1849 Mixer_UI::get_state ()
1850 {
1851         XMLNode* node = new XMLNode ("Mixer");
1852
1853         if (_parent_window && _parent_window->is_realized() ) {
1854                 Glib::RefPtr<Gdk::Window> win = _parent_window->get_window();
1855
1856                 get_window_pos_and_size ();
1857
1858                 XMLNode* geometry = new XMLNode ("geometry");
1859                 char buf[32];
1860                 snprintf(buf, sizeof(buf), "%d", m_width);
1861                 geometry->add_property(X_("x_size"), string(buf));
1862                 snprintf(buf, sizeof(buf), "%d", m_height);
1863                 geometry->add_property(X_("y_size"), string(buf));
1864                 snprintf(buf, sizeof(buf), "%d", m_root_x);
1865                 geometry->add_property(X_("x_pos"), string(buf));
1866                 snprintf(buf, sizeof(buf), "%d", m_root_y);
1867                 geometry->add_property(X_("y_pos"), string(buf));
1868
1869                 // written only for compatibility, they are not used.
1870                 snprintf(buf, sizeof(buf), "%d", 0);
1871                 geometry->add_property(X_("x_off"), string(buf));
1872                 snprintf(buf, sizeof(buf), "%d", 0);
1873                 geometry->add_property(X_("y_off"), string(buf));
1874
1875                 snprintf(buf,sizeof(buf), "%d",gtk_paned_get_position (static_cast<Paned*>(&rhs_pane1)->gobj()));
1876                 geometry->add_property(X_("mixer_rhs_pane1_pos"), string(buf));
1877                 snprintf(buf,sizeof(buf), "%d",gtk_paned_get_position (static_cast<Paned*>(&rhs_pane2)->gobj()));
1878                 geometry->add_property(X_("mixer_rhs_pane2_pos"), string(buf));
1879                 snprintf(buf,sizeof(buf), "%d",gtk_paned_get_position (static_cast<Paned*>(&list_hpane)->gobj()));
1880                 geometry->add_property(X_("mixer_list_hpane_pos"), string(buf));
1881
1882                 node->add_child_nocopy (*geometry);
1883         }
1884
1885         node->add_property ("narrow-strips", _strip_width == Narrow ? "yes" : "no");
1886         node->add_property ("show-mixer", _visible ? "yes" : "no");
1887         node->add_property ("show-mixer-list", _show_mixer_list ? "yes" : "no");
1888         node->add_property ("maximised", _maximised ? "yes" : "no");
1889
1890         store_current_favorite_order ();
1891         XMLNode* plugin_order = new XMLNode ("PluginOrder");
1892         int cnt = 0;
1893         for (PluginInfoList::const_iterator i = favorite_order.begin(); i != favorite_order.end(); ++i, ++cnt) {
1894                         XMLNode* p = new XMLNode ("PluginInfo");
1895                         p->add_property ("sort", cnt);
1896                         p->add_property ("unique-id", (*i)->unique_id);
1897                         if (favorite_ui_state.find ((*i)->unique_id) != favorite_ui_state.end ()) {
1898                                 p->add_property ("expanded", favorite_ui_state[(*i)->unique_id]);
1899                         }
1900                         plugin_order->add_child_nocopy (*p);
1901                 ;
1902         }
1903         node->add_child_nocopy (*plugin_order);
1904         return *node;
1905 }
1906
1907
1908 void
1909 Mixer_UI::pane_allocation_handler (Allocation&, Gtk::Paned* which)
1910 {
1911         int pos;
1912         XMLProperty* prop = 0;
1913         XMLNode* node = ARDOUR_UI::instance()->mixer_settings();
1914         XMLNode* geometry;
1915         int height;
1916         static int32_t done[3] = { 0, 0, 0 };
1917
1918         height = default_height;
1919
1920         if ((geometry = find_named_node (*node, "geometry")) != 0) {
1921
1922                 if ((prop = geometry->property ("y_size")) == 0) {
1923                         prop = geometry->property ("y-size");
1924                 }
1925                 if (prop) {
1926                         height = atoi (prop->value());
1927                 }
1928         }
1929
1930         if (which == static_cast<Gtk::Paned*> (&rhs_pane1)) {
1931
1932                 if (done[0]) {
1933                         return;
1934                 }
1935
1936                 if (!geometry || (prop = geometry->property("mixer-rhs-pane1-pos")) == 0) {
1937                         pos = height / 3;
1938                 } else {
1939                         pos = atoi (prop->value());
1940                 }
1941
1942                 if ((done[0] = GTK_WIDGET(rhs_pane1.gobj())->allocation.height > pos)) {
1943                         rhs_pane1.set_position (pos);
1944                 }
1945
1946         } else if (which == static_cast<Gtk::Paned*> (&rhs_pane2)) {
1947                 if (done[1]) {
1948                         return;
1949                 }
1950
1951                 if (!geometry || (prop = geometry->property("mixer-rhs-pane2-pos")) == 0) {
1952                         pos = 2 * height / 3;
1953                 } else {
1954                         pos = atoi (prop->value());
1955                 }
1956
1957                 if ((done[1] = GTK_WIDGET(rhs_pane2.gobj())->allocation.height > pos)) {
1958                         rhs_pane2.set_position (pos);
1959                 }
1960         } else if (which == static_cast<Gtk::Paned*> (&list_hpane)) {
1961
1962                 if (done[2]) {
1963                         return;
1964                 }
1965
1966                 if (!geometry || (prop = geometry->property("mixer-list-hpane-pos")) == 0) {
1967                         pos = std::max ((float)100, rintf ((float) 125 * UIConfiguration::instance().get_ui_scale()));
1968                 } else {
1969                         pos = max (36, atoi (prop->value ()));
1970                 }
1971
1972                 if ((done[2] = GTK_WIDGET(list_hpane.gobj())->allocation.width > pos)) {
1973                         list_hpane.set_position (pos);
1974                 }
1975         }
1976 }
1977 void
1978 Mixer_UI::scroll_left ()
1979 {
1980         if (!scroller.get_hscrollbar()) return;
1981         Adjustment* adj = scroller.get_hscrollbar()->get_adjustment();
1982         /* stupid GTK: can't rely on clamping across versions */
1983         scroller.get_hscrollbar()->set_value (max (adj->get_lower(), adj->get_value() - adj->get_step_increment()));
1984 }
1985
1986 void
1987 Mixer_UI::scroll_right ()
1988 {
1989         if (!scroller.get_hscrollbar()) return;
1990         Adjustment* adj = scroller.get_hscrollbar()->get_adjustment();
1991         /* stupid GTK: can't rely on clamping across versions */
1992         scroller.get_hscrollbar()->set_value (min (adj->get_upper(), adj->get_value() + adj->get_step_increment()));
1993 }
1994
1995 bool
1996 Mixer_UI::on_key_press_event (GdkEventKey* ev)
1997 {
1998         KeyboardKey k (ev->state, ev->keyval);
1999
2000         if (bindings.activate (k, Bindings::Press)) {
2001                 return true;
2002         }
2003
2004         if (_parent_window) {
2005                 /* send it to the main window, since our own bindings didn't
2006                  * handle it
2007                  */
2008                 return forward_key_press (ev);
2009         }
2010
2011         return false;
2012 }
2013
2014 bool
2015 Mixer_UI::on_key_release_event (GdkEventKey* ev)
2016 {
2017         KeyboardKey k (ev->state, ev->keyval);
2018
2019         if (bindings.activate (k, Bindings::Release)) {
2020                 return true;
2021         }
2022
2023         /* don't forward releases */
2024
2025         return true;
2026 }
2027
2028 bool
2029 Mixer_UI::on_scroll_event (GdkEventScroll* ev)
2030 {
2031         switch (ev->direction) {
2032         case GDK_SCROLL_LEFT:
2033                 scroll_left ();
2034                 return true;
2035         case GDK_SCROLL_UP:
2036                 if (ev->state & Keyboard::TertiaryModifier) {
2037                         scroll_left ();
2038                         return true;
2039                 }
2040                 return false;
2041
2042         case GDK_SCROLL_RIGHT:
2043                 scroll_right ();
2044                 return true;
2045
2046         case GDK_SCROLL_DOWN:
2047                 if (ev->state & Keyboard::TertiaryModifier) {
2048                         scroll_right ();
2049                         return true;
2050                 }
2051                 return false;
2052         }
2053
2054         return false;
2055 }
2056
2057
2058 void
2059 Mixer_UI::parameter_changed (string const & p)
2060 {
2061         if (p == "show-group-tabs") {
2062                 bool const s = _session->config.get_show_group_tabs ();
2063                 if (s) {
2064                         _group_tabs->show ();
2065                 } else {
2066                         _group_tabs->hide ();
2067                 }
2068         } else if (p == "default-narrow_ms") {
2069                 bool const s = UIConfiguration::instance().get_default_narrow_ms ();
2070                 for (list<MixerStrip*>::iterator i = strips.begin(); i != strips.end(); ++i) {
2071                         (*i)->set_width_enum (s ? Narrow : Wide, this);
2072                 }
2073         } else if (p == "remote-model") {
2074                 reset_remote_control_ids ();
2075         } else if (p == "use-monitor-bus") {
2076                 if (_session && !_session->monitor_out()) {
2077                         monitor_section_detached ();
2078                 }
2079         }
2080 }
2081
2082 void
2083 Mixer_UI::set_route_group_activation (RouteGroup* g, bool a)
2084 {
2085         g->set_active (a, this);
2086 }
2087
2088 PluginSelector*
2089 Mixer_UI::plugin_selector()
2090 {
2091 #ifdef DEFER_PLUGIN_SELECTOR_LOAD
2092         if (!_plugin_selector)
2093                 _plugin_selector = new PluginSelector (PluginManager::instance());
2094 #endif
2095
2096         return _plugin_selector;
2097 }
2098
2099 void
2100 Mixer_UI::setup_track_display ()
2101 {
2102         track_model = ListStore::create (track_columns);
2103         track_display.set_model (track_model);
2104         track_display.append_column (_("Strips"), track_columns.text);
2105         track_display.append_column (_("Show"), track_columns.visible);
2106         track_display.get_column (0)->set_data (X_("colnum"), GUINT_TO_POINTER(0));
2107         track_display.get_column (1)->set_data (X_("colnum"), GUINT_TO_POINTER(1));
2108         track_display.get_column (0)->set_expand(true);
2109         track_display.get_column (1)->set_expand(false);
2110         track_display.get_column (0)->set_sizing (Gtk::TREE_VIEW_COLUMN_FIXED);
2111         track_display.set_name (X_("EditGroupList"));
2112         track_display.get_selection()->set_mode (Gtk::SELECTION_NONE);
2113         track_display.set_reorderable (true);
2114         track_display.set_headers_visible (true);
2115         track_display.set_can_focus(false);
2116
2117         track_model->signal_row_deleted().connect (sigc::mem_fun (*this, &Mixer_UI::track_list_delete));
2118         track_model->signal_rows_reordered().connect (sigc::mem_fun (*this, &Mixer_UI::track_list_reorder));
2119
2120         CellRendererToggle* track_list_visible_cell = dynamic_cast<CellRendererToggle*>(track_display.get_column_cell_renderer (1));
2121         track_list_visible_cell->property_activatable() = true;
2122         track_list_visible_cell->property_radio() = false;
2123         track_list_visible_cell->signal_toggled().connect (sigc::mem_fun (*this, &Mixer_UI::track_visibility_changed));
2124
2125         track_display.signal_button_press_event().connect (sigc::mem_fun (*this, &Mixer_UI::track_display_button_press), false);
2126
2127         track_display_scroller.add (track_display);
2128         track_display_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
2129
2130         VBox* v = manage (new VBox);
2131         v->show ();
2132         v->pack_start (track_display_scroller, true, true);
2133
2134         Button* b = manage (new Button);
2135         b->show ();
2136         Widget* w = manage (new Image (Stock::ADD, ICON_SIZE_BUTTON));
2137         w->show ();
2138         b->add (*w);
2139
2140         b->signal_clicked().connect (sigc::mem_fun (*this, &Mixer_UI::new_track_or_bus));
2141
2142         v->pack_start (*b, false, false);
2143
2144         track_display_frame.set_name("BaseFrame");
2145         track_display_frame.set_shadow_type (Gtk::SHADOW_IN);
2146         track_display_frame.add (*v);
2147
2148         track_display_scroller.show();
2149         track_display_frame.show();
2150         track_display.show();
2151 }
2152
2153 void
2154 Mixer_UI::new_track_or_bus ()
2155 {
2156         // ARDOUR_UI::instance()->add_route (this);
2157 }
2158
2159
2160 void
2161 Mixer_UI::update_title ()
2162 {
2163         if (!own_window()) {
2164                 return;
2165         }
2166
2167         if (_session) {
2168                 string n;
2169
2170                 if (_session->snap_name() != _session->name()) {
2171                         n = _session->snap_name ();
2172                 } else {
2173                         n = _session->name ();
2174                 }
2175
2176                 if (_session->dirty ()) {
2177                         n = "*" + n;
2178                 }
2179
2180                 if (own_window()) {
2181                         WindowTitle title (n);
2182                         title += S_("Window|Mixer");
2183                         title += Glib::get_application_name ();
2184                         own_window()->set_title (title.get_string());
2185                 }
2186
2187         } else {
2188
2189                 if (own_window()) {
2190                         WindowTitle title (S_("Window|Mixer"));
2191                         title += Glib::get_application_name ();
2192                         own_window()->set_title (title.get_string());
2193                 }
2194         }
2195 }
2196
2197 MixerStrip*
2198 Mixer_UI::strip_by_x (int x)
2199 {
2200         for (list<MixerStrip*>::iterator i = strips.begin(); i != strips.end(); ++i) {
2201                 int x1, x2, y;
2202
2203                 (*i)->translate_coordinates (_content, 0, 0, x1, y);
2204                 x2 = x1 + (*i)->get_width();
2205
2206                 if (x >= x1 && x <= x2) {
2207                         return (*i);
2208                 }
2209         }
2210
2211         return 0;
2212 }
2213
2214 void
2215 Mixer_UI::set_route_targets_for_operation ()
2216 {
2217         _route_targets.clear ();
2218
2219         if (!_selection.empty()) {
2220                 _route_targets = _selection.routes;
2221                 return;
2222         }
2223
2224 //  removed "implicit" selections of strips, after discussion on IRC
2225
2226 }
2227
2228 void
2229 Mixer_UI::monitor_section_going_away ()
2230 {
2231         if (_monitor_section) {
2232                 monitor_section_detached ();
2233                 out_packer.remove (_monitor_section->tearoff());
2234                 _monitor_section->set_session (0);
2235                 delete _monitor_section;
2236                 _monitor_section = 0;
2237         }
2238 }
2239
2240 void
2241 Mixer_UI::toggle_midi_input_active (bool flip_others)
2242 {
2243         boost::shared_ptr<RouteList> rl (new RouteList);
2244         bool onoff = false;
2245
2246         set_route_targets_for_operation ();
2247
2248         for (RouteUISelection::iterator r = _route_targets.begin(); r != _route_targets.end(); ++r) {
2249                 boost::shared_ptr<MidiTrack> mt = (*r)->midi_track();
2250
2251                 if (mt) {
2252                         rl->push_back ((*r)->route());
2253                         onoff = !mt->input_active();
2254                 }
2255         }
2256
2257         _session->set_exclusive_input_active (rl, onoff, flip_others);
2258 }
2259
2260 void
2261 Mixer_UI::maximise_mixer_space ()
2262 {
2263         if (!own_window()) {
2264                 return;
2265         }
2266
2267         Gtk::Window* win = (Gtk::Window*) get_toplevel();
2268
2269         if (win) {
2270                 win->fullscreen ();
2271                 _maximised = true;
2272         }
2273
2274         _window->fullscreen ();
2275         _maximised = true;
2276 }
2277
2278 void
2279 Mixer_UI::restore_mixer_space ()
2280 {
2281         if (!own_window()) {
2282                 return;
2283         }
2284
2285         Gtk::Window* win = (Gtk::Window*) get_toplevel();
2286
2287         if (win) {
2288                 win->unfullscreen();
2289                 _maximised = false;
2290         }
2291
2292         own_window()->unfullscreen();
2293         _maximised = false;
2294 }
2295
2296 void
2297 Mixer_UI::monitor_section_attached ()
2298 {
2299         Glib::RefPtr<Action> act = ActionManager::get_action ("Common", "ToggleMonitorSection");
2300         Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
2301         act->set_sensitive (true);
2302         tact->set_active ();
2303 }
2304
2305 void
2306 Mixer_UI::monitor_section_detached ()
2307 {
2308         Glib::RefPtr<Action> act = ActionManager::get_action ("Common", "ToggleMonitorSection");
2309         act->set_sensitive (false);
2310 }
2311
2312 void
2313 Mixer_UI::store_current_favorite_order ()
2314 {
2315         typedef Gtk::TreeModel::Children type_children;
2316         type_children children = favorite_plugins_model->children();
2317         favorite_order.clear();
2318         for(type_children::iterator iter = children.begin(); iter != children.end(); ++iter)
2319         {
2320                 Gtk::TreeModel::Row row = *iter;
2321                 ARDOUR::PluginPresetPtr ppp = row[favorite_plugins_columns.plugin];
2322                 favorite_order.push_back (ppp->_pip);
2323                 std::string name = row[favorite_plugins_columns.name];
2324                 favorite_ui_state[(*ppp->_pip).unique_id] = favorite_plugins_display.row_expanded (favorite_plugins_model->get_path(iter));
2325         }
2326 }
2327
2328 void
2329 Mixer_UI::save_favorite_ui_state (const TreeModel::iterator& iter, const TreeModel::Path& path)
2330 {
2331         Gtk::TreeModel::Row row = *iter;
2332         ARDOUR::PluginPresetPtr ppp = row[favorite_plugins_columns.plugin];
2333         assert (ppp);
2334         favorite_ui_state[(*ppp->_pip).unique_id] = favorite_plugins_display.row_expanded (favorite_plugins_model->get_path(iter));
2335 }
2336
2337 void
2338 Mixer_UI::refiller (PluginInfoList& result, const PluginInfoList& plugs)
2339 {
2340         PluginManager& manager (PluginManager::instance());
2341         for (PluginInfoList::const_iterator i = plugs.begin(); i != plugs.end(); ++i) {
2342                 if (manager.get_status (*i) != PluginManager::Favorite) {
2343                         continue;
2344                 }
2345                 result.push_back (*i);
2346         }
2347 }
2348
2349 struct PluginCustomSorter {
2350 public:
2351         bool operator() (PluginInfoPtr a, PluginInfoPtr b) const {
2352                 PluginInfoList::const_iterator aiter = _user.begin();
2353                 PluginInfoList::const_iterator biter = _user.begin();
2354                 while (aiter != _user.end()) { if ((*aiter)->unique_id == a->unique_id) { break; } ++aiter; }
2355                 while (biter != _user.end()) { if ((*biter)->unique_id == b->unique_id) { break; } ++biter; }
2356
2357                 if (aiter != _user.end() && biter != _user.end()) {
2358                         return std::distance (_user.begin(), aiter) < std::distance (_user.begin(), biter);
2359                 }
2360                 if (aiter != _user.end()) {
2361                         return true;
2362                 }
2363                 if (biter != _user.end()) {
2364                         return false;
2365                 }
2366                 return ARDOUR::cmp_nocase((*a).name, (*b).name) == -1;
2367         }
2368         PluginCustomSorter(PluginInfoList user) : _user (user)  {}
2369 private:
2370         PluginInfoList _user;
2371 };
2372
2373 void
2374 Mixer_UI::refill_favorite_plugins ()
2375 {
2376         PluginInfoList plugs;
2377         PluginManager& mgr (PluginManager::instance());
2378
2379 #ifdef LV2_SUPPORT
2380         refiller (plugs, mgr.lv2_plugin_info ());
2381 #endif
2382 #ifdef WINDOWS_VST_SUPPORT
2383         refiller (plugs, mgr.windows_vst_plugin_info ());
2384 #endif
2385 #ifdef LXVST_SUPPORT
2386         refiller (plugs, mgr.lxvst_plugin_info ());
2387 #endif
2388 #ifdef AUDIOUNIT_SUPPORT
2389         refiller (plugs, mgr.au_plugin_info ());
2390 #endif
2391         refiller (plugs, mgr.ladspa_plugin_info ());
2392
2393         store_current_favorite_order ();
2394
2395         PluginCustomSorter cmp (favorite_order);
2396         plugs.sort (cmp);
2397
2398         favorite_order = plugs;
2399
2400         sync_treeview_from_favorite_order ();
2401 }
2402
2403 void
2404 Mixer_UI::sync_treeview_favorite_ui_state (const TreeModel::Path& path, const TreeModel::iterator&)
2405 {
2406         TreeIter iter;
2407         if (!(iter = favorite_plugins_model->get_iter (path))) {
2408                 return;
2409         }
2410         ARDOUR::PluginPresetPtr ppp = (*iter)[favorite_plugins_columns.plugin];
2411         if (!ppp) {
2412                 return;
2413         }
2414         PluginInfoPtr pip = ppp->_pip;
2415         if (favorite_ui_state.find (pip->unique_id) != favorite_ui_state.end ()) {
2416                 if (favorite_ui_state[pip->unique_id]) {
2417                         favorite_plugins_display.expand_row (path, true);
2418                 }
2419         }
2420 }
2421
2422 void
2423 Mixer_UI::sync_treeview_from_favorite_order ()
2424 {
2425         favorite_plugins_model->clear ();
2426         for (PluginInfoList::const_iterator i = favorite_order.begin(); i != favorite_order.end(); ++i) {
2427                 PluginInfoPtr pip = (*i);
2428
2429                 TreeModel::Row newrow = *(favorite_plugins_model->append());
2430                 newrow[favorite_plugins_columns.name] = (*i)->name;
2431                 newrow[favorite_plugins_columns.plugin] = PluginPresetPtr (new PluginPreset(pip));
2432                 if (!_session) {
2433                         continue;
2434                 }
2435
2436                 vector<ARDOUR::Plugin::PresetRecord> presets = (*i)->get_presets (true);
2437                 for (vector<ARDOUR::Plugin::PresetRecord>::const_iterator j = presets.begin(); j != presets.end(); ++j) {
2438                         Gtk::TreeModel::Row child_row = *(favorite_plugins_model->append (newrow.children()));
2439                         child_row[favorite_plugins_columns.name] = (*j).label;
2440                         child_row[favorite_plugins_columns.plugin] = PluginPresetPtr (new PluginPreset(pip, &(*j)));
2441                 }
2442                 if (favorite_ui_state.find (pip->unique_id) != favorite_ui_state.end ()) {
2443                         if (favorite_ui_state[pip->unique_id]) {
2444                                 favorite_plugins_display.expand_row (favorite_plugins_model->get_path(newrow), true);
2445                         }
2446                 }
2447         }
2448 }
2449
2450 void
2451 Mixer_UI::popup_note_context_menu (GdkEventButton *ev)
2452 {
2453         using namespace Gtk::Menu_Helpers;
2454
2455         Gtk::Menu* m = manage (new Menu);
2456         MenuList& items = m->items ();
2457
2458         if (_selection.routes.empty()) {
2459                 items.push_back (MenuElem (_("No Track/Bus is selected.")));
2460         } else {
2461                 items.push_back (MenuElem (_("Add at the top"),
2462                                         sigc::bind (sigc::mem_fun (*this, &Mixer_UI::add_selected_processor), AddTop)));
2463                 items.push_back (MenuElem (_("Add Pre-Fader"),
2464                                         sigc::bind (sigc::mem_fun (*this, &Mixer_UI::add_selected_processor), AddPreFader)));
2465                 items.push_back (MenuElem (_("Add Post-Fader"),
2466                                         sigc::bind (sigc::mem_fun (*this, &Mixer_UI::add_selected_processor), AddPostFader)));
2467                 items.push_back (MenuElem (_("Add at the end"),
2468                                         sigc::bind (sigc::mem_fun (*this, &Mixer_UI::add_selected_processor), AddBottom)));
2469         }
2470
2471         items.push_back (SeparatorElem());
2472
2473         items.push_back (MenuElem (_("Remove from favorites"), sigc::mem_fun (*this, &Mixer_UI::remove_selected_from_favorites)));
2474
2475         ARDOUR::PluginPresetPtr ppp = selected_plugin();
2476         if (ppp && ppp->_preset.valid && ppp->_preset.user) {
2477                 // we cannot currently delete AU presets
2478                 if (!ppp->_pip || ppp->_pip->type != AudioUnit) {
2479                         items.push_back (MenuElem (_("Delete Preset"), sigc::mem_fun (*this, &Mixer_UI::delete_selected_preset)));
2480                 }
2481         }
2482
2483         m->popup (ev->button, ev->time);
2484 }
2485
2486 bool
2487 Mixer_UI::plugin_row_button_press (GdkEventButton *ev)
2488 {
2489         if ((ev->type == GDK_BUTTON_PRESS) && (ev->button == 3) ) {
2490                 TreeModel::Path path;
2491                 TreeViewColumn* column;
2492                 int cellx, celly;
2493                 if (favorite_plugins_display.get_path_at_pos ((int)ev->x, (int)ev->y, path, column, cellx, celly)) {
2494                         Glib::RefPtr<Gtk::TreeView::Selection> selection = favorite_plugins_display.get_selection();
2495                         if (selection) {
2496                                 selection->unselect_all();
2497                                 selection->select(path);
2498                         }
2499                 }
2500                 ARDOUR::PluginPresetPtr ppp = selected_plugin();
2501                 if (ppp) {
2502                         popup_note_context_menu (ev);
2503                 }
2504         }
2505         return false;
2506 }
2507
2508
2509 PluginPresetPtr
2510 Mixer_UI::selected_plugin ()
2511 {
2512         Glib::RefPtr<Gtk::TreeView::Selection> selection = favorite_plugins_display.get_selection();
2513         if (!selection) {
2514                 return PluginPresetPtr();
2515         }
2516         Gtk::TreeModel::iterator iter = selection->get_selected();
2517         if (!iter) {
2518                 return PluginPresetPtr();
2519         }
2520         return (*iter)[favorite_plugins_columns.plugin];
2521 }
2522
2523 void
2524 Mixer_UI::add_selected_processor (ProcessorPosition pos)
2525 {
2526         ARDOUR::PluginPresetPtr ppp = selected_plugin();
2527         if (ppp) {
2528                 add_favorite_processor (ppp, pos);
2529         }
2530 }
2531
2532 void
2533 Mixer_UI::delete_selected_preset ()
2534 {
2535         if (!_session) {
2536                 return;
2537         }
2538         ARDOUR::PluginPresetPtr ppp = selected_plugin();
2539         if (!ppp || !ppp->_preset.valid || !ppp->_preset.user) {
2540                 return;
2541         }
2542         PluginPtr plugin = ppp->_pip->load (*_session);
2543         plugin->get_presets();
2544         plugin->remove_preset (ppp->_preset.label);
2545 }
2546
2547 void
2548 Mixer_UI::remove_selected_from_favorites ()
2549 {
2550         ARDOUR::PluginPresetPtr ppp = selected_plugin();
2551         if (!ppp) {
2552                 return;
2553         }
2554         PluginManager::PluginStatusType status = PluginManager::Normal;
2555         PluginManager& manager (PluginManager::instance());
2556
2557         manager.set_status (ppp->_pip->type, ppp->_pip->unique_id, status);
2558         manager.save_statuses ();
2559 }
2560
2561 void
2562 Mixer_UI::plugin_row_activated (const TreeModel::Path& path, TreeViewColumn* column)
2563 {
2564         TreeIter iter;
2565         if (!(iter = favorite_plugins_model->get_iter (path))) {
2566                 return;
2567         }
2568         ARDOUR::PluginPresetPtr ppp = (*iter)[favorite_plugins_columns.plugin];
2569         add_favorite_processor (ppp, AddPreFader); // TODO: preference?!
2570 }
2571
2572 void
2573 Mixer_UI::add_favorite_processor (ARDOUR::PluginPresetPtr ppp, ProcessorPosition pos)
2574 {
2575         if (!_session || _selection.routes.empty()) {
2576                 return;
2577         }
2578
2579         PluginInfoPtr pip = ppp->_pip;
2580         for (RouteUISelection::iterator i = _selection.routes.begin(); i != _selection.routes.end(); ++i) {
2581                 boost::shared_ptr<ARDOUR::Route> rt = (*i)->route();
2582                 if (!rt) { continue; }
2583
2584                 PluginPtr p = pip->load (*_session);
2585                 if (!p) { continue; }
2586
2587                 if (ppp->_preset.valid) {
2588                         p->load_preset (ppp->_preset);
2589                 }
2590
2591                 Route::ProcessorStreams err;
2592                 boost::shared_ptr<Processor> processor (new PluginInsert (*_session, p));
2593
2594                 switch (pos) {
2595                         case AddTop:
2596                                 rt->add_processor_by_index (processor, 0, &err, Config->get_new_plugins_active ());
2597                                 break;
2598                         case AddPreFader:
2599                                 rt->add_processor (processor, PreFader, &err, Config->get_new_plugins_active ());
2600                                 break;
2601                         case AddPostFader:
2602                                 {
2603                                         int idx = 0;
2604                                         for (;;++idx) {
2605                                                 boost::shared_ptr<Processor> np = rt->nth_processor (idx);
2606                                                 if (!np || boost::dynamic_pointer_cast<Amp> (np)) {
2607                                                         break;
2608                                                 }
2609                                         }
2610                                         rt->add_processor_by_index (processor, ++idx, &err, Config->get_new_plugins_active ());
2611                                 }
2612                                 break;
2613                         case AddBottom:
2614                                 rt->add_processor_by_index (processor, -1, &err, Config->get_new_plugins_active ());
2615                                 break;
2616                 }
2617         }
2618 }
2619
2620 bool
2621 PluginTreeStore::row_drop_possible_vfunc(const Gtk::TreeModel::Path& dest, const Gtk::SelectionData& data) const
2622 {
2623         if (data.get_target() != "GTK_TREE_MODEL_ROW") {
2624                 return false;
2625         }
2626
2627         // only allow to re-order top-level items
2628         TreePath src;
2629         if (TreePath::get_from_selection_data (data, src)) {
2630                 if (src.up() && src.up()) {
2631                         return false;
2632                 }
2633         }
2634
2635         // don't allow to drop as child-rows.
2636         Gtk::TreeModel::Path _dest = dest; // un const
2637         const bool is_child = _dest.up (); // explicit bool for clang
2638         if (!is_child || _dest.empty ()) {
2639                 return true;
2640         }
2641         return false;
2642 }
2643
2644 void
2645 Mixer_UI::plugin_drop (const Glib::RefPtr<Gdk::DragContext>&, const Gtk::SelectionData& data)
2646 {
2647         if (data.get_target() != "PluginPresetPtr") {
2648                 return;
2649         }
2650         if (data.get_length() != sizeof (PluginPresetPtr)) {
2651                 return;
2652         }
2653         const void *d = data.get_data();
2654         const PluginPresetPtr ppp = *(static_cast<const PluginPresetPtr*> (d));
2655
2656         PluginManager::PluginStatusType status = PluginManager::Favorite;
2657         PluginManager& manager (PluginManager::instance());
2658
2659         manager.set_status (ppp->_pip->type, ppp->_pip->unique_id, status);
2660         manager.save_statuses ();
2661 }