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