gtk2_ardour/ardour_ui2.cc

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