gtk2_ardour/ardour_ui2.cc

   1 /*
   2     Copyright (C) 1999 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 #include <fcntl.h>
  21 #include <signal.h>
  22 #include <unistd.h>
  23 #include <cerrno>
  24 #include <iostream>
  25 #include <cmath>
  26
  27 #include <sigc++/bind.h>
  28 #include <pbd/error.h>
  29 #include <pbd/basename.h>
  30 #include <pbd/fastlog.h>
  31 #include <gtkmm2ext/utils.h>
  32 #include <gtkmm2ext/click_box.h>
  33 #include <gtkmm2ext/tearoff.h>
  34
  35 #include <ardour/audioengine.h>
  36 #include <ardour/ardour.h>
  37 #include <ardour/profile.h>
  38 #include <ardour/route.h>
  39
  40 #include "ardour_ui.h"
  41 #include "keyboard.h"
  42 #include "public_editor.h"
  43 #include "audio_clock.h"
  44 #include "actions.h"
  45 #include "utils.h"
  46 #include "theme_manager.h"
  47
  48 #include "i18n.h"
  49
  50 using namespace std;
  51 using namespace ARDOUR;
  52 using namespace PBD;
  53 using namespace Gtkmm2ext;
  54 using namespace Gtk;
  55 using namespace Glib;
  56 using namespace sigc;
  57
  58 int
  59 ARDOUR_UI::setup_windows ()
  60 {
  61         if (create_editor ()) {
  62                 error << _("UI: cannot setup editor") << endmsg;
  63                 return -1;
  64         }
  65
  66         if (create_mixer ()) {
  67                 error << _("UI: cannot setup mixer") << endmsg;
  68                 return -1;
  69         }
  70
  71         /* all other dialogs are created conditionally */
  72
  73         we_have_dependents ();
  74
  75         setup_clock ();
  76         setup_transport();
  77         build_menu_bar ();
  78
  79         theme_manager->signal_unmap().connect (bind (sigc::ptr_fun(&ActionManager::uncheck_toggleaction), X_("<Actions>/Common/ToggleThemeManager")));
  80
  81 #ifdef TOP_MENUBAR
  82         HBox* status_bar_packer = manage (new HBox);
  83
  84         status_bar_label.set_size_request (300, -1);
  85         status_bar_packer->pack_start (status_bar_label, true, true, 6);
  86         status_bar_packer->pack_start (error_log_button, false, false);
  87
  88         error_log_button.signal_clicked().connect (mem_fun (*this, &UI::toggle_errors));
  89
  90         editor->get_status_bar_packer().pack_start (*status_bar_packer, true, true);
  91         editor->get_status_bar_packer().pack_start (menu_bar_base, false, false, 6);
  92 #else
  93         top_packer.pack_start (menu_bar_base, false, false);
  94 #endif
  95
  96         top_packer.pack_start (transport_frame, false, false);
  97
  98         editor->add_toplevel_controls (top_packer);
  99
 100         return 0;
 101 }
 102
 103  void
 104 ARDOUR_UI::display_message (const char *prefix, gint prefix_len, RefPtr<TextBuffer::Tag> ptag, RefPtr<TextBuffer::Tag> mtag, const char *msg)
 105 {
 106         ustring text;
 107
 108         UI::display_message (prefix, prefix_len, ptag, mtag, msg);
 109 #ifdef TOP_MENUBAR
 110
 111         if (strcmp (prefix, _("[ERROR]: ")) == 0) {
 112                 text = "<span color=\"red\" weight=\"bold\">";
 113         } else if (strcmp (prefix, _("[WARNING]: ")) == 0) {
 114                 text = "<span color=\"yellow\" weight=\"bold\">";
 115         } else if (strcmp (prefix, _("[INFO]: ")) == 0) {
 116                 text = "<span color=\"green\" weight=\"bold\">";
 117         } else {
 118                 text = "<span color=\"white\" weight=\"bold\">???";
 119         }
 120
 121         text += prefix;
 122         text += "</span>";
 123         text += msg;
 124
 125         status_bar_label.set_markup (text);
 126 #endif
 127 }
 128
 129 void
 130 ARDOUR_UI::transport_stopped ()
 131 {
 132         stop_button.set_visual_state (1);
 133
 134         roll_button.set_visual_state (0);
 135         play_selection_button.set_visual_state (0);
 136         auto_loop_button.set_visual_state (0);
 137
 138         shuttle_fract = 0;
 139         shuttle_box.queue_draw ();
 140
 141         update_disk_space ();
 142 }
 143
 144 void
 145 ARDOUR_UI::transport_rolling ()
 146 {
 147         stop_button.set_visual_state (0);
 148         if (session->get_play_range()) {
 149                 play_selection_button.set_visual_state (1);
 150                 roll_button.set_visual_state (0);
 151                 auto_loop_button.set_visual_state (0);
 152
 153         } else if (session->get_play_loop ()) {
 154                 auto_loop_button.set_visual_state (1);
 155                 play_selection_button.set_visual_state (0);
 156                 roll_button.set_visual_state (0);
 157
 158         } else {
 159
 160                 roll_button.set_visual_state (1);
 161                 play_selection_button.set_visual_state (0);
 162                 auto_loop_button.set_visual_state (0);
 163         }
 164
 165         /* reset shuttle controller */
 166
 167         shuttle_fract = SHUTTLE_FRACT_SPEED1;  /* speed = 1.0, believe it or not */
 168         shuttle_box.queue_draw ();
 169 }
 170
 171 void
 172 ARDOUR_UI::transport_rewinding ()
 173 {
 174         stop_button.set_visual_state (0);
 175         roll_button.set_visual_state (1);
 176         play_selection_button.set_visual_state (0);
 177         auto_loop_button.set_visual_state (0);
 178 }
 179
 180 void
 181 ARDOUR_UI::transport_forwarding ()
 182 {
 183         stop_button.set_visual_state (0);
 184         roll_button.set_visual_state (1);
 185         play_selection_button.set_visual_state (0);
 186         auto_loop_button.set_visual_state (0);
 187 }
 188
 189 void
 190 ARDOUR_UI::setup_transport ()
 191 {
 192         transport_tearoff = manage (new TearOff (transport_tearoff_hbox));
 193         transport_tearoff->set_name ("TransportBase");
 194
 195         transport_hbox.pack_start (*transport_tearoff, true, false);
 196
 197         transport_base.set_name ("TransportBase");
 198         transport_base.add (transport_hbox);
 199
 200         transport_frame.set_shadow_type (SHADOW_OUT);
 201         transport_frame.set_name ("BaseFrame");
 202         transport_frame.add (transport_base);
 203
 204         transport_tearoff->Detach.connect (bind (mem_fun(*this, &ARDOUR_UI::detach_tearoff), static_cast<Box*>(&top_packer),
 205                                                  static_cast<Widget*>(&transport_frame)));
 206         transport_tearoff->Attach.connect (bind (mem_fun(*this, &ARDOUR_UI::reattach_tearoff), static_cast<Box*> (&top_packer),
 207                                                  static_cast<Widget*> (&transport_frame), 1));
 208         transport_tearoff->Hidden.connect (bind (mem_fun(*this, &ARDOUR_UI::detach_tearoff), static_cast<Box*>(&top_packer),
 209                                                  static_cast<Widget*>(&transport_frame)));
 210         transport_tearoff->Visible.connect (bind (mem_fun(*this, &ARDOUR_UI::reattach_tearoff), static_cast<Box*> (&top_packer),
 211                                                   static_cast<Widget*> (&transport_frame), 1));
 212
 213         shuttle_box.set_name ("TransportButton");
 214         goto_start_button.set_name ("TransportButton");
 215         goto_end_button.set_name ("TransportButton");
 216         roll_button.set_name ("TransportButton");
 217         stop_button.set_name ("TransportButton");
 218         play_selection_button.set_name ("TransportButton");
 219         rec_button.set_name ("TransportRecButton");
 220         auto_loop_button.set_name ("TransportButton");
 221
 222         auto_return_button.set_name ("TransportButton");
 223         auto_play_button.set_name ("TransportButton");
 224         auto_input_button.set_name ("TransportButton");
 225         punch_in_button.set_name ("TransportButton");
 226         punch_out_button.set_name ("TransportButton");
 227         click_button.set_name ("TransportButton");
 228         time_master_button.set_name ("TransportButton");
 229
 230         stop_button.set_size_request(29, -1);
 231         roll_button.set_size_request(29, -1);
 232         auto_loop_button.set_size_request(29, -1);
 233         play_selection_button.set_size_request(29, -1);
 234         goto_start_button.set_size_request(29, -1);
 235         goto_end_button.set_size_request(29, -1);
 236         rec_button.set_size_request(29, -1);
 237
 238         Widget* w;
 239
 240         stop_button.set_visual_state (1);
 241
 242         w = manage (new Image (get_icon (X_("transport_start"))));
 243         w->show();
 244         goto_start_button.add (*w);
 245         w = manage (new Image (get_icon (X_("transport_end"))));
 246         w->show();
 247         goto_end_button.add (*w);
 248         w = manage (new Image (get_icon (X_("transport_play"))));
 249         w->show();
 250         roll_button.add (*w);
 251         w = manage (new Image (get_icon (X_("transport_stop"))));
 252         w->show();
 253         stop_button.add (*w);
 254         w = manage (new Image (get_icon (X_("transport_range"))));
 255         w->show();
 256         play_selection_button.add (*w);
 257         w = manage (new Image (get_icon (X_("transport_record"))));
 258         w->show();
 259         rec_button.add (*w);
 260         w = manage (new Image (get_icon (X_("transport_loop"))));
 261         w->show();
 262         auto_loop_button.add (*w);
 263
 264         RefPtr<Action> act;
 265
 266         act = ActionManager::get_action (X_("Transport"), X_("Stop"));
 267         act->connect_proxy (stop_button);
 268         act = ActionManager::get_action (X_("Transport"), X_("Roll"));
 269         act->connect_proxy (roll_button);
 270         act = ActionManager::get_action (X_("Transport"), X_("Record"));
 271         act->connect_proxy (rec_button);
 272         act = ActionManager::get_action (X_("Transport"), X_("GotoStart"));
 273         act->connect_proxy (goto_start_button);
 274         act = ActionManager::get_action (X_("Transport"), X_("GotoEnd"));
 275         act->connect_proxy (goto_end_button);
 276         act = ActionManager::get_action (X_("Transport"), X_("Loop"));
 277         act->connect_proxy (auto_loop_button);
 278         act = ActionManager::get_action (X_("Transport"), X_("PlaySelection"));
 279         act->connect_proxy (play_selection_button);
 280         act = ActionManager::get_action (X_("Transport"), X_("ToggleTimeMaster"));
 281         act->connect_proxy (time_master_button);
 282
 283         ARDOUR_UI::instance()->tooltips().set_tip (roll_button, _("Play from playhead"));
 284         ARDOUR_UI::instance()->tooltips().set_tip (stop_button, _("Stop playback"));
 285         ARDOUR_UI::instance()->tooltips().set_tip (play_selection_button, _("Play range/selection"));
 286         ARDOUR_UI::instance()->tooltips().set_tip (goto_start_button, _("Go to start of session"));
 287         ARDOUR_UI::instance()->tooltips().set_tip (goto_end_button, _("Go to end of session"));
 288         ARDOUR_UI::instance()->tooltips().set_tip (auto_loop_button, _("Play loop range"));
 289
 290         ARDOUR_UI::instance()->tooltips().set_tip (auto_return_button, _("Return to last playback start when stopped"));
 291         ARDOUR_UI::instance()->tooltips().set_tip (auto_play_button, _("Start playback after any locate"));
 292         ARDOUR_UI::instance()->tooltips().set_tip (auto_input_button, _("Be sensible about input monitoring"));
 293         ARDOUR_UI::instance()->tooltips().set_tip (punch_in_button, _("Start recording at auto-punch start"));
 294         ARDOUR_UI::instance()->tooltips().set_tip (punch_out_button, _("Stop recording at auto-punch end"));
 295         ARDOUR_UI::instance()->tooltips().set_tip (click_button, _("Enable/Disable audio click"));
 296         ARDOUR_UI::instance()->tooltips().set_tip (sync_option_combo, _("Positional sync source"));
 297         ARDOUR_UI::instance()->tooltips().set_tip (time_master_button, _("Does Ardour control the time?"));
 298         ARDOUR_UI::instance()->tooltips().set_tip (shuttle_box, _("Shuttle speed control"));
 299         ARDOUR_UI::instance()->tooltips().set_tip (shuttle_units_button, _("Select semitones or %%-age for speed display"));
 300         ARDOUR_UI::instance()->tooltips().set_tip (speed_display_box, _("Current transport speed"));
 301
 302         shuttle_box.set_flags (CAN_FOCUS);
 303         shuttle_box.add_events (Gdk::ENTER_NOTIFY_MASK|Gdk::LEAVE_NOTIFY_MASK|Gdk::BUTTON_RELEASE_MASK|Gdk::BUTTON_PRESS_MASK|Gdk::POINTER_MOTION_MASK|Gdk::SCROLL_MASK);
 304         shuttle_box.set_size_request (100, 15);
 305
 306         shuttle_box.signal_button_press_event().connect (mem_fun(*this, &ARDOUR_UI::shuttle_box_button_press));
 307         shuttle_box.signal_button_release_event().connect (mem_fun(*this, &ARDOUR_UI::shuttle_box_button_release));
 308         shuttle_box.signal_scroll_event().connect (mem_fun(*this, &ARDOUR_UI::shuttle_box_scroll));
 309         shuttle_box.signal_motion_notify_event().connect (mem_fun(*this, &ARDOUR_UI::shuttle_box_motion));
 310         shuttle_box.signal_expose_event().connect (mem_fun(*this, &ARDOUR_UI::shuttle_box_expose));
 311
 312         /* clocks, etc. */
 313
 314         ARDOUR_UI::Clock.connect (bind (mem_fun (primary_clock, &AudioClock::set), 'p'));
 315         ARDOUR_UI::Clock.connect (bind (mem_fun (secondary_clock, &AudioClock::set), 's'));
 316
 317         primary_clock.ValueChanged.connect (mem_fun(*this, &ARDOUR_UI::primary_clock_value_changed));
 318         secondary_clock.ValueChanged.connect (mem_fun(*this, &ARDOUR_UI::secondary_clock_value_changed));
 319         big_clock.ValueChanged.connect (mem_fun(*this, &ARDOUR_UI::big_clock_value_changed));
 320
 321         ARDOUR_UI::instance()->tooltips().set_tip (primary_clock, _("Primary clock"));
 322         ARDOUR_UI::instance()->tooltips().set_tip (secondary_clock, _("secondary clock"));
 323
 324         ActionManager::get_action ("Transport", "ToggleAutoReturn")->connect_proxy (auto_return_button);
 325         ActionManager::get_action ("Transport", "ToggleAutoPlay")->connect_proxy (auto_play_button);
 326         ActionManager::get_action ("Transport", "ToggleAutoInput")->connect_proxy (auto_input_button);
 327         ActionManager::get_action ("Transport", "ToggleClick")->connect_proxy (click_button);
 328         ActionManager::get_action ("Transport", "TogglePunchIn")->connect_proxy (punch_in_button);
 329         ActionManager::get_action ("Transport", "TogglePunchOut")->connect_proxy (punch_out_button);
 330
 331         preroll_button.set_name ("TransportButton");
 332         postroll_button.set_name ("TransportButton");
 333
 334         preroll_clock.set_mode (AudioClock::MinSec);
 335         preroll_clock.set_name ("TransportClockDisplay");
 336         postroll_clock.set_mode (AudioClock::MinSec);
 337         postroll_clock.set_name ("TransportClockDisplay");
 338
 339         /* alerts */
 340
 341         /* CANNOT bind these to clicked or toggled, must use pressed or released */
 342
 343         solo_alert_button.set_name ("TransportSoloAlert");
 344         solo_alert_button.signal_pressed().connect (mem_fun(*this,&ARDOUR_UI::solo_alert_toggle));
 345         auditioning_alert_button.set_name ("TransportAuditioningAlert");
 346         auditioning_alert_button.signal_pressed().connect (mem_fun(*this,&ARDOUR_UI::audition_alert_toggle));
 347
 348         tooltips().set_tip (solo_alert_button, _("When active, something is soloed.\nClick to de-solo everything"));
 349         tooltips().set_tip (auditioning_alert_button, _("When active, auditioning is taking place\nClick to stop the audition"));
 350
 351         alert_box.pack_start (solo_alert_button, false, false);
 352         alert_box.pack_start (auditioning_alert_button, false, false);
 353
 354         transport_tearoff_hbox.set_border_width (3);
 355
 356         transport_tearoff_hbox.pack_start (goto_start_button, false, false);
 357         transport_tearoff_hbox.pack_start (goto_end_button, false, false);
 358
 359         Frame* sframe = manage (new Frame);
 360         VBox*  svbox = manage (new VBox);
 361         HBox*  shbox = manage (new HBox);
 362
 363         sframe->set_shadow_type (SHADOW_IN);
 364         sframe->add (shuttle_box);
 365
 366         shuttle_box.set_name (X_("ShuttleControl"));
 367
 368         speed_display_box.add (speed_display_label);
 369         speed_display_box.set_name (X_("ShuttleDisplay"));
 370
 371         shuttle_units_button.set_name (X_("ShuttleButton"));
 372         shuttle_units_button.signal_clicked().connect (mem_fun(*this, &ARDOUR_UI::shuttle_unit_clicked));
 373
 374         shuttle_style_button.set_name (X_("ShuttleButton"));
 375
 376         vector<string> shuttle_strings;
 377         shuttle_strings.push_back (_("sprung"));
 378         shuttle_strings.push_back (_("wheel"));
 379         set_popdown_strings (shuttle_style_button, shuttle_strings);
 380         shuttle_style_button.signal_changed().connect (mem_fun (*this, &ARDOUR_UI::shuttle_style_changed));
 381
 382         Frame* sdframe = manage (new Frame);
 383
 384         sdframe->set_shadow_type (SHADOW_IN);
 385         sdframe->add (speed_display_box);
 386
 387         mtc_port_changed ();
 388         sync_option_combo.signal_changed().connect (mem_fun (*this, &ARDOUR_UI::sync_option_changed));
 389         const guint32 FUDGE = 25; // Combo's are stupid - they steal space from the entry for the button
 390         set_size_request_to_display_given_text (sync_option_combo, X_("Igternal"), 2+FUDGE, 10);
 391
 392         shbox->pack_start (*sdframe, false, false);
 393         shbox->pack_start (shuttle_units_button, true, true);
 394         shbox->pack_start (shuttle_style_button, false, false);
 395
 396         svbox->pack_start (*sframe, false, false);
 397         svbox->pack_start (*shbox, false, false);
 398
 399         transport_tearoff_hbox.pack_start (*svbox, false, false, 3);
 400
 401         transport_tearoff_hbox.pack_start (auto_loop_button, false, false);
 402         if (!Profile->get_sae()) {
 403                 transport_tearoff_hbox.pack_start (play_selection_button, false, false);
 404         }
 405         transport_tearoff_hbox.pack_start (roll_button, false, false);
 406         transport_tearoff_hbox.pack_start (stop_button, false, false);
 407         transport_tearoff_hbox.pack_start (rec_button, false, false, 6);
 408
 409         HBox* clock_box = manage (new HBox);
 410         clock_box->pack_start (primary_clock, false, false);
 411         if (!ARDOUR::Profile->get_small_screen()) {
 412                 clock_box->pack_start (secondary_clock, false, false);
 413         }
 414
 415         if (!Profile->get_sae()) {
 416                 VBox* time_controls_box = manage (new VBox);
 417                 time_controls_box->pack_start (sync_option_combo, false, false);
 418                 time_controls_box->pack_start (time_master_button, false, false);
 419                 clock_box->pack_start (*time_controls_box, false, false, 1);
 420         }
 421
 422         transport_tearoff_hbox.pack_start (*clock_box, false, false, 0);
 423
 424         HBox* toggle_box = manage(new HBox);
 425
 426         VBox* punch_box = manage (new VBox);
 427         punch_box->pack_start (punch_in_button, false, false);
 428         punch_box->pack_start (punch_out_button, false, false);
 429         toggle_box->pack_start (*punch_box, false, false);
 430
 431         VBox* auto_box = manage (new VBox);
 432         auto_box->pack_start (auto_play_button, false, false);
 433         auto_box->pack_start (auto_return_button, false, false);
 434         toggle_box->pack_start (*auto_box, false, false);
 435
 436         VBox* io_box = manage (new VBox);
 437         io_box->pack_start (auto_input_button, false, false);
 438         io_box->pack_start (click_button, false, false);
 439         toggle_box->pack_start (*io_box, false, false);
 440
 441         /* desensitize */
 442
 443         set_transport_sensitivity (false);
 444
 445 //      toggle_box->pack_start (preroll_button, false, false);
 446 //      toggle_box->pack_start (preroll_clock, false, false);
 447
 448 //      toggle_box->pack_start (postroll_button, false, false);
 449 //      toggle_box->pack_start (postroll_clock, false, false);
 450
 451         transport_tearoff_hbox.pack_start (*toggle_box, false, false, 4);
 452         transport_tearoff_hbox.pack_start (alert_box, false, false);
 453
 454         VBox* panic_box = manage (new VBox);
 455         midi_panic_button.set_name("TransportMidiPanic");
 456         midi_panic_button.signal_pressed().connect (mem_fun(*this, &ARDOUR_UI::midi_panic_toggle));
 457         panic_box->pack_start (midi_panic_button, true, true);
 458         transport_tearoff_hbox.pack_start(*panic_box, true, true, 4);
 459
 460
 461         if (Profile->get_sae()) {
 462                 Image* img = manage (new Image ((::get_icon (X_("sae")))));
 463                 transport_tearoff_hbox.pack_end (*img, false, false, 6);
 464         }
 465 }
 466
 467 void
 468 ARDOUR_UI::manage_window (Window& win)
 469 {
 470         win.signal_delete_event().connect (bind (sigc::ptr_fun (just_hide_it), &win));
 471         win.signal_enter_notify_event().connect (bind (mem_fun (Keyboard::the_keyboard(), &Keyboard::enter_window), &win));
 472         win.signal_leave_notify_event().connect (bind (mem_fun (Keyboard::the_keyboard(), &Keyboard::leave_window), &win));
 473 }
 474
 475 void
 476 ARDOUR_UI::detach_tearoff (Box* b, Widget* w)
 477 {
 478 //      editor->ensure_float (transport_tearoff->tearoff_window());
 479         b->remove (*w);
 480 }
 481
 482 void
 483 ARDOUR_UI::reattach_tearoff (Box* b, Widget* w, int32_t n)
 484 {
 485         b->pack_start (*w);
 486         b->reorder_child (*w, n);
 487 }
 488
 489 void
 490 ARDOUR_UI::soloing_changed (bool onoff)
 491 {
 492         if (solo_alert_button.get_active() != onoff) {
 493                 solo_alert_button.set_active (onoff);
 494         }
 495 }
 496
 497 void
 498 ARDOUR_UI::_auditioning_changed (bool onoff)
 499 {
 500         if (auditioning_alert_button.get_active() != onoff) {
 501                 auditioning_alert_button.set_active (onoff);
 502                 set_transport_sensitivity (!onoff);
 503         }
 504 }
 505
 506 void
 507 ARDOUR_UI::auditioning_changed (bool onoff)
 508 {
 509         UI::instance()->call_slot(bind (mem_fun(*this, &ARDOUR_UI::_auditioning_changed), onoff));
 510 }
 511
 512 void
 513 ARDOUR_UI::audition_alert_toggle ()
 514 {
 515         if (session) {
 516                 session->cancel_audition();
 517         }
 518 }
 519
 520 void
 521 ARDOUR_UI::solo_alert_toggle ()
 522 {
 523         if (session) {
 524                 session->set_all_solo (!session->soloing());
 525         }
 526 }
 527
 528 void
 529 ARDOUR_UI::midi_panic_toggle ()
 530 {
 531         if (session) {
 532                 session->midi_panic();
 533                 midi_panic_button.set_active (false);
 534                 midi_panic_button.set_state (STATE_NORMAL);
 535         }
 536 }
 537
 538 void
 539 ARDOUR_UI::solo_blink (bool onoff)
 540 {
 541         if (session == 0) {
 542                 return;
 543         }
 544
 545         if (session->soloing()) {
 546                 if (onoff) {
 547                         solo_alert_button.set_state (STATE_ACTIVE);
 548                 } else {
 549                         solo_alert_button.set_state (STATE_NORMAL);
 550                 }
 551         } else {
 552                 solo_alert_button.set_active (false);
 553                 solo_alert_button.set_state (STATE_NORMAL);
 554         }
 555 }
 556
 557 void
 558 ARDOUR_UI::audition_blink (bool onoff)
 559 {
 560         if (session == 0) {
 561                 return;
 562         }
 563
 564         if (session->is_auditioning()) {
 565                 if (onoff) {
 566                         auditioning_alert_button.set_state (STATE_ACTIVE);
 567                 } else {
 568                         auditioning_alert_button.set_state (STATE_NORMAL);
 569                 }
 570         } else {
 571                 auditioning_alert_button.set_active (false);
 572                 auditioning_alert_button.set_state (STATE_NORMAL);
 573         }
 574 }
 575
 576 void
 577 ARDOUR_UI::build_shuttle_context_menu ()
 578 {
 579         using namespace Menu_Helpers;
 580
 581         shuttle_context_menu = new Menu();
 582         MenuList& items = shuttle_context_menu->items();
 583
 584         Menu* speed_menu = manage (new Menu());
 585         MenuList& speed_items = speed_menu->items();
 586
 587         RadioMenuItem::Group group;
 588
 589         speed_items.push_back (RadioMenuElem (group, "8", bind (mem_fun (*this, &ARDOUR_UI::set_shuttle_max_speed), 8.0f)));
 590         if (shuttle_max_speed == 8.0) {
 591                 static_cast<RadioMenuItem*>(&speed_items.back())->set_active ();
 592         }
 593         speed_items.push_back (RadioMenuElem (group, "6", bind (mem_fun (*this, &ARDOUR_UI::set_shuttle_max_speed), 6.0f)));
 594         if (shuttle_max_speed == 6.0) {
 595                 static_cast<RadioMenuItem*>(&speed_items.back())->set_active ();
 596         }
 597         speed_items.push_back (RadioMenuElem (group, "4", bind (mem_fun (*this, &ARDOUR_UI::set_shuttle_max_speed), 4.0f)));
 598         if (shuttle_max_speed == 4.0) {
 599                 static_cast<RadioMenuItem*>(&speed_items.back())->set_active ();
 600         }
 601         speed_items.push_back (RadioMenuElem (group, "3", bind (mem_fun (*this, &ARDOUR_UI::set_shuttle_max_speed), 3.0f)));
 602         if (shuttle_max_speed == 3.0) {
 603                 static_cast<RadioMenuItem*>(&speed_items.back())->set_active ();
 604         }
 605         speed_items.push_back (RadioMenuElem (group, "2", bind (mem_fun (*this, &ARDOUR_UI::set_shuttle_max_speed), 2.0f)));
 606         if (shuttle_max_speed == 2.0) {
 607                 static_cast<RadioMenuItem*>(&speed_items.back())->set_active ();
 608         }
 609         speed_items.push_back (RadioMenuElem (group, "1.5", bind (mem_fun (*this, &ARDOUR_UI::set_shuttle_max_speed), 1.5f)));
 610         if (shuttle_max_speed == 1.5) {
 611                 static_cast<RadioMenuItem*>(&speed_items.back())->set_active ();
 612         }
 613
 614         items.push_back (MenuElem (_("Maximum speed"), *speed_menu));
 615 }
 616
 617 void
 618 ARDOUR_UI::show_shuttle_context_menu ()
 619 {
 620         if (shuttle_context_menu == 0) {
 621                 build_shuttle_context_menu ();
 622         }
 623
 624         shuttle_context_menu->popup (1, gtk_get_current_event_time());
 625 }
 626
 627 void
 628 ARDOUR_UI::set_shuttle_max_speed (float speed)
 629 {
 630         shuttle_max_speed = speed;
 631 }
 632
 633 gint
 634 ARDOUR_UI::shuttle_box_button_press (GdkEventButton* ev)
 635 {
 636         if (!session) {
 637                 return true;
 638         }
 639
 640         if (shuttle_controller_binding_proxy.button_press_handler (ev)) {
 641                 return true;
 642         }
 643
 644         if (Keyboard::is_context_menu_event (ev)) {
 645                 show_shuttle_context_menu ();
 646                 return true;
 647         }
 648
 649         switch (ev->button) {
 650         case 1:
 651                 shuttle_box.add_modal_grab ();
 652                 shuttle_grabbed = true;
 653                 mouse_shuttle (ev->x, true);
 654                 break;
 655
 656         case 2:
 657         case 3:
 658                 return true;
 659                 break;
 660         }
 661
 662         return true;
 663 }
 664
 665 gint
 666 ARDOUR_UI::shuttle_box_button_release (GdkEventButton* ev)
 667 {
 668         if (!session) {
 669                 return true;
 670         }
 671
 672         switch (ev->button) {
 673         case 1:
 674                 mouse_shuttle (ev->x, true);
 675                 shuttle_grabbed = false;
 676                 shuttle_box.remove_modal_grab ();
 677                 if (Config->get_shuttle_behaviour() == Sprung) {
 678                         if (Config->get_auto_play() || roll_button.get_visual_state()) {
 679                                 shuttle_fract = SHUTTLE_FRACT_SPEED1;
 680                                 session->request_transport_speed (1.0);
 681                                 stop_button.set_visual_state (0);
 682                                 roll_button.set_visual_state (1);
 683                         } else {
 684                                 shuttle_fract = 0;
 685                                 session->request_transport_speed (0.0);
 686                         }
 687                         shuttle_box.queue_draw ();
 688                 }
 689                 return true;
 690
 691         case 2:
 692                 if (session->transport_rolling()) {
 693                         shuttle_fract = SHUTTLE_FRACT_SPEED1;
 694                         session->request_transport_speed (1.0);
 695                         stop_button.set_visual_state (0);
 696                         roll_button.set_visual_state (1);
 697                 } else {
 698                         shuttle_fract = 0;
 699                 }
 700                 shuttle_box.queue_draw ();
 701                 return true;
 702
 703         case 3:
 704         default:
 705                 return true;
 706
 707         }
 708
 709         use_shuttle_fract (true);
 710
 711         return true;
 712 }
 713
 714 gint
 715 ARDOUR_UI::shuttle_box_scroll (GdkEventScroll* ev)
 716 {
 717         if (!session) {
 718                 return true;
 719         }
 720
 721         switch (ev->direction) {
 722
 723         case GDK_SCROLL_UP:
 724                 shuttle_fract += 0.005;
 725                 break;
 726         case GDK_SCROLL_DOWN:
 727                 shuttle_fract -= 0.005;
 728                 break;
 729         default:
 730                 /* scroll left/right */
 731                 return false;
 732         }
 733
 734         use_shuttle_fract (true);
 735
 736         return true;
 737 }
 738
 739 gint
 740 ARDOUR_UI::shuttle_box_motion (GdkEventMotion* ev)
 741 {
 742         if (!session || !shuttle_grabbed) {
 743                 return true;
 744         }
 745
 746         return mouse_shuttle (ev->x, false);
 747 }
 748
 749 gint
 750 ARDOUR_UI::mouse_shuttle (double x, bool force)
 751 {
 752         double half_width = shuttle_box.get_width() / 2.0;
 753         double distance = x - half_width;
 754
 755         if (distance > 0) {
 756                 distance = min (distance, half_width);
 757         } else {
 758                 distance = max (distance, -half_width);
 759         }
 760
 761         shuttle_fract = distance / half_width;
 762         use_shuttle_fract (force);
 763         return true;
 764 }
 765
 766 void
 767 ARDOUR_UI::set_shuttle_fract (double f)
 768 {
 769         shuttle_fract = f;
 770         use_shuttle_fract (false);
 771 }
 772
 773 void
 774 ARDOUR_UI::use_shuttle_fract (bool force)
 775 {
 776         microseconds_t now = get_microseconds();
 777
 778         /* do not attempt to submit a motion-driven transport speed request
 779            more than once per process cycle.
 780          */
 781
 782         if (!force && (last_shuttle_request - now) < (microseconds_t) engine->usecs_per_cycle()) {
 783                 return;
 784         }
 785
 786         last_shuttle_request = now;
 787
 788         bool neg = (shuttle_fract < 0.0);
 789
 790         double fract = 1 - sqrt (1 - (shuttle_fract * shuttle_fract)); // Formula A1
 791
 792         if (neg) {
 793                 fract = -fract;
 794         }
 795
 796         session->request_transport_speed (shuttle_max_speed * fract); // Formula A2
 797         shuttle_box.queue_draw ();
 798 }
 799
 800 gint
 801 ARDOUR_UI::shuttle_box_expose (GdkEventExpose* event)
 802 {
 803         gint x;
 804         Glib::RefPtr<Gdk::Window> win (shuttle_box.get_window());
 805
 806         /* redraw the background */
 807
 808         win->draw_rectangle (shuttle_box.get_style()->get_bg_gc (shuttle_box.get_state()),
 809                              true,
 810                              event->area.x, event->area.y,
 811                              event->area.width, event->area.height);
 812
 813
 814         x = (gint) floor ((shuttle_box.get_width() / 2.0) + (0.5 * (shuttle_box.get_width() * shuttle_fract)));
 815
 816         /* draw line */
 817
 818         win->draw_line (shuttle_box.get_style()->get_fg_gc (shuttle_box.get_state()),
 819                         x,
 820                         0,
 821                         x,
 822                         shuttle_box.get_height());
 823         return true;
 824 }
 825
 826 void
 827 ARDOUR_UI::shuttle_unit_clicked ()
 828 {
 829         if (shuttle_unit_menu == 0) {
 830                 shuttle_unit_menu = dynamic_cast<Menu*> (ActionManager::get_widget ("/ShuttleUnitPopup"));
 831         }
 832         shuttle_unit_menu->popup (1, gtk_get_current_event_time());
 833 }
 834
 835 void
 836 ARDOUR_UI::shuttle_style_changed ()
 837 {
 838         ustring str = shuttle_style_button.get_active_text ();
 839
 840         if (str == _("sprung")) {
 841                 Config->set_shuttle_behaviour (Sprung);
 842         } else if (str == _("wheel")) {
 843                 Config->set_shuttle_behaviour (Wheel);
 844         }
 845 }
 846
 847 void
 848 ARDOUR_UI::update_speed_display ()
 849 {
 850         if (!session) {
 851                 if (last_speed_displayed != 0) {
 852                         speed_display_label.set_text (_("stop"));
 853                         last_speed_displayed = 0;
 854                 }
 855                 return;
 856         }
 857
 858         char buf[32];
 859         float x = session->transport_speed ();
 860
 861         if (x != last_speed_displayed) {
 862
 863                 if (x != 0) {
 864                         if (Config->get_shuttle_units() == Percentage) {
 865                                 snprintf (buf, sizeof (buf), "%.2f", x);
 866                         } else {
 867                                 if (x < 0) {
 868                                         snprintf (buf, sizeof (buf), "< %.1f", 12.0 * fast_log2 (-x));
 869                                 } else {
 870                                         snprintf (buf, sizeof (buf), "> %.1f", 12.0 * fast_log2 (x));
 871                                 }
 872                         }
 873                         speed_display_label.set_text (buf);
 874                 } else {
 875                         speed_display_label.set_text (_("stop"));
 876                 }
 877
 878                 last_speed_displayed = x;
 879         }
 880 }
 881
 882 void
 883 ARDOUR_UI::set_transport_sensitivity (bool yn)
 884 {
 885         ActionManager::set_sensitive (ActionManager::transport_sensitive_actions, yn);
 886         shuttle_box.set_sensitive (yn);
 887 }
 888
 889 void
 890 ARDOUR_UI::editor_realized ()
 891 {
 892         Config->map_parameters (mem_fun (*this, &ARDOUR_UI::parameter_changed));
 893
 894         set_size_request_to_display_given_text (speed_display_box, _("-0.55"), 2, 2);
 895         const guint32 FUDGE = 25; // Combo's are stupid - they steal space from the entry for the button
 896         set_size_request_to_display_given_text (shuttle_style_button, _("sprung"), 2+FUDGE, 10);
 897         reset_dpi();
 898 }
 899
 900 void
 901 ARDOUR_UI::sync_option_changed ()
 902 {
 903         if (session) {
 904                 ustring txt = sync_option_combo.get_active_text ();
 905                 if (txt.length()) {
 906                         session->request_slave_source (string_to_slave_source (txt));
 907                 }
 908         }
 909 }
 910
 911 void
 912 ARDOUR_UI::maximise_editing_space ()
 913 {
 914         if (!editor) {
 915                 return;
 916         }
 917
 918         transport_tearoff->set_visible (false);
 919         editor->maximise_editing_space ();
 920 }
 921
 922 void
 923 ARDOUR_UI::restore_editing_space ()
 924 {
 925         if (!editor) {
 926                 return;
 927         }
 928
 929         transport_tearoff->set_visible (true);
 930         editor->restore_editing_space ();
 931 }