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