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 "volume_controller.h"
  21 #include "utils.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)
  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 monitor section */
 314                         _monitor = _route->monitor_control ();
 315                         assign_controllables ();
 316                 } else {
 317                         /* session with no monitor section */
 318                         _monitor.reset ();
 319                         _route.reset ();
 320                 }
 321
 322         } else {
 323                 /* no session */
 324
 325                 _monitor.reset ();
 326                 _route.reset ();
 327                 control_connections.drop_connections ();
 328                 rude_iso_button.set_active (false);
 329                 rude_solo_button.set_active (false);
 330
 331                 assign_controllables ();
 332         }
 333 }
 334
 335 MonitorSection::ChannelButtonSet::ChannelButtonSet ()
 336         : cut (X_(""))
 337         , dim (X_(""))
 338         , solo (X_(""))
 339         , invert (X_(""))
 340 {
 341         cut.set_name (X_("MonitorMuteButton"));
 342         dim.set_name (X_("MonitorDimButton"));
 343         solo.set_name (X_("MixerSoloButton"));
 344         invert.set_name (X_("MonitorInvertButton"));
 345
 346         gtk_activatable_set_use_action_appearance (GTK_ACTIVATABLE (cut.gobj()), false);
 347         gtk_activatable_set_use_action_appearance (GTK_ACTIVATABLE (dim.gobj()), false);
 348         gtk_activatable_set_use_action_appearance (GTK_ACTIVATABLE (invert.gobj()), false);
 349         gtk_activatable_set_use_action_appearance (GTK_ACTIVATABLE (solo.gobj()), false);
 350
 351         cut.unset_flags (Gtk::CAN_FOCUS);
 352         dim.unset_flags (Gtk::CAN_FOCUS);
 353         solo.unset_flags (Gtk::CAN_FOCUS);
 354         invert.unset_flags (Gtk::CAN_FOCUS);
 355 }
 356
 357 void
 358 MonitorSection::populate_buttons ()
 359 {
 360         if (!_monitor) {
 361                 return;
 362         }
 363
 364         Glib::RefPtr<Action> act;
 365         uint32_t nchans = _monitor->output_streams().n_audio();
 366
 367         main_table.resize (nchans+1, 5);
 368         main_table.set_col_spacings (6);
 369         main_table.set_row_spacings (6);
 370         main_table.set_homogeneous (true);
 371
 372         Label* l1 = manage (new Label (X_("out")));
 373         main_table.attach (*l1, 0, 1, 0, 1, SHRINK|FILL, SHRINK|FILL);
 374         l1 = manage (new Label (X_("cut")));
 375         main_table.attach (*l1, 1, 2, 0, 1, SHRINK|FILL, SHRINK|FILL);
 376         l1 = manage (new Label (X_("dim")));
 377         main_table.attach (*l1, 2, 3, 0, 1, SHRINK|FILL, SHRINK|FILL);
 378         l1 = manage (new Label (X_("solo")));
 379         main_table.attach (*l1, 3, 4, 0, 1, SHRINK|FILL, SHRINK|FILL);
 380         l1 = manage (new Label (X_("inv")));
 381         main_table.attach (*l1, 4, 5, 0, 1, SHRINK|FILL, SHRINK|FILL);
 382
 383         const uint32_t row_offset = 1;
 384
 385         for (uint32_t i = 0; i < nchans; ++i) {
 386
 387                 string l;
 388                 char buf[64];
 389
 390                 if (nchans == 2) {
 391                         if (i == 0) {
 392                                 l = "L";
 393                         } else {
 394                                 l = "R";
 395                         }
 396                 } else {
 397                         char buf[32];
 398                         snprintf (buf, sizeof (buf), "%d", i+1);
 399                         l = buf;
 400                 }
 401
 402                 Label* label = manage (new Label (l));
 403                 main_table.attach (*label, 0, 1, i+row_offset, i+row_offset+1, SHRINK|FILL, SHRINK|FILL);
 404
 405                 ChannelButtonSet* cbs = new ChannelButtonSet;
 406
 407                 _channel_buttons.push_back (cbs);
 408
 409                 main_table.attach (cbs->cut, 1, 2, i+row_offset, i+row_offset+1, SHRINK|FILL, SHRINK|FILL);
 410                 main_table.attach (cbs->dim, 2, 3, i+row_offset, i+row_offset+1, SHRINK|FILL, SHRINK|FILL);
 411                 main_table.attach (cbs->solo, 3, 4, i+row_offset, i+row_offset+1, SHRINK|FILL, SHRINK|FILL);
 412                 main_table.attach (cbs->invert, 4, 5, i+row_offset, i+row_offset+1, SHRINK|FILL, SHRINK|FILL);
 413
 414                 snprintf (buf, sizeof (buf), "monitor-cut-%u", i+1);
 415                 act = ActionManager::get_action (X_("Monitor"), buf);
 416                 if (act) {
 417                         act->connect_proxy (cbs->cut);
 418                 }
 419
 420                 snprintf (buf, sizeof (buf), "monitor-dim-%u", i+1);
 421                 act = ActionManager::get_action (X_("Monitor"), buf);
 422                 if (act) {
 423                         act->connect_proxy (cbs->dim);
 424                 }
 425
 426                 snprintf (buf, sizeof (buf), "monitor-solo-%u", i+1);
 427                 act = ActionManager::get_action (X_("Monitor"), buf);
 428                 if (act) {
 429                         act->connect_proxy (cbs->solo);
 430                 }
 431
 432                 snprintf (buf, sizeof (buf), "monitor-invert-%u", i+1);
 433                 act = ActionManager::get_action (X_("Monitor"), buf);
 434                 if (act) {
 435                         act->connect_proxy (cbs->invert);
 436                 }
 437         }
 438
 439         main_table.show_all ();
 440 }
 441
 442 void
 443 MonitorSection::set_button_names ()
 444 {
 445         rec_enable_button_label.set_text ("rec");
 446         mute_button_label.set_text ("rec");
 447         solo_button_label.set_text ("rec");
 448 }
 449
 450 void
 451 MonitorSection::toggle_exclusive_solo ()
 452 {
 453         if (!_monitor) {
 454                 return;
 455         }
 456
 457         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Monitor"), "toggle-exclusive-solo");
 458         if (act) {
 459                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 460                 Config->set_exclusive_solo (tact->get_active());
 461         }
 462
 463 }
 464
 465
 466 void
 467 MonitorSection::toggle_mute_overrides_solo ()
 468 {
 469         if (!_monitor) {
 470                 return;
 471         }
 472
 473         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Monitor"), "toggle-mute-overrides-solo");
 474         if (act) {
 475                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 476                 Config->set_solo_mute_override (tact->get_active());
 477         }
 478 }
 479
 480 void
 481 MonitorSection::dim_all ()
 482 {
 483         if (!_monitor) {
 484                 return;
 485         }
 486
 487         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Monitor"), "monitor-dim-all");
 488         if (act) {
 489                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 490                 _monitor->set_dim_all (tact->get_active());
 491         }
 492
 493 }
 494
 495 void
 496 MonitorSection::cut_all ()
 497 {
 498         if (!_monitor) {
 499                 return;
 500         }
 501
 502         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Monitor"), "monitor-cut-all");
 503         if (act) {
 504                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 505                 _monitor->set_cut_all (tact->get_active());
 506         }
 507 }
 508
 509 void
 510 MonitorSection::mono ()
 511 {
 512         if (!_monitor) {
 513                 return;
 514         }
 515
 516         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Monitor"), "monitor-mono");
 517         if (act) {
 518                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 519                 _monitor->set_mono (tact->get_active());
 520         }
 521 }
 522
 523 void
 524 MonitorSection::cut_channel (uint32_t chn)
 525 {
 526         if (!_monitor) {
 527                 return;
 528         }
 529
 530         char buf[64];
 531         snprintf (buf, sizeof (buf), "monitor-cut-%u", chn);
 532
 533         --chn; // 0-based in backend
 534
 535         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Monitor"), buf);
 536         if (act) {
 537                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 538                 _monitor->set_cut (chn, tact->get_active());
 539         }
 540 }
 541
 542 void
 543 MonitorSection::dim_channel (uint32_t chn)
 544 {
 545         if (!_monitor) {
 546                 return;
 547         }
 548
 549         char buf[64];
 550         snprintf (buf, sizeof (buf), "monitor-dim-%u", chn);
 551
 552         --chn; // 0-based in backend
 553
 554         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Monitor"), buf);
 555         if (act) {
 556                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 557                 _monitor->set_dim (chn, tact->get_active());
 558         }
 559
 560 }
 561
 562 void
 563 MonitorSection::solo_channel (uint32_t chn)
 564 {
 565         if (!_monitor) {
 566                 return;
 567         }
 568
 569         char buf[64];
 570         snprintf (buf, sizeof (buf), "monitor-solo-%u", chn);
 571
 572         --chn; // 0-based in backend
 573
 574         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Monitor"), buf);
 575         if (act) {
 576                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 577                 _monitor->set_solo (chn, tact->get_active());
 578         }
 579
 580 }
 581
 582 void
 583 MonitorSection::invert_channel (uint32_t chn)
 584 {
 585         if (!_monitor) {
 586                 return;
 587         }
 588
 589         char buf[64];
 590         snprintf (buf, sizeof (buf), "monitor-invert-%u", chn);
 591
 592         --chn; // 0-based in backend
 593
 594         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Monitor"), buf);
 595         if (act) {
 596                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 597                 _monitor->set_polarity (chn, tact->get_active());
 598         }
 599 }
 600
 601 void
 602 MonitorSection::register_actions ()
 603 {
 604         string action_name;
 605         string action_descr;
 606         Glib::RefPtr<Action> act;
 607
 608         monitor_actions = ActionGroup::create (X_("Monitor"));
 609         ActionManager::add_action_group (monitor_actions);
 610
 611         ActionManager::register_toggle_action (monitor_actions, "monitor-mono", "",
 612                                                sigc::mem_fun (*this, &MonitorSection::mono));
 613
 614         ActionManager::register_toggle_action (monitor_actions, "monitor-cut-all", "",
 615                                                sigc::mem_fun (*this, &MonitorSection::cut_all));
 616
 617         ActionManager::register_toggle_action (monitor_actions, "monitor-dim-all", "",
 618                                                sigc::mem_fun (*this, &MonitorSection::dim_all));
 619
 620         act = ActionManager::register_toggle_action (monitor_actions, "toggle-exclusive-solo", "",
 621                                                sigc::mem_fun (*this, &MonitorSection::toggle_exclusive_solo));
 622
 623         Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 624         tact->set_active (Config->get_exclusive_solo());
 625
 626         act = ActionManager::register_toggle_action (monitor_actions, "toggle-mute-overrides-solo", "",
 627                                                      sigc::mem_fun (*this, &MonitorSection::toggle_mute_overrides_solo));
 628
 629         tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
 630         tact->set_active (Config->get_solo_mute_override());
 631
 632
 633         /* note the 1-based counting (for naming - backend uses 0-based) */
 634
 635         for (uint32_t chn = 1; chn <= 16; ++chn) {
 636
 637                 /* for the time being, do not use the action description because it always
 638                    shows up in the buttons, which is undesirable.
 639                 */
 640
 641                 action_name = string_compose (X_("monitor-cut-%1"), chn);
 642                 action_descr = string_compose (_("Cut Monitor Chn %1"), chn);
 643                 ActionManager::register_toggle_action (monitor_actions, action_name.c_str(), "",
 644                                                        sigc::bind (sigc::mem_fun (*this, &MonitorSection::cut_channel), chn));
 645
 646                 action_name = string_compose (X_("monitor-dim-%1"), chn);
 647                 action_descr = string_compose (_("Dim Monitor Chn %1"), chn+1);
 648                 ActionManager::register_toggle_action (monitor_actions, action_name.c_str(), "",
 649                                                        sigc::bind (sigc::mem_fun (*this, &MonitorSection::dim_channel), chn));
 650
 651                 action_name = string_compose (X_("monitor-solo-%1"), chn);
 652                 action_descr = string_compose (_("Solo Monitor Chn %1"), chn);
 653                 ActionManager::register_toggle_action (monitor_actions, action_name.c_str(), "",
 654                                                        sigc::bind (sigc::mem_fun (*this, &MonitorSection::solo_channel), chn));
 655
 656                 action_name = string_compose (X_("monitor-invert-%1"), chn);
 657                 action_descr = string_compose (_("Invert Monitor Chn %1"), chn);
 658                 ActionManager::register_toggle_action (monitor_actions, action_name.c_str(), "",
 659                                                        sigc::bind (sigc::mem_fun (*this, &MonitorSection::invert_channel), chn));
 660
 661         }
 662
 663
 664         Glib::RefPtr<ActionGroup> solo_actions = ActionGroup::create (X_("Solo"));
 665         RadioAction::Group solo_group;
 666
 667         ActionManager::register_radio_action (solo_actions, solo_group, "solo-use-in-place", "",
 668                                               sigc::mem_fun (*this, &MonitorSection::solo_use_in_place));
 669         ActionManager::register_radio_action (solo_actions, solo_group, "solo-use-afl", "",
 670                                               sigc::mem_fun (*this, &MonitorSection::solo_use_afl));
 671         ActionManager::register_radio_action (solo_actions, solo_group, "solo-use-pfl", "",
 672                                               sigc::mem_fun (*this, &MonitorSection::solo_use_pfl));
 673
 674         ActionManager::add_action_group (solo_actions);
 675 }
 676
 677 void
 678 MonitorSection::solo_use_in_place ()
 679 {
 680         /* this is driven by a toggle on a radio group, and so is invoked twice,
 681            once for the item that became inactive and once for the one that became
 682            active.
 683         */
 684
 685         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Solo"), X_("solo-use-in-place"));
 686
 687         if (act) {
 688                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic (act);
 689                 if (ract) {
 690                         Config->set_solo_control_is_listen_control (!ract->get_active());
 691                 }
 692         }
 693 }
 694
 695 void
 696 MonitorSection::solo_use_afl ()
 697 {
 698         /* this is driven by a toggle on a radio group, and so is invoked twice,
 699            once for the item that became inactive and once for the one that became
 700            active.
 701         */
 702
 703         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Solo"), X_("solo-use-afl"));
 704         if (act) {
 705                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic (act);
 706                 if (ract) {
 707                         if (ract->get_active()) {
 708                                 Config->set_listen_position (AfterFaderListen);
 709                                 Config->set_solo_control_is_listen_control (true);
 710                         }
 711                 }
 712         }
 713 }
 714
 715 void
 716 MonitorSection::solo_use_pfl ()
 717 {
 718         /* this is driven by a toggle on a radio group, and so is invoked twice,
 719            once for the item that became inactive and once for the one that became
 720            active.
 721         */
 722
 723         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Solo"), X_("solo-use-afl"));
 724         if (act) {
 725                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic (act);
 726                 if (ract) {
 727                         if (ract->get_active()) {
 728                                 Config->set_listen_position (PreFaderListen);
 729                                 Config->set_solo_control_is_listen_control (true);
 730                         }
 731                 }
 732         }
 733 }
 734
 735 void
 736 MonitorSection::setup_knob_images ()
 737 {
 738         try {
 739
 740                 big_knob_pixbuf = MotionFeedback::render_pixbuf (80);
 741
 742         }  catch (...) {
 743
 744                 error << "No usable large knob image" << endmsg;
 745                 throw failed_constructor ();
 746         }
 747
 748         if (!big_knob_pixbuf) {
 749                 error << "No usable large knob image" << endmsg;
 750                 throw failed_constructor ();
 751         }
 752
 753         try {
 754
 755                 little_knob_pixbuf = MotionFeedback::render_pixbuf (30);
 756
 757         }  catch (...) {
 758
 759                 error << "No usable small knob image" << endmsg;
 760                 throw failed_constructor ();
 761         }
 762
 763         if (!little_knob_pixbuf) {
 764                 error << "No usable small knob image" << endmsg;
 765                 throw failed_constructor ();
 766         }
 767
 768 }
 769
 770 bool
 771 MonitorSection::nonlinear_gain_printer (SpinButton* button)
 772 {
 773         double val = button->get_adjustment()->get_value();
 774         char buf[16];
 775         snprintf (buf, sizeof (buf), "%.1f", accurate_coefficient_to_dB (slider_position_to_gain (val)));
 776         button->set_text (buf);
 777         return true;
 778 }
 779
 780 bool
 781 MonitorSection::linear_gain_printer (SpinButton* button)
 782 {
 783         double val = button->get_adjustment()->get_value();
 784         char buf[16];
 785         snprintf (buf, sizeof (buf), "%.1f", accurate_coefficient_to_dB (val));
 786         button->set_text (buf);
 787         return true;
 788 }
 789
 790 void
 791 MonitorSection::update_solo_model ()
 792 {
 793         const char* action_name;
 794         Glib::RefPtr<Action> act;
 795
 796         if (Config->get_solo_control_is_listen_control()) {
 797                 switch (Config->get_listen_position()) {
 798                 case AfterFaderListen:
 799                         action_name = X_("solo-use-afl");
 800                         break;
 801                 case PreFaderListen:
 802                         action_name = X_("solo-use-pfl");
 803                         break;
 804                 }
 805         } else {
 806                 action_name = X_("solo-use-in-place");
 807         }
 808
 809         act = ActionManager::get_action (X_("Solo"), action_name);
 810         if (act) {
 811                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic (act);
 812                 if (ract) {
 813                         ract->set_active (true);
 814                 }
 815         }
 816 }
 817
 818 void
 819 MonitorSection::map_state ()
 820 {
 821         if (!_route || !_monitor) {
 822                 return;
 823         }
 824
 825         gain_control->get_adjustment()->set_value (gain_to_slider_position (_route->gain_control()->get_value()));
 826         dim_control->get_adjustment()->set_value (_monitor->dim_level());
 827         solo_boost_control->get_adjustment()->set_value (_monitor->solo_boost_level());
 828
 829         Glib::RefPtr<Action> act;
 830
 831         update_solo_model ();
 832
 833         act = ActionManager::get_action (X_("Monitor"), "monitor-cut-all");
 834         if (act) {
 835                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
 836                 if (tact) {
 837                         tact->set_active (_monitor->cut_all());
 838                 }
 839         }
 840
 841         act = ActionManager::get_action (X_("Monitor"), "monitor-dim-all");
 842         if (act) {
 843                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
 844                 if (tact) {
 845                         tact->set_active (_monitor->dim_all());
 846                 }
 847         }
 848
 849         act = ActionManager::get_action (X_("Monitor"), "monitor-mono");
 850         if (act) {
 851                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
 852                 if (tact) {
 853                         tact->set_active (_monitor->mono());
 854                 }
 855         }
 856
 857         uint32_t nchans = _monitor->output_streams().n_audio();
 858
 859         assert (nchans == _channel_buttons.size ());
 860
 861         for (uint32_t n = 0; n < nchans; ++n) {
 862
 863                 char action_name[32];
 864
 865                 snprintf (action_name, sizeof (action_name), "monitor-cut-%u", n+1);
 866                 act = ActionManager::get_action (X_("Monitor"), action_name);
 867                 if (act) {
 868                         Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
 869                         if (tact) {
 870                                 tact->set_active (_monitor->cut (n));
 871                         }
 872                 }
 873
 874                 snprintf (action_name, sizeof (action_name), "monitor-dim-%u", n+1);
 875                 act = ActionManager::get_action (X_("Monitor"), action_name);
 876                 if (act) {
 877                         Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
 878                         if (tact) {
 879                                 tact->set_active (_monitor->dimmed (n));
 880                         }
 881                 }
 882
 883                 snprintf (action_name, sizeof (action_name), "monitor-solo-%u", n+1);
 884                 act = ActionManager::get_action (X_("Monitor"), action_name);
 885                 if (act) {
 886                         Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
 887                         if (tact) {
 888                                 tact->set_active (_monitor->soloed (n));
 889                         }
 890                 }
 891
 892                 snprintf (action_name, sizeof (action_name), "monitor-invert-%u", n+1);
 893                 act = ActionManager::get_action (X_("Monitor"), action_name);
 894                 if (act) {
 895                         Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
 896                         if (tact) {
 897                                 tact->set_active (_monitor->inverted (n));
 898                         }
 899                 }
 900         }
 901 }
 902
 903 void
 904 MonitorSection::do_blink (bool onoff)
 905 {
 906         solo_blink (onoff);
 907         audition_blink (onoff);
 908 }
 909
 910 void
 911 MonitorSection::audition_blink (bool onoff)
 912 {
 913         if (_session == 0) {
 914                 return;
 915         }
 916
 917         if (_session->is_auditioning()) {
 918                 if (onoff) {
 919                         rude_audition_button.set_state (STATE_ACTIVE);
 920                 } else {
 921                         rude_audition_button.set_state (STATE_NORMAL);
 922                 }
 923         } else {
 924                 rude_audition_button.set_active (false);
 925                 rude_audition_button.set_state (STATE_NORMAL);
 926         }
 927 }
 928
 929 void
 930 MonitorSection::solo_blink (bool onoff)
 931 {
 932         if (_session == 0) {
 933                 return;
 934         }
 935
 936         if (_session->soloing() || _session->listening()) {
 937                 if (onoff) {
 938                         rude_solo_button.set_state (STATE_ACTIVE);
 939                 } else {
 940                         rude_solo_button.set_state (STATE_NORMAL);
 941                 }
 942
 943                 if (_session->soloing()) {
 944                         rude_iso_button.set_active (_session->solo_isolated());
 945                 }
 946
 947         } else {
 948                 // rude_solo_button.set_active (false);
 949                 rude_solo_button.set_state (STATE_NORMAL);
 950                 rude_iso_button.set_active (false);
 951         }
 952 }
 953
 954 bool
 955 MonitorSection::cancel_solo (GdkEventButton*)
 956 {
 957         if (_session) {
 958                 if (_session->soloing()) {
 959                         _session->set_solo (_session->get_routes(), false);
 960                 } else if (_session->listening()) {
 961                         _session->set_listen (_session->get_routes(), false);
 962                 }
 963         }
 964
 965         return true;
 966 }
 967
 968 bool
 969 MonitorSection::cancel_isolate (GdkEventButton*)
 970 {
 971         if (_session) {
 972                 boost::shared_ptr<RouteList> rl (_session->get_routes ());
 973                 _session->set_solo_isolated (rl, false, Session::rt_cleanup, true);
 974         }
 975
 976         return true;
 977 }
 978
 979 bool
 980 MonitorSection::cancel_audition (GdkEventButton*)
 981 {
 982         if (_session) {
 983                 _session->cancel_audition();
 984         }
 985         return true;
 986 }
 987
 988 void
 989 MonitorSection::solo_cut_changed ()
 990 {
 991         Config->set_solo_mute_gain (slider_position_to_gain (solo_cut_adjustment.get_value()));
 992 }
 993
 994 void
 995 MonitorSection::parameter_changed (std::string name)
 996 {
 997         if (name == "solo-control-is-listen-control" ||
 998             name == "listen-position") {
 999                 update_solo_model ();
1000         } else if (name == "solo-mute-gain") {
1001                 solo_cut_adjustment.set_value (gain_to_slider_position (Config->get_solo_mute_gain()));
1002         }
1003 }
1004
1005 void
1006 MonitorSection::assign_controllables ()
1007 {
1008         boost::shared_ptr<Controllable> none;
1009
1010         if (!gain_control) {
1011                 /* too early - GUI controls not set up yet */
1012                 return;
1013         }
1014
1015         if (_session) {
1016                 boost::shared_ptr<Controllable> c = _session->solo_cut_control();
1017                 solo_cut_control->set_controllable (c);
1018                 solo_cut_control->get_adjustment()->set_value (c->get_value());
1019         } else {
1020                 solo_cut_control->set_controllable (none);
1021         }
1022
1023         if (_route) {
1024                 gain_control->set_controllable (_route->gain_control());
1025         } else {
1026                 gain_control->set_controllable (none);
1027         }
1028
1029         if (_monitor) {
1030
1031                 cut_all_button.set_controllable (_monitor->cut_control());
1032                 cut_all_button.watch ();
1033                 dim_all_button.set_controllable (_monitor->dim_control());
1034                 dim_all_button.watch ();
1035                 mono_button.set_controllable (_monitor->mono_control());
1036                 mono_button.watch ();
1037
1038                 boost::shared_ptr<Controllable> c (_monitor->dim_level_control ());
1039
1040                 dim_control->set_controllable (c);
1041                 dim_adjustment.set_lower (c->lower());
1042                 dim_adjustment.set_upper (c->upper());
1043
1044                 c = _monitor->solo_boost_control ();
1045                 solo_boost_control->set_controllable (c);
1046                 solo_boost_adjustment.set_lower (c->lower());
1047                 solo_boost_adjustment.set_upper (c->upper());
1048
1049         } else {
1050
1051                 cut_all_button.set_controllable (none);
1052                 dim_all_button.set_controllable (none);
1053                 mono_button.set_controllable (none);
1054
1055                 dim_control->set_controllable (none);
1056                 solo_boost_control->set_controllable (none);
1057         }
1058 }