gtk2_ardour/mixer_ui.cc

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