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