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