Make the export ranges view expand with the export dialogue.
[ardour.git] / gtk2_ardour / audio_clock.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 <cstdio> // for sprintf
21 #include <cmath>
22
23 #include "pbd/convert.h"
24 #include "pbd/enumwriter.h"
25
26 #include <gtkmm/style.h>
27
28 #include "gtkmm2ext/cairocell.h"
29 #include "gtkmm2ext/utils.h"
30 #include "gtkmm2ext/rgb_macros.h"
31
32 #include "ardour/ardour.h"
33 #include "ardour/session.h"
34 #include "ardour/tempo.h"
35 #include "ardour/profile.h"
36 #include "ardour/slave.h"
37 #include <sigc++/bind.h>
38
39 #include "ardour_ui.h"
40 #include "audio_clock.h"
41 #include "global_signals.h"
42 #include "utils.h"
43 #include "keyboard.h"
44 #include "gui_thread.h"
45 #include "i18n.h"
46
47 using namespace ARDOUR;
48 using namespace PBD;
49 using namespace Gtk;
50 using namespace std;
51
52 using Gtkmm2ext::Keyboard;
53
54 sigc::signal<void> AudioClock::ModeChanged;
55 vector<AudioClock*> AudioClock::clocks;
56 const double AudioClock::info_font_scale_factor = 0.6;
57 const double AudioClock::separator_height = 2.0;
58 const double AudioClock::x_leading_padding = 6.0;
59
60 #define BBT_BAR_CHAR "|"
61 #define BBT_SCANF_FORMAT "%" PRIu32 "%*c%" PRIu32 "%*c%" PRIu32
62
63 AudioClock::AudioClock (const string& clock_name, bool transient, const string& widget_name,
64                         bool allow_edit, bool follows_playhead, bool duration, bool with_info)
65         : _name (clock_name)
66         , is_transient (transient)
67         , is_duration (duration)
68         , editable (allow_edit)
69         , _follows_playhead (follows_playhead)
70         , _off (false)
71         , _fixed_width (true)
72         , layout_x_offset (0)
73         , em_width (0)
74         , _edit_by_click_field (false)
75         , ops_menu (0)
76         , editing_attr (0)
77         , foreground_attr (0)
78         , first_height (0)
79         , first_width (0)
80         , layout_height (0)
81         , layout_width (0)
82         , info_height (0)
83         , upper_height (0)
84         , mode_based_info_ratio (1.0)
85         , corner_radius (9)
86         , editing (false)
87         , bbt_reference_time (-1)
88         , last_when(0)
89         , last_pdelta (0)
90         , last_sdelta (0)
91         , dragging (false)
92         , drag_field (Field (0))
93
94 {
95         set_flags (CAN_FOCUS);
96
97         _layout = Pango::Layout::create (get_pango_context());
98         _layout->set_attributes (normal_attributes);
99
100         if (with_info) {
101                 _left_layout = Pango::Layout::create (get_pango_context());
102                 _right_layout = Pango::Layout::create (get_pango_context());
103         }
104
105         set_widget_name (widget_name);
106
107         _mode = BBT; /* lie to force mode switch */
108         set_mode (Timecode);
109         set (last_when, true);
110
111         if (!is_transient) {
112                 clocks.push_back (this);
113         }
114
115         ColorsChanged.connect (sigc::mem_fun (*this, &AudioClock::set_colors));
116         DPIReset.connect (sigc::mem_fun (*this, &AudioClock::dpi_reset));
117 }
118
119 AudioClock::~AudioClock ()
120 {
121         delete foreground_attr;
122         delete editing_attr;
123 }
124
125 void
126 AudioClock::set_widget_name (const string& str)
127 {
128         if (str.empty()) {
129                 set_name ("clock");
130         } else {
131                 set_name (str + " clock");
132         }
133
134         if (is_realized()) {
135                 set_colors ();
136         }
137 }
138
139
140 void
141 AudioClock::on_realize ()
142 {
143         CairoWidget::on_realize ();
144         set_font ();
145         set_colors ();
146 }
147
148 void
149 AudioClock::set_font ()
150 {
151         Glib::RefPtr<Gtk::Style> style = get_style ();
152         Pango::FontDescription font; 
153         Pango::AttrFontDesc* font_attr;
154
155         if (!is_realized()) {
156                 font = get_font_for_style (get_name());
157         } else {
158                 font = style->get_font();
159         }
160
161         font_attr = new Pango::AttrFontDesc (Pango::Attribute::create_attr_font_desc (font));
162
163         normal_attributes.change (*font_attr);
164         editing_attributes.change (*font_attr);
165
166         /* now a smaller version of the same font */
167
168         delete font_attr;
169         font.set_size ((int) lrint (font.get_size() * info_font_scale_factor));
170         font.set_weight (Pango::WEIGHT_NORMAL);
171         font_attr = new Pango::AttrFontDesc (Pango::Attribute::create_attr_font_desc (font));
172  
173         info_attributes.change (*font_attr);
174         
175         delete font_attr;
176
177         /* get the figure width for the font. This doesn't have to super
178          * accurate since we only use it to measure the (roughly 1 character)
179          * offset from the position Pango tells us for the "cursor"
180          */
181
182         Glib::RefPtr<Pango::Layout> tmp = Pango::Layout::create (get_pango_context());
183         int ignore_height;
184
185         tmp->set_text ("8");
186         tmp->get_pixel_size (em_width, ignore_height);
187 }
188
189 void
190 AudioClock::set_active_state (Gtkmm2ext::ActiveState s)
191 {
192         CairoWidget::set_active_state (s);
193         set_colors ();
194 }
195
196 void
197 AudioClock::set_colors ()
198 {
199         int r, g, b, a;
200
201         uint32_t bg_color;
202         uint32_t text_color;
203         uint32_t editing_color;
204         uint32_t cursor_color;
205
206         if (active_state()) {
207                 bg_color = ARDOUR_UI::config()->color_by_name (string_compose ("%1 active: background", get_name()));
208                 text_color = ARDOUR_UI::config()->color_by_name (string_compose ("%1 active: text", get_name()));
209                 editing_color = ARDOUR_UI::config()->color_by_name (string_compose ("%1 active: edited text", get_name()));
210                 cursor_color = ARDOUR_UI::config()->color_by_name (string_compose ("%1 active: cursor", get_name()));
211         } else {
212                 bg_color = ARDOUR_UI::config()->color_by_name (string_compose ("%1: background", get_name()));
213                 text_color = ARDOUR_UI::config()->color_by_name (string_compose ("%1: text", get_name()));
214                 editing_color = ARDOUR_UI::config()->color_by_name (string_compose ("%1: edited text", get_name()));
215                 cursor_color = ARDOUR_UI::config()->color_by_name (string_compose ("%1: cursor", get_name()));
216         }
217
218         /* store for bg and cursor in render() */
219
220         UINT_TO_RGBA (bg_color, &r, &g, &b, &a);
221
222         bg_r = r/255.0;
223         bg_g = g/255.0;
224         bg_b = b/255.0;
225         bg_a = a/255.0;
226
227         UINT_TO_RGBA (cursor_color, &r, &g, &b, &a);
228
229         cursor_r = r/255.0;
230         cursor_g = g/255.0;
231         cursor_b = b/255.0;
232         cursor_a = a/255.0;
233
234         /* rescale for Pango colors ... sigh */
235
236         r = lrint (r * 65535.0);
237         g = lrint (g * 65535.0);
238         b = lrint (b * 65535.0);
239
240         UINT_TO_RGBA (text_color, &r, &g, &b, &a);
241         r = lrint ((r/255.0) * 65535.0);
242         g = lrint ((g/255.0) * 65535.0);
243         b = lrint ((b/255.0) * 65535.0);
244         foreground_attr = new Pango::AttrColor (Pango::Attribute::create_attr_foreground (r, g, b));
245
246         UINT_TO_RGBA (editing_color, &r, &g, &b, &a);
247         r = lrint ((r/255.0) * 65535.0);
248         g = lrint ((g/255.0) * 65535.0);
249         b = lrint ((b/255.0) * 65535.0);
250         editing_attr = new Pango::AttrColor (Pango::Attribute::create_attr_foreground (r, g, b));
251         
252         normal_attributes.change (*foreground_attr);
253         info_attributes.change (*foreground_attr);
254         editing_attributes.change (*foreground_attr);
255         editing_attributes.change (*editing_attr);
256
257         if (!editing) {
258                 _layout->set_attributes (normal_attributes);
259         } else {
260                 _layout->set_attributes (editing_attributes);
261         }
262
263         if (_left_layout) {
264                 _left_layout->set_attributes (info_attributes);
265                 _right_layout->set_attributes (info_attributes);
266         }
267
268         queue_draw ();
269 }
270
271 void
272 AudioClock::render (cairo_t* cr)
273 {
274         /* main layout: rounded rect, plus the text */
275         
276         if (_need_bg) {
277                 cairo_set_source_rgba (cr, bg_r, bg_g, bg_b, bg_a);
278                 if (corner_radius) {
279                         Gtkmm2ext::rounded_rectangle (cr, 0, 0, get_width(), upper_height, corner_radius);
280                 } else {
281                         cairo_rectangle (cr, 0, 0, get_width(), upper_height);
282                 }
283                 cairo_fill (cr);
284         }
285
286         if (!_fixed_width) {
287                 cairo_move_to (cr, layout_x_offset, 0);
288         } else {
289                 cairo_move_to (cr, layout_x_offset, (upper_height - layout_height) / 2.0);
290         }
291
292         pango_cairo_show_layout (cr, _layout->gobj());
293
294         if (_left_layout) {
295
296                 double h = get_height() - upper_height - separator_height;
297
298                 if (_need_bg) {
299                         cairo_set_source_rgba (cr, bg_r, bg_g, bg_b, bg_a);
300                 }
301
302                 if (mode_based_info_ratio != 1.0) {
303
304                         double left_rect_width = round (((get_width() - separator_height) * mode_based_info_ratio) + 0.5);
305
306                         if (_need_bg) {
307                                 if (corner_radius) {
308                                         Gtkmm2ext::rounded_rectangle (cr, 0, upper_height + separator_height, left_rect_width, h, corner_radius);
309                                 } else {
310                                         cairo_rectangle (cr, 0, upper_height + separator_height, left_rect_width, h);
311                                 }
312                                 cairo_fill (cr);
313                         }
314
315                         cairo_move_to (cr, x_leading_padding, upper_height + separator_height + ((h - info_height)/2.0));
316                         pango_cairo_show_layout (cr, _left_layout->gobj());
317                         
318                         if (_need_bg) {
319                                 if (corner_radius) {
320                                         Gtkmm2ext::rounded_rectangle (cr, left_rect_width + separator_height, upper_height + separator_height, 
321                                                                       get_width() - separator_height - left_rect_width, h, 
322                                                                       corner_radius);
323                                 } else {
324                                         cairo_rectangle (cr, left_rect_width + separator_height, upper_height + separator_height, 
325                                                          get_width() - separator_height - left_rect_width, h);
326                                 }
327                                 cairo_fill (cr);        
328                         }
329
330                         cairo_move_to (cr, x_leading_padding + left_rect_width + separator_height, upper_height + separator_height + ((h - info_height)/2.0));
331                         pango_cairo_show_layout (cr, _right_layout->gobj());
332
333                 } else {
334                         /* no info to display, or just one */
335
336                         if (_need_bg) {
337                                 if (corner_radius) {
338                                         Gtkmm2ext::rounded_rectangle (cr, 0, upper_height + separator_height, get_width(), h, corner_radius);
339                                 } else {
340                                         cairo_rectangle (cr, 0, upper_height + separator_height, get_width(), h);
341                                 }
342                                 cairo_fill (cr);
343                         }
344                 }
345         }
346
347         if (editing) {
348                 if (!insert_map.empty()) {
349
350
351                         if (input_string.length() < insert_map.size()) {
352                                 Pango::Rectangle cursor;
353                                 
354                                 if (input_string.empty()) {
355                                         /* nothing entered yet, put cursor at the end
356                                            of string
357                                         */
358                                         cursor = _layout->get_cursor_strong_pos (edit_string.length() - 1);
359                                 } else {
360                                         cursor = _layout->get_cursor_strong_pos (insert_map[input_string.length()]);
361                                 }
362                                 
363                                 cairo_set_source_rgba (cr, cursor_r, cursor_g, cursor_b, cursor_a);
364                                 if (!_fixed_width) {
365                                         cairo_rectangle (cr, 
366                                                          min (get_width() - 2.0, 
367                                                               (double) cursor.get_x()/PANGO_SCALE + layout_x_offset + em_width), 0,
368                                                          2.0, cursor.get_height()/PANGO_SCALE);
369                                 } else {
370                                         cairo_rectangle (cr, 
371                                                          min (get_width() - 2.0, 
372                                                               (double) layout_x_offset + cursor.get_x()/PANGO_SCALE + em_width),
373                                                          (upper_height - layout_height)/2.0, 
374                                                          2.0, cursor.get_height()/PANGO_SCALE);
375                                 }
376                                 cairo_fill (cr);        
377                         } else {
378                                 /* we've entered all possible digits, no cursor */
379                         }
380
381                 } else {
382                         if (input_string.empty()) {
383                                 cairo_set_source_rgba (cr, cursor_r, cursor_g, cursor_b, cursor_a);
384                                 if (!_fixed_width) {
385                                         cairo_rectangle (cr, 
386                                                          (get_width()/2.0),
387                                                          0,
388                                                          2.0, upper_height);
389                                 } else {
390                                         cairo_rectangle (cr, 
391                                                          (get_width()/2.0),
392                                                          (upper_height - layout_height)/2.0, 
393                                                          2.0, upper_height);
394                                 }
395                                 cairo_fill (cr);
396                         }
397                 }
398         }
399 }
400
401 void
402 AudioClock::on_size_allocate (Gtk::Allocation& alloc)
403 {
404         CairoWidget::on_size_allocate (alloc);
405         
406         if (_left_layout) {
407                 upper_height = (get_height()/2.0) - 1.0;
408         } else {
409                 upper_height = get_height();
410         }
411
412         if (_fixed_width) {
413                 /* center display in available space */
414                 layout_x_offset = (get_width() - layout_width)/2.0;
415         } else {
416                 /* left justify */
417                 layout_x_offset = 0;
418         }
419 }
420
421 void
422 AudioClock::on_size_request (Gtk::Requisition* req)
423 {
424         /* even for non fixed width clocks, the size we *ask* for never changes, 
425            even though the size we receive might. so once we've computed it,
426            just return it.
427         */
428         
429         if (first_width) {
430                 req->width = first_width;
431                 req->height = first_height;
432                 return;
433         }
434
435         Glib::RefPtr<Pango::Layout> tmp;
436         Glib::RefPtr<Gtk::Style> style = get_style ();
437         Pango::FontDescription font; 
438
439         tmp = Pango::Layout::create (get_pango_context());
440
441         if (!is_realized()) {
442                 font = get_font_for_style (get_name());
443         } else {
444                 font = style->get_font();
445         }
446
447         tmp->set_font_description (font);
448
449         if (_fixed_width) {
450                 /* this string is the longest thing we will ever display,
451                    and also includes the BBT bar char that may descends below
452                    the baseline a bit, and a comma for the minsecs mode
453                    where we printf a fractional value (XXX or should)
454                 */
455                 
456                 tmp->set_text (" 8888888888:,|"); 
457         } else {
458                 switch (_mode) {
459                 case Timecode:
460                         tmp->set_text (" 88:88:88:88");
461                         break;
462                 case BBT:
463                         tmp->set_text (" 888|88|8888");
464                         break;
465                 case MinSec:
466                         tmp->set_text (" 88:88:88,888");
467                         break;
468                 case Frames:
469                         tmp->set_text (" 8888888888");
470                         break;
471                 }
472         }
473
474         tmp->get_pixel_size (req->width, req->height);
475
476         layout_height = req->height;
477         layout_width = req->width;
478
479         /* now tackle height, for which we need to know the height of the lower
480          * layout
481          */
482
483         if (_left_layout) {
484
485                 int w;
486
487                 font.set_size ((int) lrint (font.get_size() * info_font_scale_factor));
488                 font.set_weight (Pango::WEIGHT_NORMAL);
489                 tmp->set_font_description (font);
490
491                 /* we only care about height, so put as much stuff in here
492                    as possible that might change the height.
493                 */
494                 tmp->set_text ("qyhH|"); /* one ascender, one descender */
495                 
496                 tmp->get_pixel_size (w, info_height);
497                 
498                 /* silly extra padding that seems necessary to correct the info
499                  * that pango just gave us. I have no idea why.
500                  */
501
502                 info_height += 4;
503
504                 req->height += info_height;
505                 req->height += separator_height;
506         }
507
508         first_height = req->height;
509         first_width = req->width;
510 }
511
512 void
513 AudioClock::show_edit_status (int length)
514 {
515         editing_attr->set_start_index (edit_string.length() - length);
516         editing_attr->set_end_index (edit_string.length());
517         
518         editing_attributes.change (*foreground_attr);
519         editing_attributes.change (*editing_attr);
520
521         _layout->set_attributes (editing_attributes);
522 }
523
524 void
525 AudioClock::start_edit (Field f)
526 {
527         pre_edit_string = _layout->get_text ();
528         if (!insert_map.empty()) {
529                 edit_string = pre_edit_string;
530         } else {
531                 edit_string.clear ();
532                 _layout->set_text ("");
533         }
534         input_string.clear ();
535         editing = true;
536
537         if (f) {
538                 input_string = get_field (f);
539                 show_edit_status (merge_input_and_edit_string ());
540                 _layout->set_text (edit_string);
541         }
542
543         queue_draw ();
544
545         Keyboard::magic_widget_grab_focus ();
546         grab_focus ();
547 }
548
549 string
550 AudioClock::get_field (Field f)
551 {
552         switch (f) {
553         case Timecode_Hours:
554                 return edit_string.substr (1, 2);
555                 break;
556         case Timecode_Minutes:
557                 return edit_string.substr (4, 2);
558                 break;
559         case Timecode_Seconds:
560                 return edit_string.substr (7, 2);
561                 break;
562         case Timecode_Frames:
563                 return edit_string.substr (10, 2);
564                 break;
565         case MS_Hours:
566                 return edit_string.substr (1, 2);
567                 break;
568         case MS_Minutes:
569                 return edit_string.substr (4, 2);
570                 break;
571         case MS_Seconds:
572                 return edit_string.substr (7, 2);
573                 break;
574         case MS_Milliseconds:
575                 return edit_string.substr (10, 3);
576                 break;
577         case Bars:
578                 return edit_string.substr (1, 3);
579                 break;
580         case Beats:
581                 return edit_string.substr (5, 2);
582                 break;
583         case Ticks:
584                 return edit_string.substr (8, 4);
585                 break;
586         case AudioFrames:
587                 return edit_string;
588                 break;
589         }
590         return "";
591 }
592
593 void
594 AudioClock::end_edit (bool modify)
595 {
596         if (modify) {
597
598                 bool ok = true;
599                 
600                 switch (_mode) {
601                 case Timecode:
602                         ok = timecode_validate_edit (edit_string);
603                         break;
604                         
605                 case BBT:
606                         ok = bbt_validate_edit (edit_string);
607                         break;
608                         
609                 case MinSec:
610                         ok = minsec_validate_edit (edit_string);
611                         break;
612                         
613                 case Frames:
614                         break;
615                 }
616                 
617                 if (!ok) {
618                         edit_string = pre_edit_string;
619                         input_string.clear ();
620                         _layout->set_text (edit_string);
621                         show_edit_status (0);
622                         /* edit attributes remain in use */
623                 } else {
624
625                         editing = false;
626                         framepos_t pos = 0; /* stupid gcc */
627
628                         switch (_mode) {
629                         case Timecode:
630                                 pos = frames_from_timecode_string (edit_string);
631                                 break;
632                                 
633                         case BBT:
634                                 if (is_duration) {
635                                         pos = frame_duration_from_bbt_string (0, edit_string);
636                                 } else {
637                                         pos = frames_from_bbt_string (0, edit_string);
638                                 }
639                                 break;
640                                 
641                         case MinSec:
642                                 pos = frames_from_minsec_string (edit_string);
643                                 break;
644                                 
645                         case Frames:
646                                 pos = frames_from_audioframes_string (edit_string);
647                                 break;
648                         }
649
650                         set (pos, true);
651                         _layout->set_attributes (normal_attributes);
652                         ValueChanged(); /* EMIT_SIGNAL */
653                 }
654
655         } else {
656
657                 editing = false;
658                 _layout->set_attributes (normal_attributes);
659                 _layout->set_text (pre_edit_string);
660         }
661
662         queue_draw ();
663
664         if (!editing) {
665                 drop_focus ();
666         }
667 }
668
669 void
670 AudioClock::drop_focus ()
671 {
672         Keyboard::magic_widget_drop_focus ();
673
674         if (has_focus()) {
675
676                 /* move focus back to the default widget in the top level window */
677                 
678                 Widget* top = get_toplevel();
679                 
680                 if (top->is_toplevel ()) {
681                         Window* win = dynamic_cast<Window*> (top);
682                         win->grab_focus ();
683                 }
684         }
685 }
686
687 framecnt_t 
688 AudioClock::parse_as_frames_distance (const std::string& str)
689 {
690         framecnt_t f;
691
692         if (sscanf (str.c_str(), "%" PRId64, &f) == 1) {
693                 return f;
694         }
695
696         return 0;
697 }
698
699 framecnt_t 
700 AudioClock::parse_as_minsec_distance (const std::string& str)
701 {
702         framecnt_t sr = _session->frame_rate();
703         int msecs;
704         int secs;
705         int mins;
706         int hrs;
707
708         switch (str.length()) {
709         case 0:
710                 return 0;
711         case 1:
712         case 2:
713         case 3:
714         case 4:
715                 sscanf (str.c_str(), "%" PRId32, &msecs);
716                 return msecs * (sr / 1000);
717                 
718         case 5:
719                 sscanf (str.c_str(), "%1" PRId32 "%" PRId32, &secs, &msecs);
720                 return (secs * sr) + (msecs * (sr/1000));
721
722         case 6:
723                 sscanf (str.c_str(), "%2" PRId32 "%" PRId32, &secs, &msecs);
724                 return (secs * sr) + (msecs * (sr/1000));
725
726         case 7:
727                 sscanf (str.c_str(), "%1" PRId32 "%2" PRId32 "%" PRId32, &mins, &secs, &msecs);
728                 return (mins * 60 * sr) + (secs * sr) + (msecs * (sr/1000));
729
730         case 8:
731                 sscanf (str.c_str(), "%2" PRId32 "%2" PRId32 "%" PRId32, &mins, &secs, &msecs);
732                 return (mins * 60 * sr) + (secs * sr) + (msecs * (sr/1000));
733
734         case 9:
735                 sscanf (str.c_str(), "%1" PRId32 "%2" PRId32 "%2" PRId32 "%" PRId32, &hrs, &mins, &secs, &msecs);
736                 return (hrs * 3600 * sr) + (mins * 60 * sr) + (secs * sr) + (msecs * (sr/1000));
737
738         case 10:
739                 sscanf (str.c_str(), "%1" PRId32 "%2" PRId32 "%2" PRId32 "%" PRId32, &hrs, &mins, &secs, &msecs);
740                 return (hrs * 3600 * sr) + (mins * 60 * sr) + (secs * sr) + (msecs * (sr/1000));
741         
742         default:
743                 break;
744         }
745
746         return 0;
747 }
748
749 framecnt_t 
750 AudioClock::parse_as_timecode_distance (const std::string& str)
751 {
752         double fps = _session->timecode_frames_per_second();
753         framecnt_t sr = _session->frame_rate();
754         int frames;
755         int secs;
756         int mins;
757         int hrs;
758         
759         switch (str.length()) {
760         case 0:
761                 return 0;
762         case 1:
763         case 2:
764                 sscanf (str.c_str(), "%" PRId32, &frames);
765                 return lrint ((frames/(float)fps) * sr);
766
767         case 3:
768                 sscanf (str.c_str(), "%1" PRId32 "%" PRId32, &secs, &frames);
769                 return (secs * sr) + lrint ((frames/(float)fps) * sr);
770
771         case 4:
772                 sscanf (str.c_str(), "%2" PRId32 "%" PRId32, &secs, &frames);
773                 return (secs * sr) + lrint ((frames/(float)fps) * sr);
774                 
775         case 5:
776                 sscanf (str.c_str(), "%1" PRId32 "%2" PRId32 "%" PRId32, &mins, &secs, &frames);
777                 return (mins * 60 * sr) + (secs * sr) + lrint ((frames/(float)fps) * sr);
778
779         case 6:
780                 sscanf (str.c_str(), "%2" PRId32 "%2" PRId32 "%" PRId32, &mins, &secs, &frames);
781                 return (mins * 60 * sr) + (secs * sr) + lrint ((frames/(float)fps) * sr);
782
783         case 7:
784                 sscanf (str.c_str(), "%1" PRId32 "%2" PRId32 "%2" PRId32 "%" PRId32, &hrs, &mins, &secs, &frames);
785                 return (hrs * 3600 * sr) + (mins * 60 * sr) + (secs * sr) + lrint ((frames/(float)fps) * sr);
786
787         case 8:
788                 sscanf (str.c_str(), "%2" PRId32 "%2" PRId32 "%2" PRId32 "%" PRId32, &hrs, &mins, &secs, &frames);
789                 return (hrs * 3600 * sr) + (mins * 60 * sr) + (secs * sr) + lrint ((frames/(float)fps) * sr);
790         
791         default:
792                 break;
793         }
794
795         return 0;
796 }
797
798 framecnt_t 
799 AudioClock::parse_as_bbt_distance (const std::string& str)
800 {
801         return 0;
802 }
803
804 framecnt_t 
805 AudioClock::parse_as_distance (const std::string& instr)
806 {
807         switch (_mode) {
808         case Timecode:
809                 return parse_as_timecode_distance (instr);
810                 break;
811         case Frames:
812                 return parse_as_frames_distance (instr);
813                 break;
814         case BBT:
815                 return parse_as_bbt_distance (instr);
816                 break;
817         case MinSec:
818                 return parse_as_minsec_distance (instr);
819                 break;
820         }
821         return 0;
822 }
823
824 void
825 AudioClock::end_edit_relative (bool add)
826 {
827         bool ok = true;
828         
829         switch (_mode) {
830         case Timecode:
831                 ok = timecode_validate_edit (edit_string);
832                 break;
833                 
834         case BBT:
835                 ok = bbt_validate_edit (edit_string);
836                 break;
837                 
838         case MinSec:
839                 ok = minsec_validate_edit (edit_string);
840                 break;
841                 
842         case Frames:
843                 break;
844         }
845                 
846         if (!ok) {
847                 edit_string = pre_edit_string;
848                 input_string.clear ();
849                 _layout->set_text (edit_string);
850                 show_edit_status (0);
851                 /* edit attributes remain in use */
852                 queue_draw ();
853                 return;
854         }
855
856         framecnt_t frames = parse_as_distance (input_string);
857
858         editing = false;
859
860         editing = false;
861         _layout->set_attributes (normal_attributes);
862
863         if (frames != 0) {
864                 if (add) {
865                         set (current_time() + frames, true);
866                 } else {
867                         framepos_t c = current_time();
868
869                         if (c > frames) {
870                                 set (c - frames, true);
871                         } else {
872                                 set (0, true);
873                         }
874                 }
875                 ValueChanged (); /* EMIT SIGNAL */
876         }
877
878         input_string.clear ();
879         queue_draw ();
880         drop_focus ();
881 }
882
883 void
884 AudioClock::session_configuration_changed (std::string p)
885 {
886         if (p == "sync-source" || p == "external-sync") {
887                 set (current_time(), true);
888                 return;
889         }
890
891         if (p != "timecode-offset" && p != "timecode-offset-negative") {
892                 return;
893         }
894
895         framecnt_t current;
896
897         switch (_mode) {
898         case Timecode:
899                 if (is_duration) {
900                         current = current_duration ();
901                 } else {
902                         current = current_time ();
903                 }
904                 set (current, true);
905                 break;
906         default:
907                 break;
908         }
909 }
910
911 void
912 AudioClock::set (framepos_t when, bool force, framecnt_t offset)
913 {
914         if ((!force && !is_visible()) || _session == 0) {
915                 return;
916         }
917
918         if (is_duration) {
919                 when = when - offset;
920         } 
921
922         if (when == last_when && !force) {
923                 return;
924         }
925
926         if (!editing) {
927
928                 switch (_mode) {
929                 case Timecode:
930                         set_timecode (when, force);
931                         break;
932                         
933                 case BBT:
934                         set_bbt (when, force);
935                         break;
936                         
937                 case MinSec:
938                         set_minsec (when, force);
939                         break;
940                         
941                 case Frames:
942                         set_frames (when, force);
943                         break;
944                 }
945         }
946
947         queue_draw ();
948         last_when = when;
949 }
950
951 void
952 AudioClock::set_frames (framepos_t when, bool /*force*/)
953 {
954         char buf[32];
955         bool negative = false;
956
957         if (_off) {
958                 _layout->set_text ("\u2012\u2012\u2012\u2012\u2012\u2012\u2012\u2012\u2012\u2012");
959
960                 if (_left_layout) {
961                         _left_layout->set_text ("");
962                         _right_layout->set_text ("");
963                 }
964                 
965                 return;
966         }
967         
968         if (when < 0) {
969                 when = -when;
970                 negative = true;
971         }
972
973         if (negative) {
974                 snprintf (buf, sizeof (buf), "-%10" PRId64, when);
975         } else {
976                 snprintf (buf, sizeof (buf), " %10" PRId64, when);
977         }
978
979         _layout->set_text (buf);
980
981         if (_left_layout) {
982                 framecnt_t rate = _session->frame_rate();
983
984                 if (fmod (rate, 100.0) == 0.0) {
985                         sprintf (buf, "SR %.1fkHz", rate/1000.0);
986                 } else {
987                         sprintf (buf, "SR %" PRId64, rate);
988                 }
989
990                 _left_layout->set_text (buf);
991
992                 float vid_pullup = _session->config.get_video_pullup();
993
994                 if (vid_pullup == 0.0) {
995                         _right_layout->set_text (_("pullup: \u2012"));
996                 } else {
997                         sprintf (buf, _("pullup %-6.4f"), vid_pullup);
998                         _right_layout->set_text (buf);
999                 }
1000         }
1001 }
1002
1003 void
1004 AudioClock::set_minsec (framepos_t when, bool force)
1005 {
1006         char buf[32];
1007         framecnt_t left;
1008         int hrs;
1009         int mins;
1010         int secs;
1011         int millisecs;
1012         bool negative = false;
1013
1014         if (_off) {
1015                 _layout->set_text ("\u2012\u2012:\u2012\u2012:\u2012\u2012.\u2012\u2012\u2012");
1016
1017                 if (_left_layout) {
1018                         _left_layout->set_text ("");
1019                         _right_layout->set_text ("");
1020                 }
1021                 
1022                 return;
1023         }       
1024
1025         if (when < 0) {
1026                 when = -when;
1027                 negative = true;
1028         }
1029
1030         left = when;
1031         hrs = (int) floor (left / (_session->frame_rate() * 60.0f * 60.0f));
1032         left -= (framecnt_t) floor (hrs * _session->frame_rate() * 60.0f * 60.0f);
1033         mins = (int) floor (left / (_session->frame_rate() * 60.0f));
1034         left -= (framecnt_t) floor (mins * _session->frame_rate() * 60.0f);
1035         secs = (int) floor (left / (float) _session->frame_rate());
1036         left -= (framecnt_t) floor (secs * _session->frame_rate());
1037         millisecs = floor (left * 1000.0 / (float) _session->frame_rate());
1038         
1039         if (negative) {
1040                 snprintf (buf, sizeof (buf), "-%02" PRId32 ":%02" PRId32 ":%02" PRId32 ".%03" PRId32, hrs, mins, secs, millisecs);
1041         } else {
1042                 snprintf (buf, sizeof (buf), " %02" PRId32 ":%02" PRId32 ":%02" PRId32 ".%03" PRId32, hrs, mins, secs, millisecs);
1043         }
1044
1045         _layout->set_text (buf);
1046 }
1047
1048 void
1049 AudioClock::set_timecode (framepos_t when, bool force)
1050 {
1051         char buf[32];
1052         Timecode::Time TC;
1053         bool negative = false;
1054
1055         if (_off) {
1056                 _layout->set_text ("\u2012\u2012:\u2012\u2012:\u2012\u2012:\u2012\u2012");
1057                 if (_left_layout) {
1058                         _left_layout->set_text ("");
1059                         _right_layout->set_text ("");
1060                 }
1061                 
1062                 return;
1063         }
1064
1065         if (when < 0) {
1066                 when = -when;
1067                 negative = true;
1068         }
1069
1070         if (is_duration) {
1071                 _session->timecode_duration (when, TC);
1072         } else {
1073                 _session->timecode_time (when, TC);
1074         }
1075         
1076         if (TC.negative || negative) {
1077                 snprintf (buf, sizeof (buf), "-%02" PRIu32 ":%02" PRIu32 ":%02" PRIu32 ":%02" PRIu32, TC.hours, TC.minutes, TC.seconds, TC.frames);
1078         } else {
1079                 snprintf (buf, sizeof (buf), " %02" PRIu32 ":%02" PRIu32 ":%02" PRIu32 ":%02" PRIu32, TC.hours, TC.minutes, TC.seconds, TC.frames);
1080         }
1081
1082         _layout->set_text (buf);
1083
1084         if (_left_layout) {
1085
1086                 if (_session->config.get_external_sync()) {
1087                         switch (_session->config.get_sync_source()) {
1088                         case JACK:
1089                                 _left_layout->set_text ("JACK");
1090                                 break;
1091                         case MTC:
1092                                 _left_layout->set_text ("MTC");
1093                                 break;
1094                         case MIDIClock:
1095                                 _left_layout->set_text ("M-Clock");
1096                                 break;
1097                         }
1098                 } else {
1099                         _left_layout->set_text ("INT");
1100                 }
1101
1102                 double timecode_frames = _session->timecode_frames_per_second();
1103         
1104                 if (fmod(timecode_frames, 1.0) == 0.0) {
1105                         sprintf (buf, "FPS %u %s", int (timecode_frames), (_session->timecode_drop_frames() ? "D" : ""));
1106                 } else {
1107                         sprintf (buf, "%.2f %s", timecode_frames, (_session->timecode_drop_frames() ? "D" : ""));
1108                 }
1109
1110                 _right_layout->set_text (buf);
1111         }
1112 }
1113
1114 void
1115 AudioClock::set_bbt (framepos_t when, bool force)
1116 {
1117         char buf[16];
1118         Timecode::BBT_Time BBT;
1119         bool negative = false;
1120
1121         if (_off) {
1122                 _layout->set_text ("\u2012\u2012\u2012|\u2012\u2012|\u2012\u2012\u2012\u2012");
1123                 if (_left_layout) {
1124                         _left_layout->set_text ("");
1125                         _right_layout->set_text ("");
1126                 }
1127                 return;
1128         }
1129
1130         if (when < 0) {
1131                 when = -when;
1132                 negative = true;
1133         }
1134
1135         /* handle a common case */
1136         if (is_duration) {
1137                 if (when == 0) {
1138                         BBT.bars = 0;
1139                         BBT.beats = 0;
1140                         BBT.ticks = 0;
1141                 } else {
1142                         _session->tempo_map().bbt_time (when, BBT);
1143                         BBT.bars--;
1144                         BBT.beats--;
1145                 }
1146         } else {
1147                 _session->tempo_map().bbt_time (when, BBT);
1148         }
1149
1150         if (negative) {
1151                 snprintf (buf, sizeof (buf), "-%03" PRIu32 BBT_BAR_CHAR "%02" PRIu32 BBT_BAR_CHAR "%04" PRIu32, 
1152                           BBT.bars, BBT.beats, BBT.ticks);
1153         } else {
1154                 snprintf (buf, sizeof (buf), " %03" PRIu32 BBT_BAR_CHAR "%02" PRIu32 BBT_BAR_CHAR "%04" PRIu32, 
1155                           BBT.bars, BBT.beats, BBT.ticks);
1156         }
1157
1158         _layout->set_text (buf);
1159                  
1160         if (_right_layout) {
1161                 framepos_t pos;
1162
1163                 if (bbt_reference_time < 0) {
1164                         pos = when;
1165                 } else {
1166                         pos = bbt_reference_time;
1167                 }
1168
1169                 TempoMetric m (_session->tempo_map().metric_at (pos));
1170
1171                 sprintf (buf, "%-5.2f", m.tempo().beats_per_minute());
1172                 _left_layout->set_text (buf);
1173
1174                 sprintf (buf, "%g/%g", m.meter().beats_per_bar(), m.meter().note_divisor());
1175                 _right_layout->set_text (buf);
1176         }
1177 }
1178
1179 void
1180 AudioClock::set_session (Session *s)
1181 {
1182         SessionHandlePtr::set_session (s);
1183
1184         if (_session) {
1185
1186                 _session->config.ParameterChanged.connect (_session_connections, invalidator (*this), boost::bind (&AudioClock::session_configuration_changed, this, _1), gui_context());
1187
1188                 const XMLProperty* prop;
1189                 XMLNode* node = _session->extra_xml (X_("ClockModes"));
1190                 AudioClock::Mode amode;
1191
1192                 if (node) {
1193                         for (XMLNodeList::const_iterator i = node->children().begin(); i != node->children().end(); ++i) {
1194                                 if ((prop = (*i)->property (X_("name"))) && prop->value() == _name) {
1195
1196                                         if ((prop = (*i)->property (X_("mode"))) != 0) {
1197                                                 amode = AudioClock::Mode (string_2_enum (prop->value(), amode));
1198                                                 set_mode (amode);
1199                                         }
1200                                         if ((prop = (*i)->property (X_("on"))) != 0) {
1201                                                 set_off (!string_is_affirmative (prop->value()));
1202                                         }
1203                                         break;
1204                                 }
1205                         }
1206                 }
1207
1208                 set (last_when, true);
1209         }
1210 }
1211
1212 bool
1213 AudioClock::on_key_press_event (GdkEventKey* ev)
1214 {
1215         if (!editing) {
1216                 return false;
1217         }
1218
1219         string new_text;
1220         char new_char = 0;
1221         int highlight_length;
1222         framepos_t pos;
1223
1224         switch (ev->keyval) {
1225         case GDK_0:
1226         case GDK_KP_0:
1227                 new_char = '0';
1228                 break;
1229         case GDK_1:
1230         case GDK_KP_1:
1231                 new_char = '1';
1232                 break;
1233         case GDK_2:
1234         case GDK_KP_2:
1235                 new_char = '2';
1236                 break;
1237         case GDK_3:
1238         case GDK_KP_3:
1239                 new_char = '3';
1240                 break;
1241         case GDK_4:
1242         case GDK_KP_4:
1243                 new_char = '4';
1244                 break;
1245         case GDK_5:
1246         case GDK_KP_5:
1247                 new_char = '5';
1248                 break;
1249         case GDK_6:
1250         case GDK_KP_6:
1251                 new_char = '6';
1252                 break;
1253         case GDK_7:
1254         case GDK_KP_7:
1255                 new_char = '7';
1256                 break;
1257         case GDK_8:
1258         case GDK_KP_8:
1259                 new_char = '8';
1260                 break;
1261         case GDK_9:
1262         case GDK_KP_9:
1263                 new_char = '9';
1264                 break;
1265
1266         case GDK_minus:
1267         case GDK_KP_Subtract:
1268                 end_edit_relative (false);
1269                 return true;
1270                 break;
1271
1272         case GDK_plus:
1273         case GDK_KP_Add:
1274                 end_edit_relative (true);
1275                 return true;
1276                 break;
1277
1278         case GDK_Tab:
1279         case GDK_Return:
1280         case GDK_KP_Enter:
1281                 end_edit (true);
1282                 return true;
1283                 break;
1284
1285         case GDK_Escape:
1286                 end_edit (false);
1287                 ChangeAborted();  /*  EMIT SIGNAL  */
1288                 return true;
1289
1290         case GDK_Delete:
1291         case GDK_BackSpace:
1292                 if (!input_string.empty()) {
1293                         /* delete the last key entered
1294                         */
1295                         input_string = input_string.substr (0, input_string.length() - 1);
1296                 }
1297                 goto use_input_string;
1298
1299         default:
1300                 return false;
1301         }
1302
1303         if (!insert_map.empty() && (input_string.length() >= insert_map.size())) {
1304                 /* too many digits: eat the key event, but do nothing with it */
1305                 return true;
1306         }
1307
1308         input_string.push_back (new_char);
1309
1310   use_input_string:
1311
1312         switch (_mode) {
1313         case Frames:
1314                 /* get this one in the right order, and to the right width */
1315                 if (ev->keyval == GDK_Delete || ev->keyval == GDK_BackSpace) {
1316                         edit_string = edit_string.substr (0, edit_string.length() - 1);
1317                 } else {
1318                         edit_string.push_back (new_char);
1319                 }
1320                 if (!edit_string.empty()) {
1321                         char buf[32];
1322                         sscanf (edit_string.c_str(), "%" PRId64, &pos);
1323                         snprintf (buf, sizeof (buf), " %10" PRId64, pos);
1324                         edit_string = buf;
1325                 }
1326                 /* highlight the whole thing */
1327                 highlight_length = edit_string.length();
1328                 break;
1329
1330         default:
1331                 highlight_length = merge_input_and_edit_string ();
1332         }
1333
1334         show_edit_status (highlight_length);
1335         _layout->set_text (edit_string);
1336         queue_draw ();
1337
1338         return true;
1339 }
1340
1341 int
1342 AudioClock::merge_input_and_edit_string ()
1343 {
1344         /* merge with pre-edit-string into edit string */
1345         
1346         edit_string = pre_edit_string;
1347         
1348         if (input_string.empty()) {
1349                 return 0;
1350         } 
1351
1352         string::size_type target;
1353         for (string::size_type i = 0; i < input_string.length(); ++i) {
1354                 target = insert_map[input_string.length() - 1 - i];
1355                 edit_string[target] = input_string[i];
1356         }
1357         /* highlight from end to wherever the last character was added */
1358         return edit_string.length() - insert_map[input_string.length()-1];
1359 }
1360
1361
1362 bool
1363 AudioClock::on_key_release_event (GdkEventKey *ev)
1364 {
1365         if (!editing) {
1366                 return false;
1367         }
1368         
1369         /* return true for keys that we used on press
1370            so that they cannot possibly do double-duty
1371         */
1372         switch (ev->keyval) {
1373         case GDK_0:
1374         case GDK_KP_0:
1375         case GDK_1:
1376         case GDK_KP_1:
1377         case GDK_2:
1378         case GDK_KP_2:
1379         case GDK_3:
1380         case GDK_KP_3:
1381         case GDK_4:
1382         case GDK_KP_4:
1383         case GDK_5:
1384         case GDK_KP_5:
1385         case GDK_6:
1386         case GDK_KP_6:
1387         case GDK_7:
1388         case GDK_KP_7:
1389         case GDK_8:
1390         case GDK_KP_8:
1391         case GDK_9:
1392         case GDK_KP_9:
1393         case GDK_period:
1394         case GDK_comma:
1395         case GDK_KP_Decimal:
1396         case GDK_Tab:
1397         case GDK_Return:
1398         case GDK_KP_Enter:
1399         case GDK_Escape:
1400         case GDK_minus:
1401         case GDK_plus:
1402         case GDK_KP_Add:
1403         case GDK_KP_Subtract:
1404                 return true;
1405         default:
1406                 return false;
1407         }
1408 }
1409
1410 AudioClock::Field
1411 AudioClock::index_to_field (int index) const
1412 {
1413         switch (_mode) {
1414         case Timecode:
1415                 if (index < 4) {
1416                         return Timecode_Hours;
1417                 } else if (index < 7) {
1418                         return Timecode_Minutes;
1419                 } else if (index < 10) {
1420                         return Timecode_Seconds;
1421                 } else {
1422                         return Timecode_Frames;
1423                 }
1424                 break;
1425         case BBT:
1426                 if (index < 5) {
1427                         return Bars;
1428                 } else if (index < 7) {
1429                         return Beats;
1430                 } else {
1431                         return Ticks;
1432                 }
1433                 break;
1434         case MinSec:
1435                 if (index < 3) {
1436                         return Timecode_Hours;
1437                 } else if (index < 6) {
1438                         return MS_Minutes;
1439                 } else if (index < 9) {
1440                         return MS_Seconds;
1441                 } else {
1442                         return MS_Milliseconds;
1443                 }
1444                 break;
1445         case Frames:
1446                 return AudioFrames;
1447                 break;
1448         }
1449
1450         return Field (0);
1451 }
1452
1453 bool
1454 AudioClock::on_button_press_event (GdkEventButton *ev)
1455 {
1456         switch (ev->button) {
1457         case 1:
1458                 if (editable && !_off) {
1459                         dragging = true;
1460                         /* make absolutely sure that the pointer is grabbed */
1461                         gdk_pointer_grab(ev->window,false ,
1462                                          GdkEventMask( Gdk::POINTER_MOTION_MASK | Gdk::BUTTON_PRESS_MASK |Gdk::BUTTON_RELEASE_MASK),
1463                                          NULL,NULL,ev->time);
1464                         drag_accum = 0;
1465                         drag_start_y = ev->y;
1466                         drag_y = ev->y;
1467                         
1468                         int index;
1469                         int trailing;
1470                         int y;
1471                         int x;
1472
1473                         /* the text has been centered vertically, so adjust
1474                          * x and y. 
1475                          */
1476
1477                         y = ev->y - ((upper_height - layout_height)/2);
1478                         x = ev->x - layout_x_offset;
1479                         
1480                         if (_layout->xy_to_index (x * PANGO_SCALE, y * PANGO_SCALE, index, trailing)) {                 
1481                                 drag_field = index_to_field (index);
1482                         } else {
1483                                 drag_field = Field (0);
1484                         }
1485                 }
1486                 break;
1487                 
1488         default:
1489                 return false;
1490                 break;
1491         }
1492
1493         return true;
1494 }
1495
1496 bool
1497 AudioClock::on_button_release_event (GdkEventButton *ev)
1498 {
1499         if (editable && !_off) {
1500                 if (dragging) {
1501                         gdk_pointer_ungrab (GDK_CURRENT_TIME);
1502                         dragging = false;
1503                         if (ev->y > drag_start_y+1 || ev->y < drag_start_y-1 || Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)){
1504                                 // we actually dragged so return without
1505                                 // setting editing focus, or we shift clicked
1506                                 return true;
1507                         } else {
1508                                 if (ev->button == 1) {
1509                                         
1510                                         if (_edit_by_click_field) {
1511
1512                                                 int index = 0;
1513                                                 int trailing;
1514                                                 int y = ev->y - ((upper_height - layout_height)/2);
1515                                                 int x = ev->x - layout_x_offset;
1516                                                 Field f;
1517
1518                                                 if (!_layout->xy_to_index (x * PANGO_SCALE, y * PANGO_SCALE, index, trailing)) {
1519                                                         return true;
1520                                                 }
1521                                                 
1522                                                 f = index_to_field (index);
1523                                                 
1524                                                 switch (f) {
1525                                                 case Timecode_Frames:
1526                                                 case MS_Milliseconds:
1527                                                 case Ticks:
1528                                                         f = Field (0);
1529                                                         break;
1530                                                 default:
1531                                                         break;
1532                                                 }
1533                                                 start_edit (f);
1534                                         } else {
1535                                                 start_edit ();
1536                                         }
1537                                 }
1538                         }
1539                 }
1540         }
1541
1542         if (Keyboard::is_context_menu_event (ev)) {
1543                 if (ops_menu == 0) {
1544                         build_ops_menu ();
1545                 }
1546                 ops_menu->popup (1, ev->time);
1547                 return true;
1548         }
1549
1550         return false;
1551 }
1552
1553 bool
1554 AudioClock::on_focus_out_event (GdkEventFocus* ev)
1555 {
1556         bool ret = CairoWidget::on_focus_out_event (ev);
1557
1558         if (editing) {
1559                 end_edit (false);
1560         }
1561
1562         return ret;
1563 }
1564
1565 bool
1566 AudioClock::on_scroll_event (GdkEventScroll *ev)
1567 {
1568         int index;
1569         int trailing;
1570
1571         if (editing || _session == 0 || !editable || _off) {
1572                 return false;
1573         }
1574
1575         int y;
1576         int x;
1577         
1578         /* the text has been centered vertically, so adjust
1579          * x and y. 
1580          */
1581
1582         y = ev->y - ((upper_height - layout_height)/2);
1583         x = ev->x - layout_x_offset;
1584
1585         if (!_layout->xy_to_index (x * PANGO_SCALE, y * PANGO_SCALE, index, trailing)) {
1586                 /* not in the main layout */
1587                 return false;
1588         }
1589         
1590         Field f = index_to_field (index);
1591         framepos_t frames = 0;
1592
1593         switch (ev->direction) {
1594
1595         case GDK_SCROLL_UP:
1596                 frames = get_frame_step (f);
1597                 if (frames != 0) {
1598                         if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
1599                                 frames *= 10;
1600                         }
1601                         set (current_time() + frames, true);
1602                         ValueChanged (); /* EMIT_SIGNAL */
1603                 }
1604                 break;
1605                 
1606         case GDK_SCROLL_DOWN:
1607                 frames = get_frame_step (f);
1608                 if (frames != 0) {
1609                         if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
1610                                 frames *= 10;
1611                         }
1612                         
1613                         if ((double)current_time() - (double)frames < 0.0) {
1614                                 set (0, true);
1615                         } else {
1616                                 set (current_time() - frames, true);
1617                         }
1618                         
1619                         ValueChanged (); /* EMIT_SIGNAL */
1620                 }
1621                 break;
1622                 
1623         default:
1624                 return false;
1625                 break;
1626         }
1627         
1628         return true;
1629 }
1630
1631 bool
1632 AudioClock::on_motion_notify_event (GdkEventMotion *ev)
1633 {
1634         if (editing || _session == 0 || !dragging) {
1635                 return false;
1636         }
1637
1638         float pixel_frame_scale_factor = 0.2f;
1639
1640         if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier))  {
1641                 pixel_frame_scale_factor = 0.1f;
1642         }
1643
1644
1645         if (Keyboard::modifier_state_contains (ev->state,
1646                                                Keyboard::PrimaryModifier|Keyboard::SecondaryModifier)) {
1647
1648                 pixel_frame_scale_factor = 0.025f;
1649         }
1650
1651         double y_delta = ev->y - drag_y;
1652
1653         drag_accum +=  y_delta*pixel_frame_scale_factor;
1654
1655         drag_y = ev->y;
1656
1657         if (trunc (drag_accum) != 0) {
1658
1659                 framepos_t frames;
1660                 framepos_t pos;
1661                 int dir;
1662                 dir = (drag_accum < 0 ? 1:-1);
1663                 pos = current_time();
1664                 frames = get_frame_step (drag_field,pos,dir);
1665
1666                 if (frames  != 0 &&  frames * drag_accum < current_time()) {
1667                         set ((framepos_t) floor (pos - drag_accum * frames), false); // minus because up is negative in GTK
1668                 } else {
1669                         set (0 , false);
1670                 }
1671
1672                 drag_accum= 0;
1673                 ValueChanged();  /* EMIT_SIGNAL */
1674         }
1675
1676         return true;
1677 }
1678
1679 framepos_t
1680 AudioClock::get_frame_step (Field field, framepos_t pos, int dir)
1681 {
1682         framecnt_t f = 0;
1683         Timecode::BBT_Time BBT;
1684         switch (field) {
1685         case Timecode_Hours:
1686                 f = (framecnt_t) floor (3600.0 * _session->frame_rate());
1687                 break;
1688         case Timecode_Minutes:
1689                 f = (framecnt_t) floor (60.0 * _session->frame_rate());
1690                 break;
1691         case Timecode_Seconds:
1692                 f = _session->frame_rate();
1693                 break;
1694         case Timecode_Frames:
1695                 f = (framecnt_t) floor (_session->frame_rate() / _session->timecode_frames_per_second());
1696                 break;
1697
1698         case AudioFrames:
1699                 f = 1;
1700                 break;
1701
1702         case MS_Hours:
1703                 f = (framecnt_t) floor (3600.0 * _session->frame_rate());
1704                 break;
1705         case MS_Minutes:
1706                 f = (framecnt_t) floor (60.0 * _session->frame_rate());
1707                 break;
1708         case MS_Seconds:
1709                 f = (framecnt_t) _session->frame_rate();
1710                 break;
1711         case MS_Milliseconds:
1712                 f = (framecnt_t) floor (_session->frame_rate() / 1000.0);
1713                 break;
1714
1715         case Bars:
1716                 BBT.bars = 1;
1717                 BBT.beats = 0;
1718                 BBT.ticks = 0;
1719                 f = _session->tempo_map().bbt_duration_at (pos,BBT,dir);
1720                 break;
1721         case Beats:
1722                 BBT.bars = 0;
1723                 BBT.beats = 1;
1724                 BBT.ticks = 0;
1725                 f = _session->tempo_map().bbt_duration_at(pos,BBT,dir);
1726                 break;
1727         case Ticks:
1728                 BBT.bars = 0;
1729                 BBT.beats = 0;
1730                 BBT.ticks = 1;
1731                 f = _session->tempo_map().bbt_duration_at(pos,BBT,dir);
1732                 break;
1733         default:
1734                 error << string_compose (_("programming error: %1"), "attempt to get frames from non-text field!") << endmsg;
1735                 f = 0;
1736                 break;
1737         }
1738
1739         return f;
1740 }
1741
1742 framepos_t
1743 AudioClock::current_time (framepos_t pos) const
1744 {
1745         return last_when;
1746 }
1747
1748 framepos_t
1749 AudioClock::current_duration (framepos_t pos) const
1750 {
1751         framepos_t ret = 0;
1752
1753         switch (_mode) {
1754         case Timecode:
1755                 ret = last_when;
1756                 break;
1757         case BBT:
1758                 ret = frame_duration_from_bbt_string (pos, _layout->get_text());
1759                 break;
1760
1761         case MinSec:
1762                 ret = last_when;
1763                 break;
1764
1765         case Frames:
1766                 ret = last_when;
1767                 break;
1768         }
1769
1770         return ret;
1771 }
1772
1773 bool
1774 AudioClock::bbt_validate_edit (const string& str)
1775 {
1776         AnyTime any;
1777
1778         if (sscanf (str.c_str(), BBT_SCANF_FORMAT, &any.bbt.bars, &any.bbt.beats, &any.bbt.ticks) != 3) {
1779                 return false;
1780         }
1781
1782         if (any.bbt.ticks > Timecode::BBT_Time::ticks_per_beat) {
1783                 return false;
1784         }
1785
1786         if (!is_duration && any.bbt.bars == 0) {
1787                 return false;
1788         }
1789
1790         if (!is_duration && any.bbt.beats == 0) {
1791                 return false;
1792         }
1793
1794         return true;
1795 }
1796
1797 bool
1798 AudioClock::timecode_validate_edit (const string& str)
1799 {
1800         Timecode::Time TC;
1801
1802         if (sscanf (_layout->get_text().c_str(), "%" PRId32 ":%" PRId32 ":%" PRId32 ":%" PRId32, 
1803                     &TC.hours, &TC.minutes, &TC.seconds, &TC.frames) != 4) {
1804                 return false;
1805         }
1806
1807         if (TC.hours > 23U || TC.minutes > 59U || TC.seconds > 59U) {
1808                 return false;
1809         }
1810
1811         if (TC.frames > (uint32_t) rint (_session->timecode_frames_per_second()) - 1) {
1812                 return false;
1813         }
1814
1815         if (_session->timecode_drop_frames()) {
1816                 if (TC.minutes % 10 && TC.seconds == 0U && TC.frames < 2U) {
1817                         return false;
1818                 }
1819         }
1820
1821         return true;
1822 }
1823
1824 bool
1825 AudioClock::minsec_validate_edit (const string& str)
1826 {
1827         int hrs, mins, secs, millisecs;
1828
1829         if (sscanf (str.c_str(), "%d:%d:%d.%d", &hrs, &mins, &secs, &millisecs) != 4) {
1830                 return false;
1831         }
1832         
1833         if (hrs > 23 || mins > 59 || secs > 59 || millisecs > 999) {
1834                 return false;
1835         }
1836
1837         return true;
1838 }
1839
1840 framepos_t
1841 AudioClock::frames_from_timecode_string (const string& str) const
1842 {
1843         if (_session == 0) {
1844                 return 0;
1845         }
1846
1847         Timecode::Time TC;
1848         framepos_t sample;
1849
1850         if (sscanf (str.c_str(), "%d:%d:%d:%d", &TC.hours, &TC.minutes, &TC.seconds, &TC.frames) != 4) {
1851                 error << string_compose (_("programming error: %1 %2"), "badly formatted timecode clock string", str) << endmsg;
1852                 return 0;
1853         }
1854
1855         TC.rate = _session->timecode_frames_per_second();
1856         TC.drop= _session->timecode_drop_frames();
1857
1858         _session->timecode_to_sample (TC, sample, false /* use_offset */, false /* use_subframes */ );
1859         
1860         // timecode_tester ();
1861
1862         return sample;
1863 }
1864
1865 framepos_t
1866 AudioClock::frames_from_minsec_string (const string& str) const
1867 {
1868         if (_session == 0) {
1869                 return 0;
1870         }
1871
1872         int hrs, mins, secs, millisecs;
1873         framecnt_t sr = _session->frame_rate();
1874
1875         if (sscanf (str.c_str(), "%d:%d:%d.%d", &hrs, &mins, &secs, &millisecs) != 4) {
1876                 error << string_compose (_("programming error: %1 %2"), "badly formatted minsec clock string", str) << endmsg;
1877                 return 0;
1878         }
1879
1880         return (framepos_t) floor ((hrs * 60.0f * 60.0f * sr) + (mins * 60.0f * sr) + (secs * sr) + (millisecs * sr / 1000.0));
1881 }
1882
1883 framepos_t
1884 AudioClock::frames_from_bbt_string (framepos_t pos, const string& str) const
1885 {
1886         if (_session == 0) {
1887                 error << "AudioClock::current_time() called with BBT mode but without session!" << endmsg;
1888                 return 0;
1889         }
1890
1891         AnyTime any;
1892         any.type = AnyTime::BBT;
1893
1894         if (sscanf (str.c_str(), BBT_SCANF_FORMAT, &any.bbt.bars, &any.bbt.beats, &any.bbt.ticks) != 3) {
1895                 return 0;
1896         }
1897         
1898         if (is_duration) {
1899                 any.bbt.bars++;
1900                 any.bbt.beats++;
1901                 return _session->any_duration_to_frames (pos, any);
1902         } else {
1903                 return _session->convert_to_frames (any);
1904         }
1905 }
1906
1907
1908 framepos_t
1909 AudioClock::frame_duration_from_bbt_string (framepos_t pos, const string& str) const
1910 {
1911         if (_session == 0) {
1912                 error << "AudioClock::current_time() called with BBT mode but without session!" << endmsg;
1913                 return 0;
1914         }
1915
1916         Timecode::BBT_Time bbt;
1917
1918         if (sscanf (str.c_str(), BBT_SCANF_FORMAT, &bbt.bars, &bbt.beats, &bbt.ticks) != 0) {
1919                 return 0;
1920         }
1921
1922         return _session->tempo_map().bbt_duration_at(pos,bbt,1);
1923 }
1924
1925 framepos_t
1926 AudioClock::frames_from_audioframes_string (const string& str) const
1927 {
1928         framepos_t f;
1929         sscanf (str.c_str(), "%" PRId64, &f);
1930         return f;
1931 }
1932
1933 void
1934 AudioClock::build_ops_menu ()
1935 {
1936         using namespace Menu_Helpers;
1937         ops_menu = new Menu;
1938         MenuList& ops_items = ops_menu->items();
1939         ops_menu->set_name ("ArdourContextMenu");
1940
1941         if (!Profile->get_sae()) {
1942                 ops_items.push_back (MenuElem (_("Timecode"), sigc::bind (sigc::mem_fun(*this, &AudioClock::set_mode), Timecode)));
1943         }
1944         ops_items.push_back (MenuElem (_("Bars:Beats"), sigc::bind (sigc::mem_fun(*this, &AudioClock::set_mode), BBT)));
1945         ops_items.push_back (MenuElem (_("Minutes:Seconds"), sigc::bind (sigc::mem_fun(*this, &AudioClock::set_mode), MinSec)));
1946         ops_items.push_back (MenuElem (_("Samples"), sigc::bind (sigc::mem_fun(*this, &AudioClock::set_mode), Frames)));
1947
1948         if (editable && !_off && !is_duration && !_follows_playhead) {
1949                 ops_items.push_back (SeparatorElem());
1950                 ops_items.push_back (MenuElem (_("Set From Playhead"), sigc::mem_fun(*this, &AudioClock::set_from_playhead)));
1951                 ops_items.push_back (MenuElem (_("Locate to This Time"), sigc::mem_fun(*this, &AudioClock::locate)));
1952         }
1953 }
1954
1955 void
1956 AudioClock::set_from_playhead ()
1957 {
1958         if (!_session) {
1959                 return;
1960         }
1961
1962         set (_session->transport_frame());
1963         ValueChanged ();
1964 }
1965
1966 void
1967 AudioClock::locate ()
1968 {
1969         if (!_session || is_duration) {
1970                 return;
1971         }
1972
1973         _session->request_locate (current_time(), _session->transport_rolling ());
1974 }
1975
1976 void
1977 AudioClock::set_mode (Mode m)
1978 {
1979         if (_mode == m) {
1980                 return;
1981         }
1982
1983         _mode = m;
1984
1985         insert_map.clear();
1986
1987         _layout->set_text ("");
1988
1989         if (_left_layout) {
1990                 _left_layout->set_text ("");
1991                 _right_layout->set_text ("");
1992         }
1993
1994         switch (_mode) {
1995         case Timecode:
1996                 mode_based_info_ratio = 0.5;
1997                 insert_map.push_back (11);
1998                 insert_map.push_back (10);
1999                 insert_map.push_back (8);
2000                 insert_map.push_back (7);
2001                 insert_map.push_back (5);
2002                 insert_map.push_back (4);
2003                 insert_map.push_back (2);
2004                 insert_map.push_back (1);
2005                 break;
2006                 
2007         case BBT:
2008                 mode_based_info_ratio = 0.5;
2009                 insert_map.push_back (11);
2010                 insert_map.push_back (10);
2011                 insert_map.push_back (9);
2012                 insert_map.push_back (8);
2013                 insert_map.push_back (6);
2014                 insert_map.push_back (5);       
2015                 insert_map.push_back (3);       
2016                 insert_map.push_back (2);       
2017                 insert_map.push_back (1);       
2018                 break;
2019                 
2020         case MinSec:
2021                 mode_based_info_ratio = 1.0;
2022                 insert_map.push_back (12);
2023                 insert_map.push_back (11);
2024                 insert_map.push_back (10);
2025                 insert_map.push_back (8);
2026                 insert_map.push_back (7);
2027                 insert_map.push_back (5);
2028                 insert_map.push_back (4);
2029                 insert_map.push_back (2);       
2030                 insert_map.push_back (1);       
2031                 break;
2032                 
2033         case Frames:
2034                 mode_based_info_ratio = 0.5;
2035                 break;
2036         }
2037
2038         set (last_when, true);
2039
2040         if (!is_transient) {
2041                 ModeChanged (); /* EMIT SIGNAL (the static one)*/
2042         }
2043
2044         if (!_fixed_width) {
2045                 /* display is different, allow us to resize */
2046                 first_width = 0;
2047                 first_height = 0;
2048                 queue_resize ();
2049         }
2050
2051         mode_changed (); /* EMIT SIGNAL (the member one) */
2052 }
2053
2054 void
2055 AudioClock::set_bbt_reference (framepos_t pos)
2056 {
2057         bbt_reference_time = pos;
2058 }
2059
2060 void
2061 AudioClock::on_style_changed (const Glib::RefPtr<Gtk::Style>& old_style)
2062 {
2063         CairoWidget::on_style_changed (old_style);
2064         set_font ();
2065         set_colors ();
2066 }
2067
2068 void
2069 AudioClock::set_editable (bool yn)
2070 {
2071         editable = yn;
2072 }
2073
2074 void
2075 AudioClock::set_is_duration (bool yn)
2076 {
2077         if (yn == is_duration) {
2078                 return;
2079         }
2080
2081         is_duration = yn;
2082         set (last_when, true);
2083 }
2084
2085 void
2086 AudioClock::set_off (bool yn) 
2087 {
2088         if (_off == yn) {
2089                 return;
2090         }
2091
2092         _off = yn;
2093
2094         /* force a redraw. last_when will be preserved, but the clock text will
2095          * change 
2096          */
2097         
2098         set (last_when, true);
2099 }
2100
2101 void
2102 AudioClock::focus ()
2103 {
2104         start_edit (Field (0));
2105 }
2106
2107 void
2108 AudioClock::set_corner_radius (double r)
2109 {
2110         corner_radius = r;
2111         queue_draw ();
2112 }
2113
2114 void
2115 AudioClock::set_fixed_width (bool yn)
2116 {
2117         _fixed_width = yn;
2118 }
2119
2120 void
2121 AudioClock::dpi_reset ()
2122 {
2123         /* force recomputation of size even if we are fixed width 
2124          */
2125         first_width = 0;
2126         first_height = 0;
2127         queue_resize ();
2128 }