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