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