gtk2_ardour/monitor_section.cc

   1 #include <gdkmm/pixbuf.h>
   2
   3 #include "pbd/compose.h"
   4 #include "pbd/error.h"
   5
   6 #include "gtkmm2ext/bindable_button.h"
   7 #include "gtkmm2ext/tearoff.h"
   8 #include "gtkmm2ext/actions.h"
   9 #include "gtkmm2ext/motionfeedback.h"
  10
  11 #include "ardour/dB.h"
  12 #include "ardour/monitor_processor.h"
  13 #include "ardour/route.h"
  14 #include "ardour/utils.h"
  15
  16 #include "ardour_ui.h"
  17 #include "gui_thread.h"
  18 #include "monitor_section.h"
  19 #include "public_editor.h"
  20 #include "utils.h"
  21 #include "volume_controller.h"
  22
  23 #include "i18n.h"
  24
  25 using namespace ARDOUR;
  26 using namespace Gtk;
  27 using namespace Gtkmm2ext;
  28 using namespace PBD;
  29 using namespace std;
  30
  31 Glib::RefPtr<ActionGroup> MonitorSection::monitor_actions;
  32 Glib::RefPtr<Gdk::Pixbuf> MonitorSection::big_knob_pixbuf;
  33 Glib::RefPtr<Gdk::Pixbuf> MonitorSection::little_knob_pixbuf;
  34
  35 MonitorSection::MonitorSection (Session* s)
  36         : AxisView (s)
  37         , RouteUI (s)
  38         , main_table (2, 3)
  39         , _tearoff (0)
  40         , gain_adjustment (0.781787, 0.0, 1.0, 0.01, 0.1) // initial value is unity gain
  41         , gain_control (0)
  42         , dim_adjustment (0.2, 0.0, 1.0, 0.01, 0.1) // upper+lower will be reset to match model
  43         , dim_control (0)
  44         , solo_boost_adjustment (1.0, 1.0, 3.0, 0.01, 0.1)  // upper and lower will be reset to match model
  45         , solo_boost_control (0)
  46         , solo_cut_adjustment (0.0, 0.0, 1.0, 0.01, 0.1) // upper and lower will be reset to match model
  47         , solo_cut_control (0)
  48         , solo_in_place_button (solo_model_group, _("SiP"))
  49         , afl_button (solo_model_group, _("AFL"))
  50         , pfl_button (solo_model_group, _("PFL"))
  51         , cut_all_button (_("MUTE"))
  52         , dim_all_button (_("dim"))
  53         , mono_button (_("mono"))
  54         , rude_solo_button (_("soloing"))
  55         , rude_iso_button (_("isolated"))
  56         , rude_audition_button (_("auditioning"))
  57         , exclusive_solo_button (_("Exclusive"))
  58         , solo_mute_override_button (_("Solo/Mute"))
  59 {
  60         Glib::RefPtr<Action> act;
  61
  62         if (!monitor_actions) {
  63
  64                 /* do some static stuff */
  65
  66                 register_actions ();
  67
  68         }
  69
  70         set_session (s);
  71
  72         VBox* spin_packer;
  73         Label* spin_label;
  74
  75         /* Dim */
  76
  77         dim_control = new VolumeController (little_knob_pixbuf, &dim_adjustment, false, 30, 30);
  78
  79         HBox* dim_packer = manage (new HBox);
  80         dim_packer->show ();
  81
  82         spin_label = manage (new Label (_("Dim Cut")));
  83         spin_packer = manage (new VBox);
  84         spin_packer->show ();
  85         spin_packer->set_spacing (6);
  86         spin_packer->pack_start (*dim_control, false, false);
  87         spin_packer->pack_start (*spin_label, false, false);
  88
  89         dim_packer->set_spacing (12);
  90         dim_packer->pack_start (*spin_packer, true, true);
  91
  92         /* Rude Solo */
  93
  94         rude_solo_button.set_name ("TransportSoloAlert");
  95         rude_solo_button.show ();
  96
  97         rude_iso_button.set_name ("MonitorIsoAlert");
  98         rude_iso_button.show ();
  99
 100         rude_audition_button.set_name ("TransportAuditioningAlert");
 101         rude_audition_button.show ();
 102
 103         ARDOUR_UI::Blink.connect (sigc::mem_fun (*this, &MonitorSection::do_blink));
 104
 105         rude_solo_button.signal_button_press_event().connect (sigc::mem_fun(*this, &MonitorSection::cancel_solo), false);
 106         UI::instance()->set_tip (rude_solo_button, _("When active, something is soloed.\nClick to de-solo everything"));
 107
 108         rude_iso_button.signal_button_press_event().connect (sigc::mem_fun(*this, &MonitorSection::cancel_isolate), false);
 109         UI::instance()->set_tip (rude_iso_button, _("When active, something is solo-isolated.\nClick to de-isolate everything"));
 110
 111         rude_audition_button.signal_button_press_event().connect (sigc::mem_fun(*this, &MonitorSection::cancel_audition), false);
 112         UI::instance()->set_tip (rude_audition_button, _("When active, auditioning is active.\nClick to stop the audition"));
 113
 114         solo_model_box.set_spacing (6);
 115         solo_model_box.pack_start (solo_in_place_button, false, false);
 116         solo_model_box.pack_start (afl_button, false, false);
 117         solo_model_box.pack_start (pfl_button, false, false);
 118
 119         solo_in_place_button.show ();
 120         afl_button.show ();
 121         pfl_button.show ();
 122         solo_model_box.show ();
 123
 124         act = ActionManager::get_action (X_("Solo"), X_("solo-use-in-place"));
 125         if (act) {
 126                 act->connect_proxy (solo_in_place_button);
 127         }
 128
 129         act = ActionManager::get_action (X_("Solo"), X_("solo-use-afl"));
 130         if (act) {
 131                 act->connect_proxy (afl_button);
 132         }
 133
 134         act = ActionManager::get_action (X_("Solo"), X_("solo-use-pfl"));
 135         if (act) {
 136                 act->connect_proxy (pfl_button);
 137         }
 138
 139         /* Solo Boost */
 140
 141         solo_boost_control = new VolumeController (little_knob_pixbuf, &solo_boost_adjustment, false, 30, 30);
 142
 143         HBox* solo_packer = manage (new HBox);
 144         solo_packer->set_spacing (12);
 145         solo_packer->show ();
 146
 147         spin_label = manage (new Label (_("Solo Boost")));
 148         spin_packer = manage (new VBox);
 149         spin_packer->show ();
 150         spin_packer->set_spacing (6);
 151         spin_packer->pack_start (*solo_boost_control, false, false);
 152         spin_packer->pack_start (*spin_label, false, false);
 153
 154         solo_packer->pack_start (*spin_packer, true, true);
 155
 156         /* Solo (SiP) cut */
 157
 158         solo_cut_control = new VolumeController (little_knob_pixbuf, &solo_cut_adjustment, false, 30, 30);
 159
 160         spin_label = manage (new Label (_("SiP Cut")));
 161         spin_packer = manage (new VBox);
 162         spin_packer->show ();
 163         spin_packer->set_spacing (6);
 164         spin_packer->pack_start (*solo_cut_control, false, false);
 165         spin_packer->pack_start (*spin_label, false, false);
 166
 167         solo_packer->pack_start (*spin_packer, true, true);
 168
 169         exclusive_solo_button.set_name (X_("MonitorOptButton"));
 170         ARDOUR_UI::instance()->set_tip (&exclusive_solo_button, _("Exclusive solo means that only 1 solo is active at a time"));
 171
 172         act = ActionManager::get_action (X_("Monitor"), X_("toggle-exclusive-solo"));
 173         if (act) {
 174                 act->connect_proxy (exclusive_solo_button);
 175         }
 176
 177         solo_mute_override_button.set_name (X_("MonitorOptButton"));
 178         ARDOUR_UI::instance()->set_tip (&solo_mute_override_button, _("If enabled, solo will override mute\n(a soloed & muted track or bus will be audible)"));
 179
 180         act = ActionManager::get_action (X_("Monitor"), X_("toggle-mute-overrides-solo"));
 181         if (act) {
 182                 act->connect_proxy (solo_mute_override_button);
 183         }
 184
 185         HBox* solo_opt_box = manage (new HBox);
 186         solo_opt_box->set_spacing (12);
 187         solo_opt_box->set_homogeneous (true);
 188         solo_opt_box->pack_start (exclusive_solo_button);
 189         solo_opt_box->pack_start (solo_mute_override_button);
 190         solo_opt_box->show ();
 191
 192         upper_packer.set_spacing (12);
 193
 194         Gtk::HBox* rude_box = manage (new HBox);
 195         rude_box->pack_start (rude_solo_button, true, true);
 196         rude_box->pack_start (rude_iso_button, true, true);
 197
 198         upper_packer.pack_start (*rude_box, false, false);
 199         upper_packer.pack_start (rude_audition_button, false, false);
 200         upper_packer.pack_start (solo_model_box, false, false);
 201         upper_packer.pack_start (*solo_opt_box, false, false);
 202         upper_packer.pack_start (*solo_packer, false, false);
 203
 204         act = ActionManager::get_action (X_("Monitor"), X_("monitor-cut-all"));
 205         if (act) {
 206                 act->connect_proxy (cut_all_button);
 207         }
 208
 209         act = ActionManager::get_action (X_("Monitor"), X_("monitor-dim-all"));
 210         if (act) {
 211                 act->connect_proxy (dim_all_button);
 212         }
 213
 214         act = ActionManager::get_action (X_("Monitor"), X_("monitor-mono"));
 215         if (act) {
 216                 act->connect_proxy (mono_button);
 217         }
 218
 219         cut_all_button.set_name (X_("MonitorMuteButton"));
 220         cut_all_button.unset_flags (Gtk::CAN_FOCUS);
 221         cut_all_button.set_size_request (50,50);
 222         cut_all_button.show ();
 223
 224         HBox* bbox = manage (new HBox);
 225
 226         bbox->set_spacing (12);
 227         bbox->pack_start (mono_button, true, true);
 228         bbox->pack_start (dim_all_button, true, true);
 229
 230         dim_all_button.set_name (X_("MonitorDimButton"));
 231         dim_all_button.unset_flags (Gtk::CAN_FOCUS);
 232         mono_button.set_name (X_("MonitorMonoButton"));
 233         mono_button.unset_flags (Gtk::CAN_FOCUS);
 234
 235         lower_packer.set_spacing (12);
 236         lower_packer.pack_start (*bbox, false, false);
 237         lower_packer.pack_start (cut_all_button, false, false);
 238
 239         /* Gain */
 240
 241         gain_control = new VolumeController (big_knob_pixbuf, &gain_adjustment, false, 80, 80);
 242
 243         spin_label = manage (new Label (_("Gain")));
 244         spin_packer = manage (new VBox);
 245         spin_packer->show ();
 246         spin_packer->set_spacing (6);
 247         spin_packer->pack_start (*gain_control, false, false);
 248         spin_packer->pack_start (*spin_label, false, false);
 249
 250         lower_packer.pack_start (*spin_packer, true, true);
 251
 252         vpacker.set_border_width (12);
 253         vpacker.set_spacing (12);
 254         vpacker.pack_start (upper_packer, false, false);
 255         vpacker.pack_start (*dim_packer, false, false);
 256         vpacker.pack_start (main_table, false, false);
 257         vpacker.pack_start (lower_packer, false, false);
 258
 259         hpacker.set_border_width (12);
 260         hpacker.set_spacing (12);
 261         hpacker.pack_start (vpacker, true, true);
 262
 263         gain_control->show_all ();
 264         dim_control->show_all ();
 265         solo_boost_control->show_all ();
 266
 267         main_table.show ();
 268         hpacker.show ();
 269         upper_packer.show ();
 270         lower_packer.show ();
 271         vpacker.show ();
 272
 273         populate_buttons ();
 274         map_state ();
 275         assign_controllables ();
 276
 277         _tearoff = new TearOff (hpacker);
 278
 279         /* if torn off, make this a normal window */
 280         _tearoff->tearoff_window().set_type_hint (Gdk::WINDOW_TYPE_HINT_NORMAL);
 281         _tearoff->tearoff_window().set_title (X_("Monitor"));
 282         _tearoff->tearoff_window().signal_key_press_event().connect (sigc::ptr_fun (forward_key_press), false);
 283
 284         /* catch changes that affect us */
 285
 286         Config->ParameterChanged.connect (config_connection, invalidator (*this), ui_bind (&MonitorSection::parameter_changed, this, _1), gui_context());
 287 }
 288
 289 MonitorSection::~MonitorSection ()
 290 {
 291         for (ChannelButtons::iterator i = _channel_buttons.begin(); i != _channel_buttons.end(); ++i) {
 292                 delete *i;
 293         }
 294
 295         _channel_buttons.clear ();
 296
 297         delete gain_control;
 298         delete dim_control;
 299         delete solo_boost_control;
 300         delete _tearoff;
 301 }
 302
 303 void
 304 MonitorSection::set_session (Session* s)
 305 {
 306         AxisView::set_session (s);
 307
 308         if (_session) {
 309
 310                 _route = _session->monitor_out ();
 311
 312                 if (_route) {
 313                         /* session with control outs */
 314                         _monitor = _route->monitor_control ();
 315                         assign_controllables ();
 316                 } else {
 317                         /* session with no control outs */
 318                         _monitor.reset ();
 319                         _route.reset ();
 320                 }
 321
 322         } else {
 323                 /* no session */
 324                 _monitor.reset ();
 325                 _route.reset ();
 326                 control_connections.drop_connections ();
 327                 rude_iso_button.set_active (false);
 328                 rude_solo_button.set_active (false);
 329         }
 330
 331         /* both might be null */
 332 }
 333
 334 MonitorSection::ChannelButtonSet::ChannelButtonSet ()
 335         : cut (X_(""))
 336         , dim (X_(""))
 337         , solo (X_(""))
 338         , invert (X_(""))
 339 {
 340         cut.set_name (X_("MonitorMuteButton"));
 341         dim.set_name (X_("MonitorDimButton"));
 342         solo.set_name (X_("MixerSoloButton"));
 343         invert.set_name (X_("MonitorInvertButton"));
 344
 345         gtk_activatable_set_use_action_appearance (GTK_ACTIVATABLE (cut.gobj()), false);
 346         gtk_activatable_set_use_action_appearance (GTK_ACTIVATABLE (dim.gobj()), false);
 347         gtk_activatable_set_use_action_appearance (GTK_ACTIVATABLE (invert.gobj()), false);
 348         gtk_activatable_set_use_action_appearance (GTK_ACTIVATABLE (solo.gobj()), false);
 349
 350         cut.unset_flags (Gtk::CAN_FOCUS);
 351         dim.unset_flags (Gtk::CAN_FOCUS);
 352         solo.unset_flags (Gtk::CAN_FOCUS);
 353         invert.unset_flags (Gtk::CAN_FOCUS);
 354 }
 355
 356 void
 357 MonitorSection::populate_buttons ()
 358 {
 359         if (!_monitor) {
 360                 return;
 361         }
 362
 363         Glib::RefPtr<Action> act;
 364         uint32_t nchans = _monitor->output_streams().n_audio();
 365
 366         main_table.resize (nchans+1, 5);
 367         main_table.set_col_spacings (6);
 368         main_table.set_row_spacings (6);
 369         main_table.set_homogeneous (true);
 370
 371         Label* l1 = manage (new Label (X_("out")));
 372         main_table.attach (*l1, 0, 1, 0, 1, SHRINK|FILL, SHRINK|FILL);
 373         l1 = manage (new Label (X_("cut")));
 374         main_table.attach (*l1, 1, 2, 0, 1, SHRINK|FILL, SHRINK|FILL);
 375         l1 = manage (new Label (X_("dim")));
 376         main_table.attach (*l1, 2, 3, 0, 1, SHRINK|FILL, SHRINK|FILL);
 377         l1 = manage (new Label (X_("solo")));
 378         main_table.attach (*l1, 3, 4, 0, 1, SHRINK|FILL, SHRINK|FILL);
 379         l1 = manage (new Label (X_("inv")));
 380         main_table.attach (*l1, 4, 5, 0, 1, SHRINK|FILL, SHRINK|FILL);
 381
 382         const uint32_t row_offset = 1;
 383
 384         for (uint32_t i = 0; i < nchans; ++i) {
 385
 386                 string l;
 387                 char buf[64];
 388
 389                 if (nchans == 2) {
 390                         if (i == 0) {
 391                                 l = "L";
 392                         } else {
 393                                 l = "R";
 394                         }
 395                 } else {
 396                         char buf[32];
 397                         snprintf (buf, sizeof (buf), "%d", i+1);
 398                         l = buf;
 399                 }
 400
 401                 Label* label = manage (new Label (l));
 402                 main_table.attach (*label, 0, 1, i+row_offset, i+row_offset+1, SHRINK|FILL, SHRINK|FILL);
 403
 404                 ChannelButtonSet* cbs = new ChannelButtonSet;
 405
 406                 _channel_buttons.push_back (cbs);
 407
 408                 main_table.attach (cbs->cut, 1, 2, i+row_offset, i+row_offset+1, SHRINK|FILL, SHRINK|FILL);
 409                 main_table.attach (cbs->dim, 2, 3, i+row_offset, i+row_offset+1, SHRINK|FILL, SHRINK|FILL);
 410                 main_table.attach (cbs->solo, 3, 4, i+row_offset, i+row_offset+1, SHRINK|FILL, SHRINK|FILL);
 411                 main_table.attach (cbs->invert, 4, 5, i+row_offset, i+row_offset+1, SHRINK|FILL, SHRINK|FILL);
 412
 413                 snprintf (buf, sizeof (buf), "monitor-cut-%u", i+1);
 414                 act = ActionManager::get_action (X_("Monitor"), buf);
 415                 if (act) {
 416                         act->connect_proxy (cbs->cut);
 417                 }
 418
 419                 snprintf (buf, sizeof (buf), "monitor-dim-%u", i+1);
 420                 act = ActionManager::get_action (X_("Monitor"), buf);
 421                 if (act) {
 422                         act->connect_proxy (cbs->dim);
 423                 }
 424
 425                 snprintf (buf, sizeof (buf), "monitor-solo-%u", i+1);
 426                 act = ActionManager::get_action (X_("Monitor"), buf);
 427                 if (act) {
 428                         act->connect_proxy (cbs->solo);
 429                 }
 430
 431                 snprintf (buf, sizeof (buf), "monitor-invert-%u", i+1);
 432                 act = ActionManager::get_action (X_("Monitor"), buf);
 433                 if (act) {
 434                         act->connect_proxy (cbs->invert);
 435                 }
 436         }
 437
 438         main_table.show_all ();
 439 }
 440
 441 void
 442 MonitorSection::set_button_names ()
 443 {
 444         rec_enable_button_label.set_text ("rec");
 445         mute_button_label.set_text ("rec");
 446         solo_button_label.set_text ("rec");
 447 }
 448
 449 void
 450 MonitorSection::toggle_exclusive_solo ()
 451 {
 452         if (!_monitor) {
 453                 return;
 454         }
 455
 456         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Monitor"), "toggle-exclusive-solo");
 457         if (act) {
 458                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 459                 Config->set_exclusive_solo (tact->get_active());
 460         }
 461
 462 }
 463
 464
 465 void
 466 MonitorSection::toggle_mute_overrides_solo ()
 467 {
 468         if (!_monitor) {
 469                 return;
 470         }
 471
 472         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Monitor"), "toggle-mute-overrides-solo");
 473         if (act) {
 474                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 475                 Config->set_solo_mute_override (tact->get_active());
 476         }
 477 }
 478
 479 void
 480 MonitorSection::dim_all ()
 481 {
 482         if (!_monitor) {
 483                 return;
 484         }
 485
 486         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Monitor"), "monitor-dim-all");
 487         if (act) {
 488                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 489                 _monitor->set_dim_all (tact->get_active());
 490         }
 491
 492 }
 493
 494 void
 495 MonitorSection::cut_all ()
 496 {
 497         if (!_monitor) {
 498                 return;
 499         }
 500
 501         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Monitor"), "monitor-cut-all");
 502         if (act) {
 503                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 504                 _monitor->set_cut_all (tact->get_active());
 505         }
 506 }
 507
 508 void
 509 MonitorSection::mono ()
 510 {
 511         if (!_monitor) {
 512                 return;
 513         }
 514
 515         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Monitor"), "monitor-mono");
 516         if (act) {
 517                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 518                 _monitor->set_mono (tact->get_active());
 519         }
 520 }
 521
 522 void
 523 MonitorSection::cut_channel (uint32_t chn)
 524 {
 525         if (!_monitor) {
 526                 return;
 527         }
 528
 529         char buf[64];
 530         snprintf (buf, sizeof (buf), "monitor-cut-%u", chn);
 531
 532         --chn; // 0-based in backend
 533
 534         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Monitor"), buf);
 535         if (act) {
 536                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 537                 _monitor->set_cut (chn, tact->get_active());
 538         }
 539 }
 540
 541 void
 542 MonitorSection::dim_channel (uint32_t chn)
 543 {
 544         if (!_monitor) {
 545                 return;
 546         }
 547
 548         char buf[64];
 549         snprintf (buf, sizeof (buf), "monitor-dim-%u", chn);
 550
 551         --chn; // 0-based in backend
 552
 553         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Monitor"), buf);
 554         if (act) {
 555                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 556                 _monitor->set_dim (chn, tact->get_active());
 557         }
 558
 559 }
 560
 561 void
 562 MonitorSection::solo_channel (uint32_t chn)
 563 {
 564         if (!_monitor) {
 565                 return;
 566         }
 567
 568         char buf[64];
 569         snprintf (buf, sizeof (buf), "monitor-solo-%u", chn);
 570
 571         --chn; // 0-based in backend
 572
 573         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Monitor"), buf);
 574         if (act) {
 575                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 576                 _monitor->set_solo (chn, tact->get_active());
 577         }
 578
 579 }
 580
 581 void
 582 MonitorSection::invert_channel (uint32_t chn)
 583 {
 584         if (!_monitor) {
 585                 return;
 586         }
 587
 588         char buf[64];
 589         snprintf (buf, sizeof (buf), "monitor-invert-%u", chn);
 590
 591         --chn; // 0-based in backend
 592
 593         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Monitor"), buf);
 594         if (act) {
 595                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 596                 _monitor->set_polarity (chn, tact->get_active());
 597         }
 598 }
 599
 600 void
 601 MonitorSection::register_actions ()
 602 {
 603         string action_name;
 604         string action_descr;
 605         Glib::RefPtr<Action> act;
 606
 607         monitor_actions = ActionGroup::create (X_("Monitor"));
 608         ActionManager::add_action_group (monitor_actions);
 609
 610         ActionManager::register_toggle_action (monitor_actions, "monitor-mono", "",
 611                                                sigc::mem_fun (*this, &MonitorSection::mono));
 612
 613         ActionManager::register_toggle_action (monitor_actions, "monitor-cut-all", "",
 614                                                sigc::mem_fun (*this, &MonitorSection::cut_all));
 615
 616         ActionManager::register_toggle_action (monitor_actions, "monitor-dim-all", "",
 617                                                sigc::mem_fun (*this, &MonitorSection::dim_all));
 618
 619         act = ActionManager::register_toggle_action (monitor_actions, "toggle-exclusive-solo", "",
 620                                                sigc::mem_fun (*this, &MonitorSection::toggle_exclusive_solo));
 621
 622         Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 623         tact->set_active (Config->get_exclusive_solo());
 624
 625         act = ActionManager::register_toggle_action (monitor_actions, "toggle-mute-overrides-solo", "",
 626                                                      sigc::mem_fun (*this, &MonitorSection::toggle_mute_overrides_solo));
 627
 628         tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 629         tact->set_active (Config->get_solo_mute_override());
 630
 631         /* map from RC config */
 632
 633
 634
 635         /* note the 1-based counting (for naming - backend uses 0-based) */
 636
 637         for (uint32_t chn = 1; chn <= 16; ++chn) {
 638
 639                 /* for the time being, do not use the action description because it always
 640                    shows up in the buttons, which is undesirable.
 641                 */
 642
 643                 action_name = string_compose (X_("monitor-cut-%1"), chn);
 644                 action_descr = string_compose (_("Cut Monitor Chn %1"), chn);
 645                 ActionManager::register_toggle_action (monitor_actions, action_name.c_str(), "",
 646                                                        sigc::bind (sigc::mem_fun (*this, &MonitorSection::cut_channel), chn));
 647
 648                 action_name = string_compose (X_("monitor-dim-%1"), chn);
 649                 action_descr = string_compose (_("Dim Monitor Chn %1"), chn+1);
 650                 ActionManager::register_toggle_action (monitor_actions, action_name.c_str(), "",
 651                                                        sigc::bind (sigc::mem_fun (*this, &MonitorSection::dim_channel), chn));
 652
 653                 action_name = string_compose (X_("monitor-solo-%1"), chn);
 654                 action_descr = string_compose (_("Solo Monitor Chn %1"), chn);
 655                 ActionManager::register_toggle_action (monitor_actions, action_name.c_str(), "",
 656                                                        sigc::bind (sigc::mem_fun (*this, &MonitorSection::solo_channel), chn));
 657
 658                 action_name = string_compose (X_("monitor-invert-%1"), chn);
 659                 action_descr = string_compose (_("Invert Monitor Chn %1"), chn);
 660                 ActionManager::register_toggle_action (monitor_actions, action_name.c_str(), "",
 661                                                        sigc::bind (sigc::mem_fun (*this, &MonitorSection::invert_channel), chn));
 662
 663         }
 664
 665
 666         Glib::RefPtr<ActionGroup> solo_actions = ActionGroup::create (X_("Solo"));
 667         RadioAction::Group solo_group;
 668
 669         ActionManager::register_radio_action (solo_actions, solo_group, "solo-use-in-place", "",
 670                                               sigc::mem_fun (*this, &MonitorSection::solo_use_in_place));
 671         ActionManager::register_radio_action (solo_actions, solo_group, "solo-use-afl", "",
 672                                               sigc::mem_fun (*this, &MonitorSection::solo_use_afl));
 673         ActionManager::register_radio_action (solo_actions, solo_group, "solo-use-pfl", "",
 674                                               sigc::mem_fun (*this, &MonitorSection::solo_use_pfl));
 675
 676         ActionManager::add_action_group (solo_actions);
 677 }
 678
 679 void
 680 MonitorSection::solo_use_in_place ()
 681 {
 682         /* this is driven by a toggle on a radio group, and so is invoked twice,
 683            once for the item that became inactive and once for the one that became
 684            active.
 685         */
 686
 687         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Solo"), X_("solo-use-in-place"));
 688
 689         if (act) {
 690                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic (act);
 691                 if (ract) {
 692                         Config->set_solo_control_is_listen_control (!ract->get_active());
 693                 }
 694         }
 695 }
 696
 697 void
 698 MonitorSection::solo_use_afl ()
 699 {
 700         /* this is driven by a toggle on a radio group, and so is invoked twice,
 701            once for the item that became inactive and once for the one that became
 702            active.
 703         */
 704
 705         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Solo"), X_("solo-use-afl"));
 706         if (act) {
 707                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic (act);
 708                 if (ract) {
 709                         if (ract->get_active()) {
 710                                 Config->set_listen_position (AfterFaderListen);
 711                                 Config->set_solo_control_is_listen_control (true);
 712                         }
 713                 }
 714         }
 715 }
 716
 717 void
 718 MonitorSection::solo_use_pfl ()
 719 {
 720         /* this is driven by a toggle on a radio group, and so is invoked twice,
 721            once for the item that became inactive and once for the one that became
 722            active.
 723         */
 724
 725         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Solo"), X_("solo-use-afl"));
 726         if (act) {
 727                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic (act);
 728                 if (ract) {
 729                         if (ract->get_active()) {
 730                                 Config->set_listen_position (PreFaderListen);
 731                                 Config->set_solo_control_is_listen_control (true);
 732                         }
 733                 }
 734         }
 735 }
 736
 737 void
 738 MonitorSection::setup_knob_images ()
 739 {
 740         try {
 741
 742                 big_knob_pixbuf = MotionFeedback::render_pixbuf (80);
 743
 744         }  catch (...) {
 745
 746                 error << "No usable large knob image" << endmsg;
 747                 throw failed_constructor ();
 748         }
 749
 750         if (!big_knob_pixbuf) {
 751                 error << "No usable large knob image" << endmsg;
 752                 throw failed_constructor ();
 753         }
 754
 755         try {
 756
 757                 little_knob_pixbuf = MotionFeedback::render_pixbuf (30);
 758
 759         }  catch (...) {
 760
 761                 error << "No usable small knob image" << endmsg;
 762                 throw failed_constructor ();
 763         }
 764
 765         if (!little_knob_pixbuf) {
 766                 error << "No usable small knob image" << endmsg;
 767                 throw failed_constructor ();
 768         }
 769
 770 }
 771
 772 bool
 773 MonitorSection::nonlinear_gain_printer (SpinButton* button)
 774 {
 775         double val = button->get_adjustment()->get_value();
 776         char buf[16];
 777         snprintf (buf, sizeof (buf), "%.1f", accurate_coefficient_to_dB (slider_position_to_gain (val)));
 778         button->set_text (buf);
 779         return true;
 780 }
 781
 782 bool
 783 MonitorSection::linear_gain_printer (SpinButton* button)
 784 {
 785         double val = button->get_adjustment()->get_value();
 786         char buf[16];
 787         snprintf (buf, sizeof (buf), "%.1f", accurate_coefficient_to_dB (val));
 788         button->set_text (buf);
 789         return true;
 790 }
 791
 792 void
 793 MonitorSection::update_solo_model ()
 794 {
 795         const char* action_name;
 796         Glib::RefPtr<Action> act;
 797
 798         if (Config->get_solo_control_is_listen_control()) {
 799                 switch (Config->get_listen_position()) {
 800                 case AfterFaderListen:
 801                         action_name = X_("solo-use-afl");
 802                         break;
 803                 case PreFaderListen:
 804                         action_name = X_("solo-use-pfl");
 805                         break;
 806                 }
 807         } else {
 808                 action_name = X_("solo-use-in-place");
 809         }
 810
 811         act = ActionManager::get_action (X_("Solo"), action_name);
 812         if (act) {
 813                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic (act);
 814                 if (ract) {
 815                         ract->set_active (true);
 816                 }
 817         }
 818 }
 819
 820 void
 821 MonitorSection::map_state ()
 822 {
 823         if (!_route || !_monitor) {
 824                 return;
 825         }
 826
 827         gain_control->get_adjustment()->set_value (gain_to_slider_position (_route->gain_control()->get_value()));
 828         dim_control->get_adjustment()->set_value (_monitor->dim_level());
 829         solo_boost_control->get_adjustment()->set_value (_monitor->solo_boost_level());
 830
 831         Glib::RefPtr<Action> act;
 832
 833         update_solo_model ();
 834
 835         act = ActionManager::get_action (X_("Monitor"), "monitor-cut-all");
 836         if (act) {
 837                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
 838                 if (tact) {
 839                         tact->set_active (_monitor->cut_all());
 840                 }
 841         }
 842
 843         act = ActionManager::get_action (X_("Monitor"), "monitor-dim-all");
 844         if (act) {
 845                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
 846                 if (tact) {
 847                         tact->set_active (_monitor->dim_all());
 848                 }
 849         }
 850
 851         act = ActionManager::get_action (X_("Monitor"), "monitor-mono");
 852         if (act) {
 853                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
 854                 if (tact) {
 855                         tact->set_active (_monitor->mono());
 856                 }
 857         }
 858
 859         uint32_t nchans = _monitor->output_streams().n_audio();
 860
 861         assert (nchans == _channel_buttons.size ());
 862
 863         for (uint32_t n = 0; n < nchans; ++n) {
 864
 865                 char action_name[32];
 866
 867                 snprintf (action_name, sizeof (action_name), "monitor-cut-%u", n+1);
 868                 act = ActionManager::get_action (X_("Monitor"), action_name);
 869                 if (act) {
 870                         Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
 871                         if (tact) {
 872                                 tact->set_active (_monitor->cut (n));
 873                         }
 874                 }
 875
 876                 snprintf (action_name, sizeof (action_name), "monitor-dim-%u", n+1);
 877                 act = ActionManager::get_action (X_("Monitor"), action_name);
 878                 if (act) {
 879                         Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
 880                         if (tact) {
 881                                 tact->set_active (_monitor->dimmed (n));
 882                         }
 883                 }
 884
 885                 snprintf (action_name, sizeof (action_name), "monitor-solo-%u", n+1);
 886                 act = ActionManager::get_action (X_("Monitor"), action_name);
 887                 if (act) {
 888                         Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
 889                         if (tact) {
 890                                 tact->set_active (_monitor->soloed (n));
 891                         }
 892                 }
 893
 894                 snprintf (action_name, sizeof (action_name), "monitor-invert-%u", n+1);
 895                 act = ActionManager::get_action (X_("Monitor"), action_name);
 896                 if (act) {
 897                         Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
 898                         if (tact) {
 899                                 tact->set_active (_monitor->inverted (n));
 900                         }
 901                 }
 902         }
 903 }
 904
 905 void
 906 MonitorSection::do_blink (bool onoff)
 907 {
 908         solo_blink (onoff);
 909         audition_blink (onoff);
 910 }
 911
 912 void
 913 MonitorSection::audition_blink (bool onoff)
 914 {
 915         if (_session == 0) {
 916                 return;
 917         }
 918
 919         if (_session->is_auditioning()) {
 920                 if (onoff) {
 921                         rude_audition_button.set_state (STATE_ACTIVE);
 922                 } else {
 923                         rude_audition_button.set_state (STATE_NORMAL);
 924                 }
 925         } else {
 926                 rude_audition_button.set_active (false);
 927                 rude_audition_button.set_state (STATE_NORMAL);
 928         }
 929 }
 930
 931 void
 932 MonitorSection::solo_blink (bool onoff)
 933 {
 934         if (_session == 0) {
 935                 return;
 936         }
 937
 938         if (_session->soloing() || _session->listening()) {
 939                 if (onoff) {
 940                         rude_solo_button.set_state (STATE_ACTIVE);
 941                 } else {
 942                         rude_solo_button.set_state (STATE_NORMAL);
 943                 }
 944
 945                 if (_session->soloing()) {
 946                         rude_iso_button.set_active (_session->solo_isolated());
 947                 }
 948
 949         } else {
 950                 // rude_solo_button.set_active (false);
 951                 rude_solo_button.set_state (STATE_NORMAL);
 952                 rude_iso_button.set_active (false);
 953         }
 954 }
 955
 956 bool
 957 MonitorSection::cancel_solo (GdkEventButton* ev)
 958 {
 959         if (_session) {
 960                 if (_session->soloing()) {
 961                         _session->set_solo (_session->get_routes(), false);
 962                 } else if (_session->listening()) {
 963                         _session->set_listen (_session->get_routes(), false);
 964                 }
 965         }
 966
 967         return true;
 968 }
 969
 970 bool
 971 MonitorSection::cancel_isolate (GdkEventButton* ev)
 972 {
 973         if (_session) {
 974                 boost::shared_ptr<RouteList> rl (_session->get_routes ());
 975                 _session->set_solo_isolated (rl, false, Session::rt_cleanup, true);
 976         }
 977
 978         return true;
 979 }
 980
 981 bool
 982 MonitorSection::cancel_audition (GdkEventButton* ev)
 983 {
 984         if (_session) {
 985                 _session->cancel_audition();
 986         }
 987         return true;
 988 }
 989
 990 void
 991 MonitorSection::solo_cut_changed ()
 992 {
 993         Config->set_solo_mute_gain (slider_position_to_gain (solo_cut_adjustment.get_value()));
 994 }
 995
 996 void
 997 MonitorSection::parameter_changed (std::string name)
 998 {
 999         if (name == "solo-control-is-listen-control" ||
1000             name == "listen-position") {
1001                 update_solo_model ();
1002         } else if (name == "solo-mute-gain") {
1003                 solo_cut_adjustment.set_value (gain_to_slider_position (Config->get_solo_mute_gain()));
1004         }
1005 }
1006
1007 void
1008 MonitorSection::assign_controllables ()
1009 {
1010         boost::shared_ptr<Controllable> none;
1011
1012         if (!gain_control) {
1013                 /* too early - GUI controls not set up yet */
1014                 return;
1015         }
1016
1017         if (_route) {
1018                 gain_control->set_controllable (_route->gain_control());
1019                 control_link (control_connections, _route->gain_control(), gain_adjustment);
1020         } else {
1021                 gain_control->set_controllable (none);
1022         }
1023
1024         if (_monitor) {
1025
1026                 cut_all_button.set_controllable (_monitor->cut_control());
1027                 cut_all_button.watch ();
1028                 dim_all_button.set_controllable (_monitor->dim_control());
1029                 dim_all_button.watch ();
1030                 mono_button.set_controllable (_monitor->mono_control());
1031                 mono_button.watch ();
1032
1033                 boost::shared_ptr<Controllable> c (_monitor->dim_level_control ());
1034
1035                 dim_control->set_controllable (c);
1036                 dim_adjustment.set_lower (c->lower());
1037                 dim_adjustment.set_upper (c->upper());
1038                 control_link (control_connections, c, dim_adjustment);
1039
1040                 c = _monitor->solo_boost_control ();
1041                 solo_boost_control->set_controllable (c);
1042                 solo_boost_adjustment.set_lower (c->lower());
1043                 solo_boost_adjustment.set_upper (c->upper());
1044                 control_link (control_connections, c, solo_boost_adjustment);
1045
1046         } else {
1047
1048                 cut_all_button.set_controllable (none);
1049                 dim_all_button.set_controllable (none);
1050                 mono_button.set_controllable (none);
1051
1052                 dim_control->set_controllable (none);
1053                 solo_boost_control->set_controllable (none);
1054         }
1055 }