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