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