X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Faudio_clock.cc;h=be1bb97713b763e5d9e97cc5facda2a2e7b4ac90;hb=fddb3778120e25b3b8e8134084e260dac07c1365;hp=25985c4a3b956ae1f7adc8c59e6679baac6e2211;hpb=6313751f753c4e85116b0fcdaaf21e4d8369b4af;p=ardour.git

diff --git a/gtk2_ardour/audio_clock.cc b/gtk2_ardour/audio_clock.cc
index 25985c4a3b..be1bb97713 100644
--- a/gtk2_ardour/audio_clock.cc
+++ b/gtk2_ardour/audio_clock.cc
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 1999 Paul Davis 
+    Copyright (C) 1999 Paul Davis
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -15,39 +15,47 @@
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
-    $Id$
 */
 
 #include <cstdio> // for sprintf
 #include <cmath>
 
-#include <pbd/convert.h>
+#include "pbd/convert.h"
+#include "pbd/enumwriter.h"
 
 #include <gtkmm2ext/utils.h>
 
-#include <ardour/ardour.h>
-#include <ardour/session.h>
-#include <ardour/tempo.h>
+#include "ardour/ardour.h"
+#include "ardour/session.h"
+#include "ardour/tempo.h"
+#include "ardour/profile.h"
 #include <sigc++/bind.h>
 
 #include "ardour_ui.h"
 #include "audio_clock.h"
 #include "utils.h"
 #include "keyboard.h"
+#include "gui_thread.h"
 #include "i18n.h"
 
 using namespace ARDOUR;
-using namespace sigc;
+using namespace PBD;
 using namespace Gtk;
+using namespace std;
+
+using Gtkmm2ext::Keyboard;
 
 using PBD::atoi;
 using PBD::atof;
 
+sigc::signal<void> AudioClock::ModeChanged;
+vector<AudioClock*> AudioClock::clocks;
+
 const uint32_t AudioClock::field_length[(int) AudioClock::AudioFrames+1] = {
-	2,   /* SMPTE_Hours */
-	2,   /* SMPTE_Minutes */
-	2,   /* SMPTE_Seconds */
-	2,   /* SMPTE_Frames */
+	2,   /* Timecode_Hours */
+	2,   /* Timecode_Minutes */
+	2,   /* Timecode_Seconds */
+	2,   /* Timecode_Frames */
 	2,   /* MS_Hours */
 	2,   /* MS_Minutes */
 	5,   /* MS_Seconds */
@@ -57,26 +65,78 @@ const uint32_t AudioClock::field_length[(int) AudioClock::AudioFrames+1] = {
 	10   /* Audio Frame */
 };
 
-AudioClock::AudioClock (const string& name, bool allow_edit, bool duration, bool with_tempo_and_meter) 
-	: is_duration (duration),
+AudioClock::AudioClock (const string& clock_name, bool transient, const string& widget_name, 
+			bool allow_edit, bool follows_playhead, bool duration, bool with_info)
+	: _name (clock_name),
+	  is_transient (transient),
+	  is_duration (duration),
 	  editable (allow_edit),
+	  _follows_playhead (follows_playhead),
 	  colon1 (":"),
 	  colon2 (":"),
 	  colon3 (":"),
 	  colon4 (":"),
 	  colon5 (":"),
 	  b1 ("|"),
-	  b2 ("|")
+	  b2 ("|"),
+	  last_when(0)
 {
-	session = 0;
 	last_when = 0;
+	last_pdelta = 0;
+	last_sdelta = 0;
 	key_entry_state = 0;
 	ops_menu = 0;
 	dragging = false;
-	
+	bbt_reference_time = -1;
+
+	if (with_info) {
+		frames_upper_info_label = manage (new Label);
+		frames_lower_info_label = manage (new Label);
+		timecode_upper_info_label = manage (new Label);
+		timecode_lower_info_label = manage (new Label);
+		bbt_upper_info_label = manage (new Label);
+		bbt_lower_info_label = manage (new Label);
+
+		frames_upper_info_label->set_name ("AudioClockFramesUpperInfo");
+		frames_lower_info_label->set_name ("AudioClockFramesLowerInfo");
+		timecode_upper_info_label->set_name ("AudioClockTimecodeUpperInfo");
+		timecode_lower_info_label->set_name ("AudioClockTimecodeLowerInfo");
+		bbt_upper_info_label->set_name ("AudioClockBBTUpperInfo");
+		bbt_lower_info_label->set_name ("AudioClockBBTLowerInfo");
+
+		Gtkmm2ext::set_size_request_to_display_given_text(*timecode_upper_info_label, "23.98",0,0);
+		Gtkmm2ext::set_size_request_to_display_given_text(*timecode_lower_info_label, "NDF",0,0);
+
+		Gtkmm2ext::set_size_request_to_display_given_text(*bbt_upper_info_label, "88|88",0,0);
+		Gtkmm2ext::set_size_request_to_display_given_text(*bbt_lower_info_label, "888.88",0,0);
+
+		frames_info_box.pack_start (*frames_upper_info_label, true, true);
+		frames_info_box.pack_start (*frames_lower_info_label, true, true);
+		timecode_info_box.pack_start (*timecode_upper_info_label, true, true);
+		timecode_info_box.pack_start (*timecode_lower_info_label, true, true);
+		bbt_info_box.pack_start (*bbt_upper_info_label, true, true);
+		bbt_info_box.pack_start (*bbt_lower_info_label, true, true);
+
+	} else {
+		frames_upper_info_label = 0;
+		frames_lower_info_label = 0;
+		timecode_upper_info_label = 0;
+		timecode_lower_info_label = 0;
+		bbt_upper_info_label = 0;
+		bbt_lower_info_label = 0;
+	}
+
 	audio_frames_ebox.add (audio_frames_label);
-	frames_packer_hbox.set_border_width (2);
-	frames_packer_hbox.pack_start (audio_frames_ebox, false, false);
+
+	frames_packer.set_homogeneous (false);
+	frames_packer.set_border_width (2);
+	frames_packer.pack_start (audio_frames_ebox, false, false);
+
+	if (with_info) {
+		frames_packer.pack_start (frames_info_box, false, false, 5);
+	}
+
+	frames_packer_hbox.pack_start (frames_packer, true, false);
 
 	hours_ebox.add (hours_label);
 	minutes_ebox.add (minutes_label);
@@ -89,17 +149,21 @@ AudioClock::AudioClock (const string& name, bool allow_edit, bool duration, bool
 	ms_minutes_ebox.add (ms_minutes_label);
 	ms_seconds_ebox.add (ms_seconds_label);
 
-	smpte_packer.set_homogeneous (false);
-	smpte_packer.set_border_width (2);
-	smpte_packer.pack_start (hours_ebox, false, false);
-	smpte_packer.pack_start (colon1, false, false);
-	smpte_packer.pack_start (minutes_ebox, false, false);
-	smpte_packer.pack_start (colon2, false, false);
-	smpte_packer.pack_start (seconds_ebox, false, false);
-	smpte_packer.pack_start (colon3, false, false);
-	smpte_packer.pack_start (frames_ebox, false, false);
+	timecode_packer.set_homogeneous (false);
+	timecode_packer.set_border_width (2);
+	timecode_packer.pack_start (hours_ebox, false, false);
+	timecode_packer.pack_start (colon1, false, false);
+	timecode_packer.pack_start (minutes_ebox, false, false);
+	timecode_packer.pack_start (colon2, false, false);
+	timecode_packer.pack_start (seconds_ebox, false, false);
+	timecode_packer.pack_start (colon3, false, false);
+	timecode_packer.pack_start (frames_ebox, false, false);
+
+	if (with_info) {
+		timecode_packer.pack_start (timecode_info_box, false, false, 5);
+	}
 
-	smpte_packer_hbox.pack_start (smpte_packer, true, false);
+	timecode_packer_hbox.pack_start (timecode_packer, true, false);
 
 	bbt_packer.set_homogeneous (false);
 	bbt_packer.set_border_width (2);
@@ -109,20 +173,8 @@ AudioClock::AudioClock (const string& name, bool allow_edit, bool duration, bool
 	bbt_packer.pack_start (b2, false, false);
 	bbt_packer.pack_start (ticks_ebox, false, false);
 
-	if (with_tempo_and_meter) {
-		meter_label = manage (new Label);
-		tempo_label = manage (new Label);
-
-		meter_label->set_name ("BBTMeterLabel");
-		tempo_label->set_name ("BBTTempoLabel");
-
-		tempo_meter_box.pack_start (*meter_label, true, true);
-		tempo_meter_box.pack_start (*tempo_label, true, true);
-
-		bbt_packer.pack_start (tempo_meter_box, false, false, 5);
-	} else {
-		meter_label = 0;
-		tempo_label = 0;
+	if (with_info) {
+		bbt_packer.pack_start (bbt_info_box, false, false, 5);
 	}
 
 	bbt_packer_hbox.pack_start (bbt_packer, true, false);
@@ -137,7 +189,50 @@ AudioClock::AudioClock (const string& name, bool allow_edit, bool duration, bool
 
 	minsec_packer_hbox.pack_start (minsec_packer, true, false);
 
-	set_name (name);
+	clock_frame.set_shadow_type (Gtk::SHADOW_IN);
+	clock_frame.set_name ("BaseFrame");
+
+	clock_frame.add (clock_base);
+
+	set_widget_name (widget_name);
+
+	_mode = BBT; /* lie to force mode switch */
+	set_mode (Timecode);
+
+	pack_start (clock_frame, true, true);
+
+	/* the clock base handles button releases for menu popup regardless of
+	   editable status. if the clock is editable, the clock base is where
+	   we pass focus to after leaving the last editable "field", which
+	   will then shutdown editing till the user starts it up again.
+
+	   it does this because the focus out event on the field disables
+	   keyboard event handling, and we don't connect anything up to
+	   notice focus in on the clock base. hence, keyboard event handling
+	   stays disabled.
+	*/
+
+	clock_base.add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|Gdk::SCROLL_MASK);
+	clock_base.signal_button_release_event().connect (sigc::bind (sigc::mem_fun (*this, &AudioClock::field_button_release_event), Timecode_Hours));
+
+	Session::TimecodeOffsetChanged.connect (_session_connections, invalidator (*this), boost::bind (&AudioClock::timecode_offset_changed, this), gui_context());
+
+	if (editable) {
+		setup_events ();
+	}
+
+	set (last_when, true);
+
+	if (!is_transient) {
+		clocks.push_back (this);
+	}
+}
+
+void
+AudioClock::set_widget_name (string name)
+{
+	Widget::set_name (name);
+
 	clock_base.set_name (name);
 
 	audio_frames_label.set_name (name);
@@ -162,7 +257,7 @@ AudioClock::AudioClock (const string& name, bool allow_edit, bool duration, bool
 	ms_hours_ebox.set_name (name);
 	ms_minutes_ebox.set_name (name);
 	ms_seconds_ebox.set_name (name);
-	
+
 	colon1.set_name (name);
 	colon2.set_name (name);
 	colon3.set_name (name);
@@ -171,37 +266,7 @@ AudioClock::AudioClock (const string& name, bool allow_edit, bool duration, bool
 	b1.set_name (name);
 	b2.set_name (name);
 
-	clock_frame.set_shadow_type (Gtk::SHADOW_IN);
-	clock_frame.set_name ("BaseFrame");
-
-	clock_frame.add (clock_base);
-
-	_mode = BBT; /* lie to force mode switch */
-	set_mode (SMPTE);
-
-	pack_start (clock_frame, true, true);
-
-	/* the clock base handles button releases for menu popup regardless of
-	   editable status. if the clock is editable, the clock base is where
-	   we pass focus to after leaving the last editable "field", which
-	   will then shutdown editing till the user starts it up again.
-
-	   it does this because the focus out event on the field disables
-	   keyboard event handling, and we don't connect anything up to
-	   notice focus in on the clock base. hence, keyboard event handling
-	   stays disabled.
-	*/
-
-	clock_base.add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|Gdk::SCROLL_MASK);
-	clock_base.signal_button_release_event().connect (bind (mem_fun (*this, &AudioClock::field_button_release_event), SMPTE_Hours));
-
-	Session::SMPTEOffsetChanged.connect (mem_fun (*this, &AudioClock::smpte_offset_changed));
-
-	if (editable) {
-		setup_events ();
-	}
-
-	set (last_when, true);
+	queue_draw ();
 }
 
 void
@@ -233,89 +298,110 @@ AudioClock::setup_events ()
 	ms_minutes_ebox.set_flags (Gtk::CAN_FOCUS);
 	ms_seconds_ebox.set_flags (Gtk::CAN_FOCUS);
 
-	hours_ebox.signal_motion_notify_event().connect (bind (mem_fun(*this, &AudioClock::field_motion_notify_event), SMPTE_Hours));
-	minutes_ebox.signal_motion_notify_event().connect (bind (mem_fun(*this, &AudioClock::field_motion_notify_event), SMPTE_Minutes));
-	seconds_ebox.signal_motion_notify_event().connect (bind (mem_fun(*this, &AudioClock::field_motion_notify_event), SMPTE_Seconds));
-	frames_ebox.signal_motion_notify_event().connect (bind (mem_fun(*this, &AudioClock::field_motion_notify_event), SMPTE_Frames));
-	audio_frames_ebox.signal_motion_notify_event().connect (bind (mem_fun(*this, &AudioClock::field_motion_notify_event), AudioFrames));
-	bars_ebox.signal_motion_notify_event().connect (bind (mem_fun(*this, &AudioClock::field_motion_notify_event), Bars));
-	beats_ebox.signal_motion_notify_event().connect (bind (mem_fun(*this, &AudioClock::field_motion_notify_event), Beats));
-	ticks_ebox.signal_motion_notify_event().connect (bind (mem_fun(*this, &AudioClock::field_motion_notify_event), Ticks));
-	ms_hours_ebox.signal_motion_notify_event().connect (bind (mem_fun(*this, &AudioClock::field_motion_notify_event), MS_Hours));
-	ms_minutes_ebox.signal_motion_notify_event().connect (bind (mem_fun(*this, &AudioClock::field_motion_notify_event), MS_Minutes));
-	ms_seconds_ebox.signal_motion_notify_event().connect (bind (mem_fun(*this, &AudioClock::field_motion_notify_event), MS_Seconds));
-
-	hours_ebox.signal_button_press_event().connect (bind (mem_fun(*this, &AudioClock::field_button_press_event), SMPTE_Hours));
-	minutes_ebox.signal_button_press_event().connect (bind (mem_fun(*this, &AudioClock::field_button_press_event), SMPTE_Minutes));
-	seconds_ebox.signal_button_press_event().connect (bind (mem_fun(*this, &AudioClock::field_button_press_event), SMPTE_Seconds));
-	frames_ebox.signal_button_press_event().connect (bind (mem_fun(*this, &AudioClock::field_button_press_event), SMPTE_Frames));
-	audio_frames_ebox.signal_button_press_event().connect (bind (mem_fun(*this, &AudioClock::field_button_press_event), AudioFrames));
-	bars_ebox.signal_button_press_event().connect (bind (mem_fun(*this, &AudioClock::field_button_press_event), Bars));
-	beats_ebox.signal_button_press_event().connect (bind (mem_fun(*this, &AudioClock::field_button_press_event), Beats));
-	ticks_ebox.signal_button_press_event().connect (bind (mem_fun(*this, &AudioClock::field_button_press_event), Ticks));
-	ms_hours_ebox.signal_button_press_event().connect (bind (mem_fun(*this, &AudioClock::field_button_press_event), MS_Hours));
-	ms_minutes_ebox.signal_button_press_event().connect (bind (mem_fun(*this, &AudioClock::field_button_press_event), MS_Minutes));
-	ms_seconds_ebox.signal_button_press_event().connect (bind (mem_fun(*this, &AudioClock::field_button_press_event), MS_Seconds));
-
-	hours_ebox.signal_button_release_event().connect (bind (mem_fun(*this, &AudioClock::field_button_release_event), SMPTE_Hours));
-	minutes_ebox.signal_button_release_event().connect (bind (mem_fun(*this, &AudioClock::field_button_release_event), SMPTE_Minutes));
-	seconds_ebox.signal_button_release_event().connect (bind (mem_fun(*this, &AudioClock::field_button_release_event), SMPTE_Seconds));
-	frames_ebox.signal_button_release_event().connect (bind (mem_fun(*this, &AudioClock::field_button_release_event), SMPTE_Frames));
-	audio_frames_ebox.signal_button_release_event().connect (bind (mem_fun(*this, &AudioClock::field_button_release_event), AudioFrames));
-	bars_ebox.signal_button_release_event().connect (bind (mem_fun(*this, &AudioClock::field_button_release_event), Bars));
-	beats_ebox.signal_button_release_event().connect (bind (mem_fun(*this, &AudioClock::field_button_release_event), Beats));
-	ticks_ebox.signal_button_release_event().connect (bind (mem_fun(*this, &AudioClock::field_button_release_event), Ticks));
-	ms_hours_ebox.signal_button_release_event().connect (bind (mem_fun(*this, &AudioClock::field_button_release_event), MS_Hours));
-	ms_minutes_ebox.signal_button_release_event().connect (bind (mem_fun(*this, &AudioClock::field_button_release_event), MS_Minutes));
-	ms_seconds_ebox.signal_button_release_event().connect (bind (mem_fun(*this, &AudioClock::field_button_release_event), MS_Seconds));
-
-	hours_ebox.signal_scroll_event().connect (bind (mem_fun(*this, &AudioClock::field_button_scroll_event), SMPTE_Hours));
-	minutes_ebox.signal_scroll_event().connect (bind (mem_fun(*this, &AudioClock::field_button_scroll_event), SMPTE_Minutes));
-	seconds_ebox.signal_scroll_event().connect (bind (mem_fun(*this, &AudioClock::field_button_scroll_event), SMPTE_Seconds));
-	frames_ebox.signal_scroll_event().connect (bind (mem_fun(*this, &AudioClock::field_button_scroll_event), SMPTE_Frames));
-	audio_frames_ebox.signal_scroll_event().connect (bind (mem_fun(*this, &AudioClock::field_button_scroll_event), AudioFrames));
-	bars_ebox.signal_scroll_event().connect (bind (mem_fun(*this, &AudioClock::field_button_scroll_event), Bars));
-	beats_ebox.signal_scroll_event().connect (bind (mem_fun(*this, &AudioClock::field_button_scroll_event), Beats));
-	ticks_ebox.signal_scroll_event().connect (bind (mem_fun(*this, &AudioClock::field_button_scroll_event), Ticks));
-	ms_hours_ebox.signal_scroll_event().connect (bind (mem_fun(*this, &AudioClock::field_button_scroll_event), MS_Hours));
-	ms_minutes_ebox.signal_scroll_event().connect (bind (mem_fun(*this, &AudioClock::field_button_scroll_event), MS_Minutes));
-	ms_seconds_ebox.signal_scroll_event().connect (bind (mem_fun(*this, &AudioClock::field_button_scroll_event), MS_Seconds));
-
-	hours_ebox.signal_key_release_event().connect (bind (mem_fun(*this, &AudioClock::field_key_release_event), SMPTE_Hours));
-	minutes_ebox.signal_key_release_event().connect (bind (mem_fun(*this, &AudioClock::field_key_release_event), SMPTE_Minutes));
-	seconds_ebox.signal_key_release_event().connect (bind (mem_fun(*this, &AudioClock::field_key_release_event), SMPTE_Seconds));
-	frames_ebox.signal_key_release_event().connect (bind (mem_fun(*this, &AudioClock::field_key_release_event), SMPTE_Frames));
-	audio_frames_ebox.signal_key_release_event().connect (bind (mem_fun(*this, &AudioClock::field_key_release_event), AudioFrames));
-	bars_ebox.signal_key_release_event().connect (bind (mem_fun(*this, &AudioClock::field_key_release_event), Bars));
-	beats_ebox.signal_key_release_event().connect (bind (mem_fun(*this, &AudioClock::field_key_release_event), Beats));
-	ticks_ebox.signal_key_release_event().connect (bind (mem_fun(*this, &AudioClock::field_key_release_event), Ticks));
-	ms_hours_ebox.signal_key_release_event().connect (bind (mem_fun(*this, &AudioClock::field_key_release_event), MS_Hours));
-	ms_minutes_ebox.signal_key_release_event().connect (bind (mem_fun(*this, &AudioClock::field_key_release_event), MS_Minutes));
-	ms_seconds_ebox.signal_key_release_event().connect (bind (mem_fun(*this, &AudioClock::field_key_release_event), MS_Seconds));
-
-	hours_ebox.signal_focus_in_event().connect (bind (mem_fun(*this, &AudioClock::field_focus_in_event), SMPTE_Hours));
-	minutes_ebox.signal_focus_in_event().connect (bind (mem_fun(*this, &AudioClock::field_focus_in_event), SMPTE_Minutes));
-	seconds_ebox.signal_focus_in_event().connect (bind (mem_fun(*this, &AudioClock::field_focus_in_event), SMPTE_Seconds));
-	frames_ebox.signal_focus_in_event().connect (bind (mem_fun(*this, &AudioClock::field_focus_in_event), SMPTE_Frames));
-	audio_frames_ebox.signal_focus_in_event().connect (bind (mem_fun(*this, &AudioClock::field_focus_in_event), AudioFrames));
-	bars_ebox.signal_focus_in_event().connect (bind (mem_fun(*this, &AudioClock::field_focus_in_event), Bars));
-	beats_ebox.signal_focus_in_event().connect (bind (mem_fun(*this, &AudioClock::field_focus_in_event), Beats));
-	ticks_ebox.signal_focus_in_event().connect (bind (mem_fun(*this, &AudioClock::field_focus_in_event), Ticks));
-	ms_hours_ebox.signal_focus_in_event().connect (bind (mem_fun(*this, &AudioClock::field_focus_in_event), MS_Hours));
-	ms_minutes_ebox.signal_focus_in_event().connect (bind (mem_fun(*this, &AudioClock::field_focus_in_event), MS_Minutes));
-	ms_seconds_ebox.signal_focus_in_event().connect (bind (mem_fun(*this, &AudioClock::field_focus_in_event), MS_Seconds));
-
-	hours_ebox.signal_focus_out_event().connect (bind (mem_fun(*this, &AudioClock::field_focus_out_event), SMPTE_Hours));
-	minutes_ebox.signal_focus_out_event().connect (bind (mem_fun(*this, &AudioClock::field_focus_out_event), SMPTE_Minutes));
-	seconds_ebox.signal_focus_out_event().connect (bind (mem_fun(*this, &AudioClock::field_focus_out_event), SMPTE_Seconds));
-	frames_ebox.signal_focus_out_event().connect (bind (mem_fun(*this, &AudioClock::field_focus_out_event), SMPTE_Frames));
-	audio_frames_ebox.signal_focus_out_event().connect (bind (mem_fun(*this, &AudioClock::field_focus_out_event), AudioFrames));
-	bars_ebox.signal_focus_out_event().connect (bind (mem_fun(*this, &AudioClock::field_focus_out_event), Bars));
-	beats_ebox.signal_focus_out_event().connect (bind (mem_fun(*this, &AudioClock::field_focus_out_event), Beats));
-	ticks_ebox.signal_focus_out_event().connect (bind (mem_fun(*this, &AudioClock::field_focus_out_event), Ticks));
-	ms_hours_ebox.signal_focus_out_event().connect (bind (mem_fun(*this, &AudioClock::field_focus_out_event), MS_Hours));
-	ms_minutes_ebox.signal_focus_out_event().connect (bind (mem_fun(*this, &AudioClock::field_focus_out_event), MS_Minutes));
-	ms_seconds_ebox.signal_focus_out_event().connect (bind (mem_fun(*this, &AudioClock::field_focus_out_event), MS_Seconds));
+	hours_ebox.signal_motion_notify_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_motion_notify_event), Timecode_Hours));
+	minutes_ebox.signal_motion_notify_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_motion_notify_event), Timecode_Minutes));
+	seconds_ebox.signal_motion_notify_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_motion_notify_event), Timecode_Seconds));
+	frames_ebox.signal_motion_notify_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_motion_notify_event), Timecode_Frames));
+	audio_frames_ebox.signal_motion_notify_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_motion_notify_event), AudioFrames));
+	bars_ebox.signal_motion_notify_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_motion_notify_event), Bars));
+	beats_ebox.signal_motion_notify_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_motion_notify_event), Beats));
+	ticks_ebox.signal_motion_notify_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_motion_notify_event), Ticks));
+	ms_hours_ebox.signal_motion_notify_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_motion_notify_event), MS_Hours));
+	ms_minutes_ebox.signal_motion_notify_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_motion_notify_event), MS_Minutes));
+	ms_seconds_ebox.signal_motion_notify_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_motion_notify_event), MS_Seconds));
+
+	hours_ebox.signal_button_press_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_press_event), Timecode_Hours));
+	minutes_ebox.signal_button_press_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_press_event), Timecode_Minutes));
+	seconds_ebox.signal_button_press_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_press_event), Timecode_Seconds));
+	frames_ebox.signal_button_press_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_press_event), Timecode_Frames));
+	audio_frames_ebox.signal_button_press_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_press_event), AudioFrames));
+	bars_ebox.signal_button_press_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_press_event), Bars));
+	beats_ebox.signal_button_press_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_press_event), Beats));
+	ticks_ebox.signal_button_press_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_press_event), Ticks));
+	ms_hours_ebox.signal_button_press_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_press_event), MS_Hours));
+	ms_minutes_ebox.signal_button_press_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_press_event), MS_Minutes));
+	ms_seconds_ebox.signal_button_press_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_press_event), MS_Seconds));
+
+	hours_ebox.signal_button_release_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_release_event), Timecode_Hours));
+	minutes_ebox.signal_button_release_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_release_event), Timecode_Minutes));
+	seconds_ebox.signal_button_release_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_release_event), Timecode_Seconds));
+	frames_ebox.signal_button_release_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_release_event), Timecode_Frames));
+	audio_frames_ebox.signal_button_release_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_release_event), AudioFrames));
+	bars_ebox.signal_button_release_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_release_event), Bars));
+	beats_ebox.signal_button_release_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_release_event), Beats));
+	ticks_ebox.signal_button_release_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_release_event), Ticks));
+	ms_hours_ebox.signal_button_release_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_release_event), MS_Hours));
+	ms_minutes_ebox.signal_button_release_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_release_event), MS_Minutes));
+	ms_seconds_ebox.signal_button_release_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_release_event), MS_Seconds));
+
+	hours_ebox.signal_scroll_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_scroll_event), Timecode_Hours));
+	minutes_ebox.signal_scroll_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_scroll_event), Timecode_Minutes));
+	seconds_ebox.signal_scroll_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_scroll_event), Timecode_Seconds));
+	frames_ebox.signal_scroll_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_scroll_event), Timecode_Frames));
+	audio_frames_ebox.signal_scroll_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_scroll_event), AudioFrames));
+	bars_ebox.signal_scroll_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_scroll_event), Bars));
+	beats_ebox.signal_scroll_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_scroll_event), Beats));
+	ticks_ebox.signal_scroll_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_scroll_event), Ticks));
+	ms_hours_ebox.signal_scroll_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_scroll_event), MS_Hours));
+	ms_minutes_ebox.signal_scroll_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_scroll_event), MS_Minutes));
+	ms_seconds_ebox.signal_scroll_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_button_scroll_event), MS_Seconds));
+
+	hours_ebox.signal_key_press_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_key_press_event), Timecode_Hours));
+	minutes_ebox.signal_key_press_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_key_press_event), Timecode_Minutes));
+	seconds_ebox.signal_key_press_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_key_press_event), Timecode_Seconds));
+	frames_ebox.signal_key_press_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_key_press_event), Timecode_Frames));
+	audio_frames_ebox.signal_key_press_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_key_press_event), AudioFrames));
+	bars_ebox.signal_key_press_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_key_press_event), Bars));
+	beats_ebox.signal_key_press_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_key_press_event), Beats));
+	ticks_ebox.signal_key_press_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_key_press_event), Ticks));
+	ms_hours_ebox.signal_key_press_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_key_press_event), MS_Hours));
+	ms_minutes_ebox.signal_key_press_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_key_press_event), MS_Minutes));
+	ms_seconds_ebox.signal_key_press_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_key_press_event), MS_Seconds));
+
+	hours_ebox.signal_key_release_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_key_release_event), Timecode_Hours));
+	minutes_ebox.signal_key_release_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_key_release_event), Timecode_Minutes));
+	seconds_ebox.signal_key_release_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_key_release_event), Timecode_Seconds));
+	frames_ebox.signal_key_release_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_key_release_event), Timecode_Frames));
+	audio_frames_ebox.signal_key_release_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_key_release_event), AudioFrames));
+	bars_ebox.signal_key_release_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_key_release_event), Bars));
+	beats_ebox.signal_key_release_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_key_release_event), Beats));
+	ticks_ebox.signal_key_release_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_key_release_event), Ticks));
+	ms_hours_ebox.signal_key_release_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_key_release_event), MS_Hours));
+	ms_minutes_ebox.signal_key_release_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_key_release_event), MS_Minutes));
+	ms_seconds_ebox.signal_key_release_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_key_release_event), MS_Seconds));
+
+	hours_ebox.signal_focus_in_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_focus_in_event), Timecode_Hours));
+	minutes_ebox.signal_focus_in_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_focus_in_event), Timecode_Minutes));
+	seconds_ebox.signal_focus_in_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_focus_in_event), Timecode_Seconds));
+	frames_ebox.signal_focus_in_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_focus_in_event), Timecode_Frames));
+	audio_frames_ebox.signal_focus_in_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_focus_in_event), AudioFrames));
+	bars_ebox.signal_focus_in_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_focus_in_event), Bars));
+	beats_ebox.signal_focus_in_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_focus_in_event), Beats));
+	ticks_ebox.signal_focus_in_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_focus_in_event), Ticks));
+	ms_hours_ebox.signal_focus_in_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_focus_in_event), MS_Hours));
+	ms_minutes_ebox.signal_focus_in_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_focus_in_event), MS_Minutes));
+	ms_seconds_ebox.signal_focus_in_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_focus_in_event), MS_Seconds));
+
+	hours_ebox.signal_focus_out_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_focus_out_event), Timecode_Hours));
+	minutes_ebox.signal_focus_out_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_focus_out_event), Timecode_Minutes));
+	seconds_ebox.signal_focus_out_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_focus_out_event), Timecode_Seconds));
+	frames_ebox.signal_focus_out_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_focus_out_event), Timecode_Frames));
+	audio_frames_ebox.signal_focus_out_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_focus_out_event), AudioFrames));
+	bars_ebox.signal_focus_out_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_focus_out_event), Bars));
+	beats_ebox.signal_focus_out_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_focus_out_event), Beats));
+	ticks_ebox.signal_focus_out_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_focus_out_event), Ticks));
+	ms_hours_ebox.signal_focus_out_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_focus_out_event), MS_Hours));
+	ms_minutes_ebox.signal_focus_out_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_focus_out_event), MS_Minutes));
+	ms_seconds_ebox.signal_focus_out_event().connect (sigc::bind (sigc::mem_fun(*this, &AudioClock::field_focus_out_event), MS_Seconds));
+
+	clock_base.signal_focus_in_event().connect (sigc::mem_fun (*this, &AudioClock::drop_focus_handler));
+}
+
+bool
+AudioClock::drop_focus_handler (GdkEventFocus*)
+{
+	Keyboard::magic_widget_drop_focus ();
+	return false;
 }
 
 void
@@ -325,51 +411,47 @@ AudioClock::on_realize ()
 
 	/* styles are not available until the widgets are bound to a window */
 
-	switch (_mode) {
-	case SMPTE:
-		Gtkmm2ext::set_size_request_to_display_given_text (hours_label, "-88", 0, 2);
-		Gtkmm2ext::set_size_request_to_display_given_text (minutes_label, "88", 0, 2);
-		Gtkmm2ext::set_size_request_to_display_given_text (seconds_label, "88", 0, 2);
-		Gtkmm2ext::set_size_request_to_display_given_text (frames_label, "88", 0, 2);
-		break;
-
-	case BBT:
-		Gtkmm2ext::set_size_request_to_display_given_text (bars_label, "-888", 0, 2);
-		Gtkmm2ext::set_size_request_to_display_given_text (beats_label, "88", 0, 2);
-		Gtkmm2ext::set_size_request_to_display_given_text (ticks_label, "8888", 0, 2);
-		break;
-
-	case MinSec:
-		Gtkmm2ext::set_size_request_to_display_given_text (ms_hours_label, "99", 0, 2);
-		Gtkmm2ext::set_size_request_to_display_given_text (ms_minutes_label, "99", 0, 2);
-		Gtkmm2ext::set_size_request_to_display_given_text (ms_seconds_label, "99", 0, 2);
-		break;
-
-	case Frames:
-		Gtkmm2ext::set_size_request_to_display_given_text (audio_frames_label, "4294967296", 0, 2);
-		break;
-
-	case Off:
-		break;
-		
-	}
+	set_size_requests ();
 }
 
 void
-AudioClock::set (jack_nframes_t when, bool force)
+AudioClock::set (nframes_t when, bool force, nframes_t offset, char which)
 {
 
- 	if ((!force && !is_visible()) || session == 0) {
+ 	if ((!force && !is_visible()) || _session == 0) {
 		return;
 	}
-	
-	if (when == last_when && !force) {
+
+	if (when == last_when && !offset && !force) {
 		return;
 	}
 
+	bool pdelta = Config->get_primary_clock_delta_edit_cursor();
+	bool sdelta = Config->get_secondary_clock_delta_edit_cursor();
+
+	if (offset && which == 'p' && pdelta) {
+		when = (when > offset) ? when - offset : offset - when;
+	} else if (offset && which == 's' && sdelta) {
+		when = (when > offset) ? when - offset : offset - when;
+	}
+
+	if (which == 'p' && pdelta && !last_pdelta) {
+		set_widget_name("TransportClockDisplayDelta");
+		last_pdelta = true;
+	} else if (which == 'p' && !pdelta && last_pdelta) {
+		set_widget_name("TransportClockDisplay");
+		last_pdelta = false;
+	} else if (which == 's'  && sdelta && !last_sdelta) {
+		set_widget_name("SecondaryClockDisplayDelta");
+		last_sdelta = true;
+	} else if (which == 's' && !sdelta && last_sdelta) {
+		set_widget_name("SecondaryClockDisplay");
+		last_sdelta = false;
+	}
+
 	switch (_mode) {
-	case SMPTE:
-		set_smpte (when, force);
+	case Timecode:
+		set_timecode (when, force);
 		break;
 
 	case BBT:
@@ -392,12 +474,12 @@ AudioClock::set (jack_nframes_t when, bool force)
 }
 
 void
-AudioClock::smpte_offset_changed ()
+AudioClock::timecode_offset_changed ()
 {
-	jack_nframes_t current;
+	nframes_t current;
 
 	switch (_mode) {
-	case SMPTE:
+	case Timecode:
 		if (is_duration) {
 			current = current_duration();
 		} else {
@@ -411,37 +493,64 @@ AudioClock::smpte_offset_changed ()
 }
 
 void
-AudioClock::set_frames (jack_nframes_t when, bool force)
+AudioClock::set_frames (nframes_t when, bool /*force*/)
 {
 	char buf[32];
 	snprintf (buf, sizeof (buf), "%u", when);
 	audio_frames_label.set_text (buf);
-}	
+
+	if (frames_upper_info_label) {
+		nframes_t rate = _session->frame_rate();
+
+		if (fmod (rate, 1000.0) == 0.000) {
+			sprintf (buf, "%uK", rate/1000);
+		} else {
+			sprintf (buf, "%.3fK", rate/1000.0f);
+		}
+
+		if (frames_upper_info_label->get_text() != buf) {
+			frames_upper_info_label->set_text (buf);
+		}
+
+		float vid_pullup = _session->config.get_video_pullup();
+
+		if (vid_pullup == 0.0) {
+			if (frames_lower_info_label->get_text () != _("none")) {
+				frames_lower_info_label->set_text(_("none"));
+			}
+		} else {
+			sprintf (buf, "%-6.4f", vid_pullup);
+			if (frames_lower_info_label->get_text() != buf) {
+				frames_lower_info_label->set_text (buf);
+			}
+		}
+	}
+}
 
 void
-AudioClock::set_minsec (jack_nframes_t when, bool force)
+AudioClock::set_minsec (nframes_t when, bool force)
 {
 	char buf[32];
-	jack_nframes_t left;
+	nframes_t left;
 	int hrs;
 	int mins;
 	float secs;
-	
+
 	left = when;
-	hrs = (int) floor (left / (session->frame_rate() * 60.0f * 60.0f));
-	left -= (jack_nframes_t) floor (hrs * session->frame_rate() * 60.0f * 60.0f);
-	mins = (int) floor (left / (session->frame_rate() * 60.0f));
-	left -= (jack_nframes_t) floor (mins * session->frame_rate() * 60.0f);
-	secs = left / (float) session->frame_rate();
+	hrs = (int) floor (left / (_session->frame_rate() * 60.0f * 60.0f));
+	left -= (nframes_t) floor (hrs * _session->frame_rate() * 60.0f * 60.0f);
+	mins = (int) floor (left / (_session->frame_rate() * 60.0f));
+	left -= (nframes_t) floor (mins * _session->frame_rate() * 60.0f);
+	secs = left / (float) _session->frame_rate();
 
 	if (force || hrs != ms_last_hrs) {
-		sprintf (buf, "%d", hrs);
+		sprintf (buf, "%02d", hrs);
 		ms_hours_label.set_text (buf);
 		ms_last_hrs = hrs;
 	}
 
 	if (force || mins != ms_last_mins) {
-		sprintf (buf, "%d", mins);
+		sprintf (buf, "%02d", mins);
 		ms_minutes_label.set_text (buf);
 		ms_last_mins = mins;
 	}
@@ -454,80 +563,187 @@ AudioClock::set_minsec (jack_nframes_t when, bool force)
 }
 
 void
-AudioClock::set_smpte (jack_nframes_t when, bool force)
+AudioClock::set_timecode (nframes_t when, bool force)
 {
 	char buf[32];
-	SMPTE::Time smpte;
-	
+	Timecode::Time timecode;
+
 	if (is_duration) {
-		session->smpte_duration (when, smpte);
+		_session->timecode_duration (when, timecode);
 	} else {
-		session->smpte_time (when, smpte);
+		_session->timecode_time (when, timecode);
 	}
 
-	if (force || smpte.hours != last_hrs || smpte.negative != last_negative) {
-		if (smpte.negative) {
-			sprintf (buf, "-%02" PRIu32, smpte.hours);
+	if (force || timecode.hours != last_hrs || timecode.negative != last_negative) {
+		if (timecode.negative) {
+			sprintf (buf, "-%02" PRIu32, timecode.hours);
 		} else {
-			sprintf (buf, " %02" PRIu32, smpte.hours);
+			sprintf (buf, " %02" PRIu32, timecode.hours);
 		}
 		hours_label.set_text (buf);
-		last_hrs = smpte.hours;
-		last_negative = smpte.negative;
+		last_hrs = timecode.hours;
+		last_negative = timecode.negative;
 	}
 
-	if (force || smpte.minutes != last_mins) {
-		sprintf (buf, "%02" PRIu32, smpte.minutes);
+	if (force || timecode.minutes != last_mins) {
+		sprintf (buf, "%02" PRIu32, timecode.minutes);
 		minutes_label.set_text (buf);
-		last_mins = smpte.minutes;
+		last_mins = timecode.minutes;
 	}
 
-	if (force || smpte.seconds != last_secs) {
-		sprintf (buf, "%02" PRIu32, smpte.seconds);
+	if (force || timecode.seconds != last_secs) {
+		sprintf (buf, "%02" PRIu32, timecode.seconds);
 		seconds_label.set_text (buf);
-		last_secs = smpte.seconds;
+		last_secs = timecode.seconds;
 	}
 
-	if (force || smpte.frames != last_frames) {
-		sprintf (buf, "%02" PRIu32, smpte.frames);
+	if (force || timecode.frames != last_frames) {
+		sprintf (buf, "%02" PRIu32, timecode.frames);
 		frames_label.set_text (buf);
-		last_frames = smpte.frames;
+		last_frames = timecode.frames;
+	}
+
+	if (timecode_upper_info_label) {
+		double timecode_frames = _session->timecode_frames_per_second();
+
+		if ( fmod(timecode_frames, 1.0) == 0.0) {
+			sprintf (buf, "%u", int (timecode_frames));
+		} else {
+			sprintf (buf, "%.2f", timecode_frames);
+		}
+
+		if (timecode_upper_info_label->get_text() != buf) {
+			timecode_upper_info_label->set_text (buf);
+		}
+
+		if ((fabs(timecode_frames - 29.97) < 0.0001) || timecode_frames == 30) {
+			if (_session->timecode_drop_frames()) {
+				sprintf (buf, "DF");
+			} else {
+				sprintf (buf, "NDF");
+			}
+		} else {
+			// there is no drop frame alternative
+			buf[0] = '\0';
+		}
+
+		if (timecode_lower_info_label->get_text() != buf) {
+			timecode_lower_info_label->set_text (buf);
+		}
 	}
 }
 
 void
-AudioClock::set_bbt (jack_nframes_t when, bool force)
+AudioClock::set_bbt (nframes_t when, bool force)
 {
 	char buf[16];
 	BBT_Time bbt;
 
-	session->tempo_map().bbt_time (when, bbt);
+	/* handle a common case */
+	if (is_duration) {
+		if (when == 0) {
+			bbt.bars = 0;
+			bbt.beats = 0;
+			bbt.ticks = 0;
+		} else {
+			_session->tempo_map().bbt_time (when, bbt);
+			bbt.bars--;
+			bbt.beats--;
+		}
+	} else {
+		_session->tempo_map().bbt_time (when, bbt);
+	}
+
 	sprintf (buf, "%03" PRIu32, bbt.bars);
-	bars_label.set_text (buf);
+	if (force || bars_label.get_text () != buf) {
+		bars_label.set_text (buf);
+	}
 	sprintf (buf, "%02" PRIu32, bbt.beats);
-	beats_label.set_text (buf);
+	if (force || beats_label.get_text () != buf) {
+		beats_label.set_text (buf);
+	}
 	sprintf (buf, "%04" PRIu32, bbt.ticks);
-	ticks_label.set_text (buf);
-	
-	if (meter_label) {
-		TempoMap::Metric m (session->tempo_map().metric_at (when));
+	if (force || ticks_label.get_text () != buf) {
+		ticks_label.set_text (buf);
+	}
+
+	if (bbt_upper_info_label) {
+		nframes64_t pos;
+
+		if (bbt_reference_time < 0) {
+			pos = when;
+		} else {
+			pos = bbt_reference_time;
+		}
+
+		TempoMetric m (_session->tempo_map().metric_at (pos));
+
 		sprintf (buf, "%-5.2f", m.tempo().beats_per_minute());
-		tempo_label->set_text (buf);
+		if (bbt_lower_info_label->get_text() != buf) {
+			bbt_lower_info_label->set_text (buf);
+		}
 		sprintf (buf, "%g|%g", m.meter().beats_per_bar(), m.meter().note_divisor());
-		meter_label->set_text (buf);
+		if (bbt_upper_info_label->get_text() != buf) {
+			bbt_upper_info_label->set_text (buf);
+		}
 	}
 }
 
 void
 AudioClock::set_session (Session *s)
 {
-	session = s;
+	SessionHandlePtr::set_session (s);
+
+	if (_session) {
+
+		XMLProperty* prop;
+		XMLNode* node = _session->extra_xml (X_("ClockModes"));
+		AudioClock::Mode amode;
+
+		if (node) {
+			if ((prop = node->property (_name)) != 0) {
+				amode = AudioClock::Mode (string_2_enum (prop->value(), amode));
+				set_mode (amode);
+			}
+		}
 
-	if (s) {
 		set (last_when, true);
 	}
 }
 
+void
+AudioClock::focus ()
+{
+	switch (_mode) {
+	case Timecode:
+		hours_ebox.grab_focus ();
+		break;
+
+	case BBT:
+		bars_ebox.grab_focus ();
+		break;
+
+	case MinSec:
+		ms_hours_ebox.grab_focus ();
+		break;
+
+	case Frames:
+		frames_ebox.grab_focus ();
+		break;
+
+	case Off:
+		break;
+	}
+}
+
+
+bool
+AudioClock::field_key_press_event (GdkEventKey */*ev*/, Field /*field*/)
+{
+	/* all key activity is handled on key release */
+	return true;
+}
+
 bool
 AudioClock::field_key_release_event (GdkEventKey *ev, Field field)
 {
@@ -537,16 +753,16 @@ AudioClock::field_key_release_event (GdkEventKey *ev, Field field)
 	bool move_on = false;
 
 	switch (field) {
-	case SMPTE_Hours:
+	case Timecode_Hours:
 		label = &hours_label;
 		break;
-	case SMPTE_Minutes:
+	case Timecode_Minutes:
 		label = &minutes_label;
 		break;
-	case SMPTE_Seconds:
+	case Timecode_Seconds:
 		label = &seconds_label;
 		break;
-	case SMPTE_Frames:
+	case Timecode_Frames:
 		label = &frames_label;
 		break;
 
@@ -574,7 +790,7 @@ AudioClock::field_key_release_event (GdkEventKey *ev, Field field)
 		label = &ticks_label;
 		break;
 	default:
-		return FALSE;
+		return false;
 	}
 
 	switch (ev->keyval) {
@@ -624,22 +840,24 @@ AudioClock::field_key_release_event (GdkEventKey *ev, Field field)
 		if (_mode == MinSec && field == MS_Seconds) {
 			new_char = '.';
 		} else {
-			return FALSE;
+			return false;
 		}
 		break;
 
+	case GDK_Tab:
 	case GDK_Return:
 	case GDK_KP_Enter:
-	case GDK_Tab:
 		move_on = true;
 		break;
 
 	case GDK_Escape:
+		key_entry_state = 0;
 		clock_base.grab_focus ();
-		return TRUE;
+		ChangeAborted();  /*  EMIT SIGNAL  */
+		return true;
 
 	default:
-		return FALSE;
+		return false;
 	}
 
 	if (!move_on) {
@@ -674,43 +892,55 @@ AudioClock::field_key_release_event (GdkEventKey *ev, Field field)
 	if (key_entry_state == field_length[field]) {
 		move_on = true;
 	}
-	
+
 	if (move_on) {
 
 		if (key_entry_state) {
-      
+
 			switch (field) {
-			case SMPTE_Hours:
-			case SMPTE_Minutes:
-			case SMPTE_Seconds:
-			case SMPTE_Frames:
-				// Check SMPTE fields for sanity (may also adjust fields)
-				smpte_sanitize_display();
+			case Timecode_Hours:
+			case Timecode_Minutes:
+			case Timecode_Seconds:
+			case Timecode_Frames:
+				// Check Timecode fields for sanity (may also adjust fields)
+				timecode_sanitize_display();
+				break;
+			case Bars:
+			case Beats:
+			case Ticks:
+				// Bars should never be, unless this clock is for a duration
+				if (atoi(bars_label.get_text()) == 0 && !is_duration) {
+					bars_label.set_text("001");
+				}
+				//  beats should never be 0, unless this clock is for a duration
+				if (atoi(beats_label.get_text()) == 0 && !is_duration) {
+					beats_label.set_text("01");
+				}
 				break;
 			default:
 				break;
 			}
-			
+
 			ValueChanged(); /* EMIT_SIGNAL */
 		}
-		
+
 		/* move on to the next field.
 		 */
-		
+
 		switch (field) {
-			
-			/* SMPTE */
-			
-		case SMPTE_Hours:
+
+			/* Timecode */
+
+		case Timecode_Hours:
 			minutes_ebox.grab_focus ();
 			break;
-		case SMPTE_Minutes:
+		case Timecode_Minutes:
 			seconds_ebox.grab_focus ();
 			break;
-		case SMPTE_Seconds:
+		case Timecode_Seconds:
 			frames_ebox.grab_focus ();
 			break;
-		case SMPTE_Frames:
+		case Timecode_Frames:
 			clock_base.grab_focus ();
 			break;
 
@@ -749,28 +979,37 @@ AudioClock::field_key_release_event (GdkEventKey *ev, Field field)
 
 	}
 
-	return TRUE;
+	//if user hit Enter, lose focus
+	switch (ev->keyval) {
+	case GDK_Return:
+	case GDK_KP_Enter:
+		clock_base.grab_focus ();
+	}
+
+	return true;
 }
 
 bool
-AudioClock::field_focus_in_event (GdkEventFocus *ev, Field field)
+AudioClock::field_focus_in_event (GdkEventFocus */*ev*/, Field field)
 {
 	key_entry_state = 0;
 
+	Keyboard::magic_widget_grab_focus ();
+
 	switch (field) {
-	case SMPTE_Hours:
+	case Timecode_Hours:
 		hours_ebox.set_flags (Gtk::HAS_FOCUS);
 		hours_ebox.set_state (Gtk::STATE_ACTIVE);
 		break;
-	case SMPTE_Minutes:
+	case Timecode_Minutes:
 		minutes_ebox.set_flags (Gtk::HAS_FOCUS);
 		minutes_ebox.set_state (Gtk::STATE_ACTIVE);
 		break;
-	case SMPTE_Seconds:
+	case Timecode_Seconds:
 		seconds_ebox.set_flags (Gtk::HAS_FOCUS);
 		seconds_ebox.set_state (Gtk::STATE_ACTIVE);
 		break;
-	case SMPTE_Frames:
+	case Timecode_Frames:
 		frames_ebox.set_flags (Gtk::HAS_FOCUS);
 		frames_ebox.set_state (Gtk::STATE_ACTIVE);
 		break;
@@ -806,27 +1045,27 @@ AudioClock::field_focus_in_event (GdkEventFocus *ev, Field field)
 		break;
 	}
 
-	return FALSE;
+	return false;
 }
 
 bool
-AudioClock::field_focus_out_event (GdkEventFocus *ev, Field field)
+AudioClock::field_focus_out_event (GdkEventFocus */*ev*/, Field field)
 {
 	switch (field) {
 
-	case SMPTE_Hours:
+	case Timecode_Hours:
 		hours_ebox.unset_flags (Gtk::HAS_FOCUS);
 		hours_ebox.set_state (Gtk::STATE_NORMAL);
 		break;
-	case SMPTE_Minutes:
+	case Timecode_Minutes:
 		minutes_ebox.unset_flags (Gtk::HAS_FOCUS);
 		minutes_ebox.set_state (Gtk::STATE_NORMAL);
 		break;
-	case SMPTE_Seconds:
+	case Timecode_Seconds:
 		seconds_ebox.unset_flags (Gtk::HAS_FOCUS);
 		seconds_ebox.set_state (Gtk::STATE_NORMAL);
 		break;
-	case SMPTE_Frames:
+	case Timecode_Frames:
 		frames_ebox.unset_flags (Gtk::HAS_FOCUS);
 		frames_ebox.set_state (Gtk::STATE_NORMAL);
 		break;
@@ -863,21 +1102,21 @@ AudioClock::field_focus_out_event (GdkEventFocus *ev, Field field)
 		break;
 	}
 
-	return FALSE;
+	Keyboard::magic_widget_drop_focus ();
+
+	return false;
 }
 
 bool
 AudioClock::field_button_release_event (GdkEventButton *ev, Field field)
 {
-
-
 	if (dragging) {
-		gdk_pointer_ungrab(GDK_CURRENT_TIME);
+		cerr << "button event on clock but we are dragging\n";
+		gdk_pointer_ungrab (GDK_CURRENT_TIME);
 		dragging = false;
-		if (ev->y > drag_start_y+1 || ev->y < drag_start_y-1 || Keyboard::modifier_state_equals (ev->state, Keyboard::Shift)){
-                  // we actually dragged so return without setting editing focus, or we shift clicked
-
-			return TRUE;
+		if (ev->y > drag_start_y+1 || ev->y < drag_start_y-1 || Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)){
+			// we actually dragged so return without setting editing focus, or we shift clicked
+			return true;
 		}
 	}
 
@@ -886,37 +1125,38 @@ AudioClock::field_button_release_event (GdkEventButton *ev, Field field)
 			build_ops_menu ();
 		}
 		ops_menu->popup (1, ev->time);
-		return TRUE;
+		return true;
 	}
 
 	if (Keyboard::is_context_menu_event (ev)) {
+		cerr << "Context menu event on clock\n";
 		if (ops_menu == 0) {
 			build_ops_menu ();
 		}
 		ops_menu->popup (1, ev->time);
-		return TRUE;
-	} 
+		return true;
+	}
 
 	switch (ev->button) {
 	case 1:
 		switch (field) {
-		case SMPTE_Hours:
+		case Timecode_Hours:
 			hours_ebox.grab_focus();
 			break;
-		case SMPTE_Minutes:
+		case Timecode_Minutes:
 			minutes_ebox.grab_focus();
 			break;
-		case SMPTE_Seconds:
+		case Timecode_Seconds:
 			seconds_ebox.grab_focus();
 			break;
-		case SMPTE_Frames:
+		case Timecode_Frames:
 			frames_ebox.grab_focus();
 			break;
 
 		case AudioFrames:
 			audio_frames_ebox.grab_focus();
 			break;
-			
+
 		case MS_Hours:
 			ms_hours_ebox.grab_focus();
 			break;
@@ -926,7 +1166,7 @@ AudioClock::field_button_release_event (GdkEventButton *ev, Field field)
 		case MS_Seconds:
 			ms_seconds_ebox.grab_focus();
 			break;
-			
+
 		case Bars:
 			bars_ebox.grab_focus ();
 			break;
@@ -938,31 +1178,33 @@ AudioClock::field_button_release_event (GdkEventButton *ev, Field field)
 			break;
 		}
 		break;
-		
+
 	default:
 		break;
 	}
 
-	return TRUE;
+	return true;
 }
 
 bool
-AudioClock::field_button_press_event (GdkEventButton *ev, Field field)
+AudioClock::field_button_press_event (GdkEventButton *ev, Field /*field*/)
 {
-	if (session == 0) return FALSE;
+	if (_session == 0) {
+		return false;
+	}
 
-	jack_nframes_t frames = 0;
+	nframes_t frames = 0;
 
 	switch (ev->button) {
 	case 1:
-		if (Keyboard::modifier_state_equals (ev->state, Keyboard::Shift)) {
+		if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
 			set (frames, true);
 			ValueChanged (); /* EMIT_SIGNAL */
 					}
-	
+
                 /* make absolutely sure that the pointer is grabbed */
-		gdk_pointer_grab(ev->window,FALSE ,
-				 GdkEventMask( Gdk::POINTER_MOTION_MASK | Gdk::BUTTON_PRESS_MASK |Gdk::BUTTON_RELEASE_MASK), 
+		gdk_pointer_grab(ev->window,false ,
+				 GdkEventMask( Gdk::POINTER_MOTION_MASK | Gdk::BUTTON_PRESS_MASK |Gdk::BUTTON_RELEASE_MASK),
 				 NULL,NULL,ev->time);
 		dragging = true;
 		drag_accum = 0;
@@ -971,7 +1213,7 @@ AudioClock::field_button_press_event (GdkEventButton *ev, Field field)
 		break;
 
 	case 2:
-		if (Keyboard::modifier_state_equals (ev->state, Keyboard::Shift)) {
+		if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
 			set (frames, true);
 			ValueChanged (); /* EMIT_SIGNAL */
 		}
@@ -979,63 +1221,32 @@ AudioClock::field_button_press_event (GdkEventButton *ev, Field field)
 
 	case 3:
 		/* used for context sensitive menu */
-		return FALSE;
-		break;
-
-	case 4:
-		if (Keyboard::modifier_state_equals (ev->state, Keyboard::Shift)) {
-			frames = get_frames (field);
-			if (frames != 0) {
-				if (Keyboard::modifier_state_equals (ev->state, Keyboard::Control)) {
-					frames *= 10;
-				}
-				set (current_time() + frames, true);
-				 ValueChanged (); /* EMIT_SIGNAL */
-			}
-		}
-		break;
-
-	case 5:
-		if (Keyboard::modifier_state_equals (ev->state, Keyboard::Shift)) {
-			frames = get_frames (field);
-			if (frames != 0) {
-				if (Keyboard::modifier_state_equals (ev->state, Keyboard::Control)) {
-					frames *= 10;
-				}
-
-				if ((double)current_time() - (double)frames < 0.0) {
-					set (0, true);
-				}
-				else {
-					set (current_time() - frames, true);
-				}
-				
-				 ValueChanged (); /* EMIT_SIGNAL */
-			}
-		}
+		return false;
 		break;
 
 	default:
-		return FALSE;
+		return false;
 		break;
 	}
-	
-	return TRUE;
+
+	return true;
 }
 
 bool
 AudioClock::field_button_scroll_event (GdkEventScroll *ev, Field field)
 {
-	if (session == 0) return FALSE;
+	if (_session == 0) {
+		return false;
+	}
 
-	jack_nframes_t frames = 0;
+	nframes_t frames = 0;
 
 	switch (ev->direction) {
 
 	case GDK_SCROLL_UP:
 	       frames = get_frames (field);
 	       if (frames != 0) {
-		      if (Keyboard::modifier_state_equals (ev->state, Keyboard::Control)) {
+		      if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
 			     frames *= 10;
 		      }
 		      set (current_time() + frames, true);
@@ -1046,45 +1257,45 @@ AudioClock::field_button_scroll_event (GdkEventScroll *ev, Field field)
 	case GDK_SCROLL_DOWN:
 	       frames = get_frames (field);
 	       if (frames != 0) {
-		      if (Keyboard::modifier_state_equals (ev->state, Keyboard::Control)) {
+		      if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
 			     frames *= 10;
 		      }
-		      
+
 		      if ((double)current_time() - (double)frames < 0.0) {
 			     set (0, true);
 		      } else {
 			     set (current_time() - frames, true);
 		      }
-		      
+
 		      ValueChanged (); /* EMIT_SIGNAL */
 	       }
 	       break;
 
 	default:
-		return FALSE;
+		return false;
 		break;
 	}
-	
-	return TRUE;
+
+	return true;
 }
 
 bool
 AudioClock::field_motion_notify_event (GdkEventMotion *ev, Field field)
 {
-	if (session == 0 || !dragging) {
-		return FALSE;
+	if (_session == 0 || !dragging) {
+		return false;
 	}
-	
+
 	float pixel_frame_scale_factor = 0.2f;
 
 /*
-	if (Keyboard::modifier_state_equals (ev->state, Keyboard::Control))  {
+	if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier))  {
 		pixel_frame_scale_factor = 0.1f;
 	}
 
 
-	if (Keyboard::modifier_state_contains (ev->state, 
-					       Keyboard::Control|Keyboard::Alt)) {
+	if (Keyboard::modifier_state_contains (ev->state,
+					       Keyboard::PrimaryModifier|Keyboard::SecondaryModifier)) {
 
 		pixel_frame_scale_factor = 0.025f;
 	}
@@ -1097,49 +1308,49 @@ AudioClock::field_motion_notify_event (GdkEventMotion *ev, Field field)
 
 	if (trunc(drag_accum) != 0) {
 
-		jack_nframes_t frames;
-		jack_nframes_t pos ;
+		nframes_t frames;
+		nframes_t pos ;
 		int dir;
 		dir = (drag_accum < 0 ? 1:-1);
 		pos = current_time();
 		frames = get_frames (field,pos,dir);
-		
+
 		if (frames  != 0 &&  frames * drag_accum < current_time()) {
-		
-			set ((jack_nframes_t) floor (pos - drag_accum * frames), false); // minus because up is negative in computer-land
-		
+
+			set ((nframes_t) floor (pos - drag_accum * frames), false); // minus because up is negative in computer-land
+
 		} else {
 			set (0 , false);
-		
+
  		}
 
 	       	drag_accum= 0;
-		ValueChanged();	 /* EMIT_SIGNAL */	
-		
+		ValueChanged();	 /* EMIT_SIGNAL */
+
 
 	}
 
-	return TRUE;
+	return true;
 }
 
-jack_nframes_t
-AudioClock::get_frames (Field field,jack_nframes_t pos,int dir)
+nframes_t
+AudioClock::get_frames (Field field,nframes_t pos,int dir)
 {
 
-	jack_nframes_t frames = 0;
+	nframes_t frames = 0;
 	BBT_Time bbt;
 	switch (field) {
-	case SMPTE_Hours:
-		frames = (jack_nframes_t) floor (3600.0 * session->frame_rate());
+	case Timecode_Hours:
+		frames = (nframes_t) floor (3600.0 * _session->frame_rate());
 		break;
-	case SMPTE_Minutes:
-		frames = (jack_nframes_t) floor (60.0 * session->frame_rate());
+	case Timecode_Minutes:
+		frames = (nframes_t) floor (60.0 * _session->frame_rate());
 		break;
-	case SMPTE_Seconds:
-		frames = session->frame_rate();
+	case Timecode_Seconds:
+		frames = _session->frame_rate();
 		break;
-	case SMPTE_Frames:
-		frames = (jack_nframes_t) floor (session->frame_rate() / session->smpte_frames_per_second);
+	case Timecode_Frames:
+		frames = (nframes_t) floor (_session->frame_rate() / _session->timecode_frames_per_second());
 		break;
 
 	case AudioFrames:
@@ -1147,46 +1358,46 @@ AudioClock::get_frames (Field field,jack_nframes_t pos,int dir)
 		break;
 
 	case MS_Hours:
-		frames = (jack_nframes_t) floor (3600.0 * session->frame_rate());
+		frames = (nframes_t) floor (3600.0 * _session->frame_rate());
 		break;
 	case MS_Minutes:
-		frames = (jack_nframes_t) floor (60.0 * session->frame_rate());
+		frames = (nframes_t) floor (60.0 * _session->frame_rate());
 		break;
 	case MS_Seconds:
-		frames = session->frame_rate();
+		frames = _session->frame_rate();
 		break;
 
 	case Bars:
 		bbt.bars = 1;
 		bbt.beats = 0;
 		bbt.ticks = 0;
-		frames = session->tempo_map().bbt_duration_at(pos,bbt,dir);
+		frames = _session->tempo_map().bbt_duration_at(pos,bbt,dir);
 		break;
 	case Beats:
 		bbt.bars = 0;
 		bbt.beats = 1;
 		bbt.ticks = 0;
-		frames = session->tempo_map().bbt_duration_at(pos,bbt,dir);
+		frames = _session->tempo_map().bbt_duration_at(pos,bbt,dir);
 		break;
 	case Ticks:
 		bbt.bars = 0;
 		bbt.beats = 0;
 		bbt.ticks = 1;
-		frames = session->tempo_map().bbt_duration_at(pos,bbt,dir);
+		frames = _session->tempo_map().bbt_duration_at(pos,bbt,dir);
 		break;
 	}
 
 	return frames;
 }
 
-jack_nframes_t
-AudioClock::current_time (jack_nframes_t pos) const
+nframes_t
+AudioClock::current_time (nframes_t pos) const
 {
-	jack_nframes_t ret = 0;
+	nframes_t ret = 0;
 
 	switch (_mode) {
-	case SMPTE:
-		ret = smpte_frame_from_display ();
+	case Timecode:
+		ret = timecode_frame_from_display ();
 		break;
 	case BBT:
 		ret = bbt_frame_from_display (pos);
@@ -1207,14 +1418,14 @@ AudioClock::current_time (jack_nframes_t pos) const
 	return ret;
 }
 
-jack_nframes_t
-AudioClock::current_duration (jack_nframes_t pos) const
+nframes_t
+AudioClock::current_duration (nframes_t pos) const
 {
-	jack_nframes_t ret = 0;
+	nframes_t ret = 0;
 
 	switch (_mode) {
-	case SMPTE:
-		ret = smpte_frame_from_display ();
+	case Timecode:
+		ret = timecode_frame_from_display ();
 		break;
 	case BBT:
 		ret = bbt_frame_duration_from_display (pos);
@@ -1236,18 +1447,18 @@ AudioClock::current_duration (jack_nframes_t pos) const
 }
 
 void
-AudioClock::smpte_sanitize_display()
+AudioClock::timecode_sanitize_display()
 {
-	// Check SMPTE fields for sanity, possibly adjusting values
+	// Check Timecode fields for sanity, possibly adjusting values
 	if (atoi(minutes_label.get_text()) > 59) {
 		minutes_label.set_text("59");
 	}
-	
+
 	if (atoi(seconds_label.get_text()) > 59) {
 		seconds_label.set_text("59");
 	}
-	
-	switch ((long)rint(session->smpte_frames_per_second)) {
+
+	switch ((long)rint(_session->timecode_frames_per_second())) {
 	case 24:
 		if (atoi(frames_label.get_text()) > 23) {
 			frames_label.set_text("23");
@@ -1266,409 +1477,411 @@ AudioClock::smpte_sanitize_display()
 	default:
 		break;
 	}
-	
-	if (session->smpte_drop_frames) {
+
+	if (_session->timecode_drop_frames()) {
 		if ((atoi(minutes_label.get_text()) % 10) && (atoi(seconds_label.get_text()) == 0) && (atoi(frames_label.get_text()) < 2)) {
 			frames_label.set_text("02");
 		}
 	}
 }
 
-jack_nframes_t
-AudioClock::smpte_frame_from_display () const
+nframes_t
+AudioClock::timecode_frame_from_display () const
 {
-	if (session == 0) {
+	if (_session == 0) {
 		return 0;
 	}
-	
-	SMPTE::Time smpte;
-	jack_nframes_t sample;
-	
-	smpte.hours = atoi (hours_label.get_text());
-	smpte.minutes = atoi (minutes_label.get_text());
-	smpte.seconds = atoi (seconds_label.get_text());
-	smpte.frames = atoi (frames_label.get_text());
 
-	session->smpte_to_sample( smpte, sample, false /* use_offset */, false /* use_subframes */ );
-	
+	Timecode::Time timecode;
+	nframes_t sample;
+
+	timecode.hours = atoi (hours_label.get_text());
+	timecode.minutes = atoi (minutes_label.get_text());
+	timecode.seconds = atoi (seconds_label.get_text());
+	timecode.frames = atoi (frames_label.get_text());
+	timecode.rate = _session->timecode_frames_per_second();
+	timecode.drop= _session->timecode_drop_frames();
+
+	_session->timecode_to_sample( timecode, sample, false /* use_offset */, false /* use_subframes */ );
+
 
 #if 0
-#define SMPTE_SAMPLE_TEST_1
-#define SMPTE_SAMPLE_TEST_2
-#define SMPTE_SAMPLE_TEST_3
-#define SMPTE_SAMPLE_TEST_4
-#define SMPTE_SAMPLE_TEST_5
-#define SMPTE_SAMPLE_TEST_6
-#define SMPTE_SAMPLE_TEST_7
-
-	// Testcode for smpte<->sample conversions (P.S.)
-	SMPTE::Time smpte1;
-	jack_nframes_t sample1;
-	jack_nframes_t oldsample = 0;
-	SMPTE::Time smpte2;
-	jack_nframes_t sample_increment;
-
-	sample_increment = (long)rint(session->frame_rate() / session->smpte_frames_per_second);
-
-#ifdef SMPTE_SAMPLE_TEST_1
+#define Timecode_SAMPLE_TEST_1
+#define Timecode_SAMPLE_TEST_2
+#define Timecode_SAMPLE_TEST_3
+#define Timecode_SAMPLE_TEST_4
+#define Timecode_SAMPLE_TEST_5
+#define Timecode_SAMPLE_TEST_6
+#define Timecode_SAMPLE_TEST_7
+
+	// Testcode for timecode<->sample conversions (P.S.)
+	Timecode::Time timecode1;
+	nframes_t sample1;
+	nframes_t oldsample = 0;
+	Timecode::Time timecode2;
+	nframes_t sample_increment;
+
+	sample_increment = (long)rint(_session->frame_rate() / _session->timecode_frames_per_second);
+
+#ifdef Timecode_SAMPLE_TEST_1
 	// Test 1: use_offset = false, use_subframes = false
 	cout << "use_offset = false, use_subframes = false" << endl;
 	for (int i = 0; i < 108003; i++) {
-		session->smpte_to_sample( smpte1, sample1, false /* use_offset */, false /* use_subframes */ );
-		session->sample_to_smpte( sample1, smpte2, false /* use_offset */, false /* use_subframes */ );
+		_session->timecode_to_sample( timecode1, sample1, false /* use_offset */, false /* use_subframes */ );
+		_session->sample_to_timecode( sample1, timecode2, false /* use_offset */, false /* use_subframes */ );
 
 		if ((i > 0) && ( ((sample1 - oldsample) != sample_increment) && ((sample1 - oldsample) != (sample_increment + 1)) && ((sample1 - oldsample) != (sample_increment - 1)))) {
 			cout << "ERROR: sample increment not right: " << (sample1 - oldsample) << " != " << sample_increment << endl;
-			cout << "smpte1: " << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << " -> ";
+			cout << "timecode1: " << timecode1.hours << ":" << timecode1.minutes << ":" << timecode1.seconds << ":" << timecode1.frames << "::" << timecode1.subframes << " -> ";
 			cout << "sample: " << sample1 << endl;
 			cout << "sample: " << sample1 << " -> ";
-			cout << "smpte2: " << smpte2.hours << ":" << smpte2.minutes << ":" << smpte2.seconds << ":" << smpte2.frames << "::" << smpte2.subframes << endl;
+			cout << "timecode2: " << timecode2.hours << ":" << timecode2.minutes << ":" << timecode2.seconds << ":" << timecode2.frames << "::" << timecode2.subframes << endl;
 			break;
 		}
-    
-		if (smpte2.hours != smpte1.hours || smpte2.minutes != smpte1.minutes || smpte2.seconds != smpte2.seconds || smpte2.frames != smpte1.frames) {
-			cout << "ERROR: smpte2 not equal smpte1" << endl;
-			cout << "smpte1: " << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << " -> ";
+
+		if (timecode2.hours != timecode1.hours || timecode2.minutes != timecode1.minutes || timecode2.seconds != timecode2.seconds || timecode2.frames != timecode1.frames) {
+			cout << "ERROR: timecode2 not equal timecode1" << endl;
+			cout << "timecode1: " << timecode1.hours << ":" << timecode1.minutes << ":" << timecode1.seconds << ":" << timecode1.frames << "::" << timecode1.subframes << " -> ";
 			cout << "sample: " << sample1 << endl;
 			cout << "sample: " << sample1 << " -> ";
-			cout << "smpte2: " << smpte2.hours << ":" << smpte2.minutes << ":" << smpte2.seconds << ":" << smpte2.frames << "::" << smpte2.subframes << endl;
+			cout << "timecode2: " << timecode2.hours << ":" << timecode2.minutes << ":" << timecode2.seconds << ":" << timecode2.frames << "::" << timecode2.subframes << endl;
 			break;
 		}
 		oldsample = sample1;
-		session->smpte_increment( smpte1 );
+		_session->timecode_increment( timecode1 );
 	}
 
 	cout << "sample_increment: " << sample_increment << endl;
 	cout << "sample: " << sample1 << " -> ";
-	cout << "smpte: " << smpte2.hours << ":" << smpte2.minutes << ":" << smpte2.seconds << ":" << smpte2.frames << "::" << smpte2.subframes << endl;
+	cout << "timecode: " << timecode2.hours << ":" << timecode2.minutes << ":" << timecode2.seconds << ":" << timecode2.frames << "::" << timecode2.subframes << endl;
 #endif
 
-#ifdef SMPTE_SAMPLE_TEST_2
+#ifdef Timecode_SAMPLE_TEST_2
 	// Test 2: use_offset = true, use_subframes = false
 	cout << "use_offset = true, use_subframes = false" << endl;
-  
-	smpte1.hours = 0;
-	smpte1.minutes = 0;
-	smpte1.seconds = 0;
-	smpte1.frames = 0;
-	smpte1.subframes = 0;
+
+	timecode1.hours = 0;
+	timecode1.minutes = 0;
+	timecode1.seconds = 0;
+	timecode1.frames = 0;
+	timecode1.subframes = 0;
 	sample1 = oldsample = 0;
 
-	session->sample_to_smpte( sample1, smpte1, true /* use_offset */, false /* use_subframes */ );
+	_session->sample_to_timecode( sample1, timecode1, true /* use_offset */, false /* use_subframes */ );
 	cout << "Starting at sample: " << sample1 << " -> ";
-	cout << "smpte: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << endl;
+	cout << "timecode: " << (timecode1.negative ? "-" : "") << timecode1.hours << ":" << timecode1.minutes << ":" << timecode1.seconds << ":" << timecode1.frames << "::" << timecode1.subframes << endl;
 
 	for (int i = 0; i < 108003; i++) {
-		session->smpte_to_sample( smpte1, sample1, true /* use_offset */, false /* use_subframes */ );
-		session->sample_to_smpte( sample1, smpte2, true /* use_offset */, false /* use_subframes */ );
+		_session->timecode_to_sample( timecode1, sample1, true /* use_offset */, false /* use_subframes */ );
+		_session->sample_to_timecode( sample1, timecode2, true /* use_offset */, false /* use_subframes */ );
 
-//     cout << "smpte: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << " -> ";
+//     cout << "timecode: " << (timecode1.negative ? "-" : "") << timecode1.hours << ":" << timecode1.minutes << ":" << timecode1.seconds << ":" << timecode1.frames << "::" << timecode1.subframes << " -> ";
 //     cout << "sample: " << sample1 << endl;
 //     cout << "sample: " << sample1 << " -> ";
-//     cout << "smpte: " << (smpte2.negative ? "-" : "") << smpte2.hours << ":" << smpte2.minutes << ":" << smpte2.seconds << ":" << smpte2.frames << "::" << smpte2.subframes << endl;
-    
+//     cout << "timecode: " << (timecode2.negative ? "-" : "") << timecode2.hours << ":" << timecode2.minutes << ":" << timecode2.seconds << ":" << timecode2.frames << "::" << timecode2.subframes << endl;
+
 		if ((i > 0) && ( ((sample1 - oldsample) != sample_increment) && ((sample1 - oldsample) != (sample_increment + 1)) && ((sample1 - oldsample) != (sample_increment - 1)))) {
 			cout << "ERROR: sample increment not right: " << (sample1 - oldsample) << " != " << sample_increment << endl;
-			cout << "smpte1: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << " -> ";
+			cout << "timecode1: " << (timecode1.negative ? "-" : "") << timecode1.hours << ":" << timecode1.minutes << ":" << timecode1.seconds << ":" << timecode1.frames << "::" << timecode1.subframes << " -> ";
 			cout << "sample: " << sample1 << endl;
 			cout << "sample: " << sample1 << " -> ";
-			cout << "smpte2: " << (smpte2.negative ? "-" : "") << smpte2.hours << ":" << smpte2.minutes << ":" << smpte2.seconds << ":" << smpte2.frames << "::" << smpte2.subframes << endl;
+			cout << "timecode2: " << (timecode2.negative ? "-" : "") << timecode2.hours << ":" << timecode2.minutes << ":" << timecode2.seconds << ":" << timecode2.frames << "::" << timecode2.subframes << endl;
 			break;
 		}
-    
-		if (smpte2.hours != smpte1.hours || smpte2.minutes != smpte1.minutes || smpte2.seconds != smpte2.seconds || smpte2.frames != smpte1.frames) {
-			cout << "ERROR: smpte2 not equal smpte1" << endl;
-			cout << "smpte1: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << " -> ";
+
+		if (timecode2.hours != timecode1.hours || timecode2.minutes != timecode1.minutes || timecode2.seconds != timecode2.seconds || timecode2.frames != timecode1.frames) {
+			cout << "ERROR: timecode2 not equal timecode1" << endl;
+			cout << "timecode1: " << (timecode1.negative ? "-" : "") << timecode1.hours << ":" << timecode1.minutes << ":" << timecode1.seconds << ":" << timecode1.frames << "::" << timecode1.subframes << " -> ";
 			cout << "sample: " << sample1 << endl;
 			cout << "sample: " << sample1 << " -> ";
-			cout << "smpte2: " << (smpte2.negative ? "-" : "") << smpte2.hours << ":" << smpte2.minutes << ":" << smpte2.seconds << ":" << smpte2.frames << "::" << smpte2.subframes << endl;
+			cout << "timecode2: " << (timecode2.negative ? "-" : "") << timecode2.hours << ":" << timecode2.minutes << ":" << timecode2.seconds << ":" << timecode2.frames << "::" << timecode2.subframes << endl;
 			break;
 		}
 		oldsample = sample1;
-		session->smpte_increment( smpte1 );
+		_session->timecode_increment( timecode1 );
 	}
 
 	cout << "sample_increment: " << sample_increment << endl;
 	cout << "sample: " << sample1 << " -> ";
-	cout << "smpte: " << (smpte2.negative ? "-" : "") << smpte2.hours << ":" << smpte2.minutes << ":" << smpte2.seconds << ":" << smpte2.frames << "::" << smpte2.subframes << endl;
+	cout << "timecode: " << (timecode2.negative ? "-" : "") << timecode2.hours << ":" << timecode2.minutes << ":" << timecode2.seconds << ":" << timecode2.frames << "::" << timecode2.subframes << endl;
 #endif
 
-#ifdef SMPTE_SAMPLE_TEST_3
+#ifdef Timecode_SAMPLE_TEST_3
 	// Test 3: use_offset = true, use_subframes = false, decrement
-	cout << "use_offset = true, use_subframes = false, decrement" << endl;  
+	cout << "use_offset = true, use_subframes = false, decrement" << endl;
 
-	session->sample_to_smpte( sample1, smpte1, true /* use_offset */, false /* use_subframes */ );
+	_session->sample_to_timecode( sample1, timecode1, true /* use_offset */, false /* use_subframes */ );
 	cout << "Starting at sample: " << sample1 << " -> ";
-	cout << "smpte: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << endl;
+	cout << "timecode: " << (timecode1.negative ? "-" : "") << timecode1.hours << ":" << timecode1.minutes << ":" << timecode1.seconds << ":" << timecode1.frames << "::" << timecode1.subframes << endl;
 
 	for (int i = 0; i < 108003; i++) {
-		session->smpte_to_sample( smpte1, sample1, true /* use_offset */, false /* use_subframes */ );
-		session->sample_to_smpte( sample1, smpte2, true /* use_offset */, false /* use_subframes */ );
+		_session->timecode_to_sample( timecode1, sample1, true /* use_offset */, false /* use_subframes */ );
+		_session->sample_to_timecode( sample1, timecode2, true /* use_offset */, false /* use_subframes */ );
 
-//     cout << "smpte: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << " -> ";
+//     cout << "timecode: " << (timecode1.negative ? "-" : "") << timecode1.hours << ":" << timecode1.minutes << ":" << timecode1.seconds << ":" << timecode1.frames << "::" << timecode1.subframes << " -> ";
 //     cout << "sample: " << sample1 << endl;
 //     cout << "sample: " << sample1 << " -> ";
-//     cout << "smpte: " << (smpte2.negative ? "-" : "") << smpte2.hours << ":" << smpte2.minutes << ":" << smpte2.seconds << ":" << smpte2.frames << "::" << smpte2.subframes << endl;
-    
+//     cout << "timecode: " << (timecode2.negative ? "-" : "") << timecode2.hours << ":" << timecode2.minutes << ":" << timecode2.seconds << ":" << timecode2.frames << "::" << timecode2.subframes << endl;
+
 		if ((i > 0) && ( ((oldsample - sample1) != sample_increment) && ((oldsample - sample1) != (sample_increment + 1)) && ((oldsample - sample1) != (sample_increment - 1)))) {
 			cout << "ERROR: sample increment not right: " << (oldsample - sample1) << " != " << sample_increment << endl;
-			cout << "smpte1: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << " -> ";
+			cout << "timecode1: " << (timecode1.negative ? "-" : "") << timecode1.hours << ":" << timecode1.minutes << ":" << timecode1.seconds << ":" << timecode1.frames << "::" << timecode1.subframes << " -> ";
 			cout << "sample: " << sample1 << endl;
 			cout << "sample: " << sample1 << " -> ";
-			cout << "smpte2: " << (smpte2.negative ? "-" : "") << smpte2.hours << ":" << smpte2.minutes << ":" << smpte2.seconds << ":" << smpte2.frames << "::" << smpte2.subframes << endl;
+			cout << "timecode2: " << (timecode2.negative ? "-" : "") << timecode2.hours << ":" << timecode2.minutes << ":" << timecode2.seconds << ":" << timecode2.frames << "::" << timecode2.subframes << endl;
 			break;
 		}
-    
-		if (smpte2.hours != smpte1.hours || smpte2.minutes != smpte1.minutes || smpte2.seconds != smpte2.seconds || smpte2.frames != smpte1.frames) {
-			cout << "ERROR: smpte2 not equal smpte1" << endl;
-			cout << "smpte1: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << " -> ";
+
+		if (timecode2.hours != timecode1.hours || timecode2.minutes != timecode1.minutes || timecode2.seconds != timecode2.seconds || timecode2.frames != timecode1.frames) {
+			cout << "ERROR: timecode2 not equal timecode1" << endl;
+			cout << "timecode1: " << (timecode1.negative ? "-" : "") << timecode1.hours << ":" << timecode1.minutes << ":" << timecode1.seconds << ":" << timecode1.frames << "::" << timecode1.subframes << " -> ";
 			cout << "sample: " << sample1 << endl;
 			cout << "sample: " << sample1 << " -> ";
-			cout << "smpte2: " << (smpte2.negative ? "-" : "") << smpte2.hours << ":" << smpte2.minutes << ":" << smpte2.seconds << ":" << smpte2.frames << "::" << smpte2.subframes << endl;
+			cout << "timecode2: " << (timecode2.negative ? "-" : "") << timecode2.hours << ":" << timecode2.minutes << ":" << timecode2.seconds << ":" << timecode2.frames << "::" << timecode2.subframes << endl;
 			break;
 		}
 		oldsample = sample1;
-		session->smpte_decrement( smpte1 );
+		_session->timecode_decrement( timecode1 );
 	}
 
 	cout << "sample_decrement: " << sample_increment << endl;
 	cout << "sample: " << sample1 << " -> ";
-	cout << "smpte: " << (smpte2.negative ? "-" : "") << smpte2.hours << ":" << smpte2.minutes << ":" << smpte2.seconds << ":" << smpte2.frames << "::" << smpte2.subframes << endl;
+	cout << "timecode: " << (timecode2.negative ? "-" : "") << timecode2.hours << ":" << timecode2.minutes << ":" << timecode2.seconds << ":" << timecode2.frames << "::" << timecode2.subframes << endl;
 #endif
 
 
-#ifdef SMPTE_SAMPLE_TEST_4
+#ifdef Timecode_SAMPLE_TEST_4
 	// Test 4: use_offset = true, use_subframes = true
 	cout << "use_offset = true, use_subframes = true" << endl;
-  
+
 	for (long sub = 5; sub < 80; sub += 5) {
-		smpte1.hours = 0;
-		smpte1.minutes = 0;
-		smpte1.seconds = 0;
-		smpte1.frames = 0;
-		smpte1.subframes = 0;
+		timecode1.hours = 0;
+		timecode1.minutes = 0;
+		timecode1.seconds = 0;
+		timecode1.frames = 0;
+		timecode1.subframes = 0;
 		sample1 = oldsample = (sample_increment * sub) / 80;
-    
-		session->sample_to_smpte( sample1, smpte1, true /* use_offset */, true /* use_subframes */ );
-    
+
+		_session->sample_to_timecode( sample1, timecode1, true /* use_offset */, true /* use_subframes */ );
+
 		cout << "starting at sample: " << sample1 << " -> ";
-		cout << "smpte: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << endl;
-    
+		cout << "timecode: " << (timecode1.negative ? "-" : "") << timecode1.hours << ":" << timecode1.minutes << ":" << timecode1.seconds << ":" << timecode1.frames << "::" << timecode1.subframes << endl;
+
 		for (int i = 0; i < 108003; i++) {
-			session->smpte_to_sample( smpte1, sample1, true /* use_offset */, true /* use_subframes */ );
-			session->sample_to_smpte( sample1, smpte2, true /* use_offset */, true /* use_subframes */ );
-      
+			_session->timecode_to_sample( timecode1, sample1, true /* use_offset */, true /* use_subframes */ );
+			_session->sample_to_timecode( sample1, timecode2, true /* use_offset */, true /* use_subframes */ );
+
 			if ((i > 0) && ( ((sample1 - oldsample) != sample_increment) && ((sample1 - oldsample) != (sample_increment + 1)) && ((sample1 - oldsample) != (sample_increment - 1)))) {
 				cout << "ERROR: sample increment not right: " << (sample1 - oldsample) << " != " << sample_increment << endl;
-				cout << "smpte1: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << " -> ";
+				cout << "timecode1: " << (timecode1.negative ? "-" : "") << timecode1.hours << ":" << timecode1.minutes << ":" << timecode1.seconds << ":" << timecode1.frames << "::" << timecode1.subframes << " -> ";
 				cout << "sample: " << sample1 << endl;
 				cout << "sample: " << sample1 << " -> ";
-				cout << "smpte2: " << (smpte2.negative ? "-" : "") << smpte2.hours << ":" << smpte2.minutes << ":" << smpte2.seconds << ":" << smpte2.frames << "::" << smpte2.subframes << endl;
+				cout << "timecode2: " << (timecode2.negative ? "-" : "") << timecode2.hours << ":" << timecode2.minutes << ":" << timecode2.seconds << ":" << timecode2.frames << "::" << timecode2.subframes << endl;
 				//break;
 			}
-      
-			if (smpte2.hours != smpte1.hours || smpte2.minutes != smpte1.minutes || smpte2.seconds != smpte2.seconds || smpte2.frames != smpte1.frames || smpte2.subframes != smpte1.subframes) {
-				cout << "ERROR: smpte2 not equal smpte1" << endl;
-				cout << "smpte1: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << " -> ";
+
+			if (timecode2.hours != timecode1.hours || timecode2.minutes != timecode1.minutes || timecode2.seconds != timecode2.seconds || timecode2.frames != timecode1.frames || timecode2.subframes != timecode1.subframes) {
+				cout << "ERROR: timecode2 not equal timecode1" << endl;
+				cout << "timecode1: " << (timecode1.negative ? "-" : "") << timecode1.hours << ":" << timecode1.minutes << ":" << timecode1.seconds << ":" << timecode1.frames << "::" << timecode1.subframes << " -> ";
 				cout << "sample: " << sample1 << endl;
 				cout << "sample: " << sample1 << " -> ";
-				cout << "smpte2: " << (smpte2.negative ? "-" : "") << smpte2.hours << ":" << smpte2.minutes << ":" << smpte2.seconds << ":" << smpte2.frames << "::" << smpte2.subframes << endl;
+				cout << "timecode2: " << (timecode2.negative ? "-" : "") << timecode2.hours << ":" << timecode2.minutes << ":" << timecode2.seconds << ":" << timecode2.frames << "::" << timecode2.subframes << endl;
 				break;
 			}
 			oldsample = sample1;
-			session->smpte_increment( smpte1 );
+			_session->timecode_increment( timecode1 );
 		}
-    
+
 		cout << "sample_increment: " << sample_increment << endl;
 		cout << "sample: " << sample1 << " -> ";
-		cout << "smpte: " << (smpte2.negative ? "-" : "") << smpte2.hours << ":" << smpte2.minutes << ":" << smpte2.seconds << ":" << smpte2.frames << "::" << smpte2.subframes << endl;
+		cout << "timecode: " << (timecode2.negative ? "-" : "") << timecode2.hours << ":" << timecode2.minutes << ":" << timecode2.seconds << ":" << timecode2.frames << "::" << timecode2.subframes << endl;
 
 		for (int i = 0; i < 108003; i++) {
-			session->smpte_to_sample( smpte1, sample1, true /* use_offset */, true /* use_subframes */ );
-			session->sample_to_smpte( sample1, smpte2, true /* use_offset */, true /* use_subframes */ );
-      
+			_session->timecode_to_sample( timecode1, sample1, true /* use_offset */, true /* use_subframes */ );
+			_session->sample_to_timecode( sample1, timecode2, true /* use_offset */, true /* use_subframes */ );
+
 			if ((i > 0) && ( ((oldsample - sample1) != sample_increment) && ((oldsample - sample1) != (sample_increment + 1)) && ((oldsample - sample1) != (sample_increment - 1)))) {
 				cout << "ERROR: sample increment not right: " << (oldsample - sample1) << " != " << sample_increment << endl;
-				cout << "smpte1: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << " -> ";
+				cout << "timecode1: " << (timecode1.negative ? "-" : "") << timecode1.hours << ":" << timecode1.minutes << ":" << timecode1.seconds << ":" << timecode1.frames << "::" << timecode1.subframes << " -> ";
 				cout << "sample: " << sample1 << endl;
 				cout << "sample: " << sample1 << " -> ";
-				cout << "smpte2: " << (smpte2.negative ? "-" : "") << smpte2.hours << ":" << smpte2.minutes << ":" << smpte2.seconds << ":" << smpte2.frames << "::" << smpte2.subframes << endl;
+				cout << "timecode2: " << (timecode2.negative ? "-" : "") << timecode2.hours << ":" << timecode2.minutes << ":" << timecode2.seconds << ":" << timecode2.frames << "::" << timecode2.subframes << endl;
 				//break;
 			}
-      
-			if (smpte2.hours != smpte1.hours || smpte2.minutes != smpte1.minutes || smpte2.seconds != smpte2.seconds || smpte2.frames != smpte1.frames || smpte2.subframes != smpte1.subframes) {
-				cout << "ERROR: smpte2 not equal smpte1" << endl;
-				cout << "smpte1: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << " -> ";
+
+			if (timecode2.hours != timecode1.hours || timecode2.minutes != timecode1.minutes || timecode2.seconds != timecode2.seconds || timecode2.frames != timecode1.frames || timecode2.subframes != timecode1.subframes) {
+				cout << "ERROR: timecode2 not equal timecode1" << endl;
+				cout << "timecode1: " << (timecode1.negative ? "-" : "") << timecode1.hours << ":" << timecode1.minutes << ":" << timecode1.seconds << ":" << timecode1.frames << "::" << timecode1.subframes << " -> ";
 				cout << "sample: " << sample1 << endl;
 				cout << "sample: " << sample1 << " -> ";
-				cout << "smpte2: " << (smpte2.negative ? "-" : "") << smpte2.hours << ":" << smpte2.minutes << ":" << smpte2.seconds << ":" << smpte2.frames << "::" << smpte2.subframes << endl;
+				cout << "timecode2: " << (timecode2.negative ? "-" : "") << timecode2.hours << ":" << timecode2.minutes << ":" << timecode2.seconds << ":" << timecode2.frames << "::" << timecode2.subframes << endl;
 				break;
 			}
 			oldsample = sample1;
-			session->smpte_decrement( smpte1 );
+			_session->timecode_decrement( timecode1 );
 		}
-    
+
 		cout << "sample_decrement: " << sample_increment << endl;
 		cout << "sample: " << sample1 << " -> ";
-		cout << "smpte: " << (smpte2.negative ? "-" : "") << smpte2.hours << ":" << smpte2.minutes << ":" << smpte2.seconds << ":" << smpte2.frames << "::" << smpte2.subframes << endl;
+		cout << "timecode: " << (timecode2.negative ? "-" : "") << timecode2.hours << ":" << timecode2.minutes << ":" << timecode2.seconds << ":" << timecode2.frames << "::" << timecode2.subframes << endl;
 	}
 #endif
 
 
-#ifdef SMPTE_SAMPLE_TEST_5
+#ifdef Timecode_SAMPLE_TEST_5
 	// Test 5: use_offset = true, use_subframes = false, increment seconds
 	cout << "use_offset = true, use_subframes = false, increment seconds" << endl;
-  
-	smpte1.hours = 0;
-	smpte1.minutes = 0;
-	smpte1.seconds = 0;
-	smpte1.frames = 0;
-	smpte1.subframes = 0;
+
+	timecode1.hours = 0;
+	timecode1.minutes = 0;
+	timecode1.seconds = 0;
+	timecode1.frames = 0;
+	timecode1.subframes = 0;
 	sample1 = oldsample = 0;
-	sample_increment = session->frame_rate();
+	sample_increment = _session->frame_rate();
 
-	session->sample_to_smpte( sample1, smpte1, true /* use_offset */, false /* use_subframes */ );
+	_session->sample_to_timecode( sample1, timecode1, true /* use_offset */, false /* use_subframes */ );
 	cout << "Starting at sample: " << sample1 << " -> ";
-	cout << "smpte: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << endl;
+	cout << "timecode: " << (timecode1.negative ? "-" : "") << timecode1.hours << ":" << timecode1.minutes << ":" << timecode1.seconds << ":" << timecode1.frames << "::" << timecode1.subframes << endl;
 
 	for (int i = 0; i < 3600; i++) {
-		session->smpte_to_sample( smpte1, sample1, true /* use_offset */, false /* use_subframes */ );
-		session->sample_to_smpte( sample1, smpte2, true /* use_offset */, false /* use_subframes */ );
+		_session->timecode_to_sample( timecode1, sample1, true /* use_offset */, false /* use_subframes */ );
+		_session->sample_to_timecode( sample1, timecode2, true /* use_offset */, false /* use_subframes */ );
 
-//     cout << "smpte: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << " -> ";
+//     cout << "timecode: " << (timecode1.negative ? "-" : "") << timecode1.hours << ":" << timecode1.minutes << ":" << timecode1.seconds << ":" << timecode1.frames << "::" << timecode1.subframes << " -> ";
 //     cout << "sample: " << sample1 << endl;
 //     cout << "sample: " << sample1 << " -> ";
-//     cout << "smpte: " << (smpte2.negative ? "-" : "") << smpte2.hours << ":" << smpte2.minutes << ":" << smpte2.seconds << ":" << smpte2.frames << "::" << smpte2.subframes << endl;
-    
+//     cout << "timecode: " << (timecode2.negative ? "-" : "") << timecode2.hours << ":" << timecode2.minutes << ":" << timecode2.seconds << ":" << timecode2.frames << "::" << timecode2.subframes << endl;
+
 //     if ((i > 0) && ( ((sample1 - oldsample) != sample_increment) && ((sample1 - oldsample) != (sample_increment + 1)) && ((sample1 - oldsample) != (sample_increment - 1))))
 //     {
 //       cout << "ERROR: sample increment not right: " << (sample1 - oldsample) << " != " << sample_increment << endl;
 //       break;
 //     }
-    
-		if (smpte2.hours != smpte1.hours || smpte2.minutes != smpte1.minutes || smpte2.seconds != smpte2.seconds || smpte2.frames != smpte1.frames) {
-			cout << "ERROR: smpte2 not equal smpte1" << endl;
-			cout << "smpte: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << " -> ";
+
+		if (timecode2.hours != timecode1.hours || timecode2.minutes != timecode1.minutes || timecode2.seconds != timecode2.seconds || timecode2.frames != timecode1.frames) {
+			cout << "ERROR: timecode2 not equal timecode1" << endl;
+			cout << "timecode: " << (timecode1.negative ? "-" : "") << timecode1.hours << ":" << timecode1.minutes << ":" << timecode1.seconds << ":" << timecode1.frames << "::" << timecode1.subframes << " -> ";
 			cout << "sample: " << sample1 << endl;
 			cout << "sample: " << sample1 << " -> ";
-			cout << "smpte: " << (smpte2.negative ? "-" : "") << smpte2.hours << ":" << smpte2.minutes << ":" << smpte2.seconds << ":" << smpte2.frames << "::" << smpte2.subframes << endl;
+			cout << "timecode: " << (timecode2.negative ? "-" : "") << timecode2.hours << ":" << timecode2.minutes << ":" << timecode2.seconds << ":" << timecode2.frames << "::" << timecode2.subframes << endl;
 			break;
 		}
 		oldsample = sample1;
-		session->smpte_increment_seconds( smpte1 );
+		_session->timecode_increment_seconds( timecode1 );
 	}
 
 	cout << "sample_increment: " << sample_increment << endl;
 	cout << "sample: " << sample1 << " -> ";
-	cout << "smpte: " << (smpte2.negative ? "-" : "") << smpte2.hours << ":" << smpte2.minutes << ":" << smpte2.seconds << ":" << smpte2.frames << "::" << smpte2.subframes << endl;
+	cout << "timecode: " << (timecode2.negative ? "-" : "") << timecode2.hours << ":" << timecode2.minutes << ":" << timecode2.seconds << ":" << timecode2.frames << "::" << timecode2.subframes << endl;
 #endif
 
 
-#ifdef SMPTE_SAMPLE_TEST_6
+#ifdef Timecode_SAMPLE_TEST_6
 	// Test 6: use_offset = true, use_subframes = false, increment minutes
 	cout << "use_offset = true, use_subframes = false, increment minutes" << endl;
-  
-	smpte1.hours = 0;
-	smpte1.minutes = 0;
-	smpte1.seconds = 0;
-	smpte1.frames = 0;
-	smpte1.subframes = 0;
+
+	timecode1.hours = 0;
+	timecode1.minutes = 0;
+	timecode1.seconds = 0;
+	timecode1.frames = 0;
+	timecode1.subframes = 0;
 	sample1 = oldsample = 0;
-	sample_increment = session->frame_rate() * 60;
+	sample_increment = _session->frame_rate() * 60;
 
-	session->sample_to_smpte( sample1, smpte1, true /* use_offset */, false /* use_subframes */ );
+	_session->sample_to_timecode( sample1, timecode1, true /* use_offset */, false /* use_subframes */ );
 	cout << "Starting at sample: " << sample1 << " -> ";
-	cout << "smpte: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << endl;
+	cout << "timecode: " << (timecode1.negative ? "-" : "") << timecode1.hours << ":" << timecode1.minutes << ":" << timecode1.seconds << ":" << timecode1.frames << "::" << timecode1.subframes << endl;
 
 	for (int i = 0; i < 60; i++) {
-		session->smpte_to_sample( smpte1, sample1, true /* use_offset */, false /* use_subframes */ );
-		session->sample_to_smpte( sample1, smpte2, true /* use_offset */, false /* use_subframes */ );
+		_session->timecode_to_sample( timecode1, sample1, true /* use_offset */, false /* use_subframes */ );
+		_session->sample_to_timecode( sample1, timecode2, true /* use_offset */, false /* use_subframes */ );
 
-//     cout << "smpte: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << " -> ";
+//     cout << "timecode: " << (timecode1.negative ? "-" : "") << timecode1.hours << ":" << timecode1.minutes << ":" << timecode1.seconds << ":" << timecode1.frames << "::" << timecode1.subframes << " -> ";
 //     cout << "sample: " << sample1 << endl;
 //     cout << "sample: " << sample1 << " -> ";
-//     cout << "smpte: " << (smpte2.negative ? "-" : "") << smpte2.hours << ":" << smpte2.minutes << ":" << smpte2.seconds << ":" << smpte2.frames << "::" << smpte2.subframes << endl;
-    
+//     cout << "timecode: " << (timecode2.negative ? "-" : "") << timecode2.hours << ":" << timecode2.minutes << ":" << timecode2.seconds << ":" << timecode2.frames << "::" << timecode2.subframes << endl;
+
 //     if ((i > 0) && ( ((sample1 - oldsample) != sample_increment) && ((sample1 - oldsample) != (sample_increment + 1)) && ((sample1 - oldsample) != (sample_increment - 1))))
 //     {
 //       cout << "ERROR: sample increment not right: " << (sample1 - oldsample) << " != " << sample_increment << endl;
 //       break;
 //     }
-    
-		if (smpte2.hours != smpte1.hours || smpte2.minutes != smpte1.minutes || smpte2.seconds != smpte2.seconds || smpte2.frames != smpte1.frames) {
-			cout << "ERROR: smpte2 not equal smpte1" << endl;
-			cout << "smpte: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << " -> ";
+
+		if (timecode2.hours != timecode1.hours || timecode2.minutes != timecode1.minutes || timecode2.seconds != timecode2.seconds || timecode2.frames != timecode1.frames) {
+			cout << "ERROR: timecode2 not equal timecode1" << endl;
+			cout << "timecode: " << (timecode1.negative ? "-" : "") << timecode1.hours << ":" << timecode1.minutes << ":" << timecode1.seconds << ":" << timecode1.frames << "::" << timecode1.subframes << " -> ";
 			cout << "sample: " << sample1 << endl;
 			cout << "sample: " << sample1 << " -> ";
-			cout << "smpte: " << (smpte2.negative ? "-" : "") << smpte2.hours << ":" << smpte2.minutes << ":" << smpte2.seconds << ":" << smpte2.frames << "::" << smpte2.subframes << endl;
+			cout << "timecode: " << (timecode2.negative ? "-" : "") << timecode2.hours << ":" << timecode2.minutes << ":" << timecode2.seconds << ":" << timecode2.frames << "::" << timecode2.subframes << endl;
 			break;
 		}
 		oldsample = sample1;
-		session->smpte_increment_minutes( smpte1 );
+		_session->timecode_increment_minutes( timecode1 );
 	}
 
 	cout << "sample_increment: " << sample_increment << endl;
 	cout << "sample: " << sample1 << " -> ";
-	cout << "smpte: " << (smpte2.negative ? "-" : "") << smpte2.hours << ":" << smpte2.minutes << ":" << smpte2.seconds << ":" << smpte2.frames << "::" << smpte2.subframes << endl;
+	cout << "timecode: " << (timecode2.negative ? "-" : "") << timecode2.hours << ":" << timecode2.minutes << ":" << timecode2.seconds << ":" << timecode2.frames << "::" << timecode2.subframes << endl;
 #endif
 
-#ifdef SMPTE_SAMPLE_TEST_7
+#ifdef Timecode_SAMPLE_TEST_7
 	// Test 7: use_offset = true, use_subframes = false, increment hours
 	cout << "use_offset = true, use_subframes = false, increment hours" << endl;
-  
-	smpte1.hours = 0;
-	smpte1.minutes = 0;
-	smpte1.seconds = 0;
-	smpte1.frames = 0;
-	smpte1.subframes = 0;
+
+	timecode1.hours = 0;
+	timecode1.minutes = 0;
+	timecode1.seconds = 0;
+	timecode1.frames = 0;
+	timecode1.subframes = 0;
 	sample1 = oldsample = 0;
-	sample_increment = session->frame_rate() * 60 * 60;
+	sample_increment = _session->frame_rate() * 60 * 60;
 
-	session->sample_to_smpte( sample1, smpte1, true /* use_offset */, false /* use_subframes */ );
+	_session->sample_to_timecode( sample1, timecode1, true /* use_offset */, false /* use_subframes */ );
 	cout << "Starting at sample: " << sample1 << " -> ";
-	cout << "smpte: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << endl;
+	cout << "timecode: " << (timecode1.negative ? "-" : "") << timecode1.hours << ":" << timecode1.minutes << ":" << timecode1.seconds << ":" << timecode1.frames << "::" << timecode1.subframes << endl;
 
 	for (int i = 0; i < 10; i++) {
-		session->smpte_to_sample( smpte1, sample1, true /* use_offset */, false /* use_subframes */ );
-		session->sample_to_smpte( sample1, smpte2, true /* use_offset */, false /* use_subframes */ );
+		_session->timecode_to_sample( timecode1, sample1, true /* use_offset */, false /* use_subframes */ );
+		_session->sample_to_timecode( sample1, timecode2, true /* use_offset */, false /* use_subframes */ );
 
-//     cout << "smpte: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << " -> ";
+//     cout << "timecode: " << (timecode1.negative ? "-" : "") << timecode1.hours << ":" << timecode1.minutes << ":" << timecode1.seconds << ":" << timecode1.frames << "::" << timecode1.subframes << " -> ";
 //     cout << "sample: " << sample1 << endl;
 //     cout << "sample: " << sample1 << " -> ";
-//     cout << "smpte: " << (smpte2.negative ? "-" : "") << smpte2.hours << ":" << smpte2.minutes << ":" << smpte2.seconds << ":" << smpte2.frames << "::" << smpte2.subframes << endl;
-    
+//     cout << "timecode: " << (timecode2.negative ? "-" : "") << timecode2.hours << ":" << timecode2.minutes << ":" << timecode2.seconds << ":" << timecode2.frames << "::" << timecode2.subframes << endl;
+
 //     if ((i > 0) && ( ((sample1 - oldsample) != sample_increment) && ((sample1 - oldsample) != (sample_increment + 1)) && ((sample1 - oldsample) != (sample_increment - 1))))
 //     {
 //       cout << "ERROR: sample increment not right: " << (sample1 - oldsample) << " != " << sample_increment << endl;
 //       break;
 //     }
-    
-		if (smpte2.hours != smpte1.hours || smpte2.minutes != smpte1.minutes || smpte2.seconds != smpte2.seconds || smpte2.frames != smpte1.frames) {
-			cout << "ERROR: smpte2 not equal smpte1" << endl;
-			cout << "smpte: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << " -> ";
+
+		if (timecode2.hours != timecode1.hours || timecode2.minutes != timecode1.minutes || timecode2.seconds != timecode2.seconds || timecode2.frames != timecode1.frames) {
+			cout << "ERROR: timecode2 not equal timecode1" << endl;
+			cout << "timecode: " << (timecode1.negative ? "-" : "") << timecode1.hours << ":" << timecode1.minutes << ":" << timecode1.seconds << ":" << timecode1.frames << "::" << timecode1.subframes << " -> ";
 			cout << "sample: " << sample1 << endl;
 			cout << "sample: " << sample1 << " -> ";
-			cout << "smpte: " << (smpte2.negative ? "-" : "") << smpte2.hours << ":" << smpte2.minutes << ":" << smpte2.seconds << ":" << smpte2.frames << "::" << smpte2.subframes << endl;
+			cout << "timecode: " << (timecode2.negative ? "-" : "") << timecode2.hours << ":" << timecode2.minutes << ":" << timecode2.seconds << ":" << timecode2.frames << "::" << timecode2.subframes << endl;
 			break;
 		}
 		oldsample = sample1;
-		session->smpte_increment_hours( smpte1 );
+		_session->timecode_increment_hours( timecode1 );
 	}
 
 	cout << "sample_increment: " << sample_increment << endl;
 	cout << "sample: " << sample1 << " -> ";
-	cout << "smpte: " << (smpte2.negative ? "-" : "") << smpte2.hours << ":" << smpte2.minutes << ":" << smpte2.seconds << ":" << smpte2.frames << "::" << smpte2.subframes << endl;
+	cout << "timecode: " << (timecode2.negative ? "-" : "") << timecode2.hours << ":" << timecode2.minutes << ":" << timecode2.seconds << ":" << timecode2.frames << "::" << timecode2.subframes << endl;
 #endif
 
-#endif  
+#endif
 
 	return sample;
 }
 
-jack_nframes_t
+nframes_t
 AudioClock::minsec_frame_from_display () const
 {
-	if (session == 0) {
+	if (_session == 0) {
 		return 0;
 	}
 
@@ -1676,15 +1889,15 @@ AudioClock::minsec_frame_from_display () const
 	int mins = atoi (ms_minutes_label.get_text());
 	float secs = atof (ms_seconds_label.get_text());
 
-	jack_nframes_t sr = session->frame_rate();
+	nframes_t sr = _session->frame_rate();
 
-	return (jack_nframes_t) floor ((hrs * 60.0f * 60.0f * sr) + (mins * 60.0f * sr) + (secs * sr));
+	return (nframes_t) floor ((hrs * 60.0f * 60.0f * sr) + (mins * 60.0f * sr) + (secs * sr));
 }
 
-jack_nframes_t
-AudioClock::bbt_frame_from_display (jack_nframes_t pos) const
+nframes_t
+AudioClock::bbt_frame_from_display (nframes_t pos) const
 {
-	if (session == 0) {
+	if (_session == 0) {
 		error << "AudioClock::current_time() called with BBT mode but without session!" << endmsg;
 		return 0;
 	}
@@ -1696,16 +1909,21 @@ AudioClock::bbt_frame_from_display (jack_nframes_t pos) const
 	any.bbt.beats = atoi (beats_label.get_text());
 	any.bbt.ticks = atoi (ticks_label.get_text());
 
-	jack_nframes_t ret = session->convert_to_frames_at (pos, any);
+       if (is_duration) {
+               any.bbt.bars++;
+               any.bbt.beats++;
+       }
+
+	nframes_t ret = _session->convert_to_frames_at (pos, any);
 
 	return ret;
 }
 
 
-jack_nframes_t
-AudioClock::bbt_frame_duration_from_display (jack_nframes_t pos) const
+nframes_t
+AudioClock::bbt_frame_duration_from_display (nframes_t pos) const
 {
-	if (session == 0) {
+	if (_session == 0) {
 		error << "AudioClock::current_time() called with BBT mode but without session!" << endmsg;
 		return 0;
 	}
@@ -1716,14 +1934,14 @@ AudioClock::bbt_frame_duration_from_display (jack_nframes_t pos) const
 	bbt.bars = atoi (bars_label.get_text());
 	bbt.beats = atoi (beats_label.get_text());
 	bbt.ticks = atoi (ticks_label.get_text());
-	
-	return session->tempo_map().bbt_duration_at(pos,bbt,1);
+
+	return _session->tempo_map().bbt_duration_at(pos,bbt,1);
 }
 
-jack_nframes_t
+nframes_t
 AudioClock::audio_frame_from_display () const
 {
-	return (jack_nframes_t) atoi (audio_frames_label.get_text());
+	return (nframes_t) atoi (audio_frames_label.get_text());
 }
 
 void
@@ -1734,17 +1952,39 @@ AudioClock::build_ops_menu ()
 	MenuList& ops_items = ops_menu->items();
 	ops_menu->set_name ("ArdourContextMenu");
 
-	Menu *mode_menu = manage (new Menu);
-	MenuList& mode_items = mode_menu->items();
-	mode_menu->set_name ("ArdourContextMenu");
+	if (!Profile->get_sae()) {
+		ops_items.push_back (MenuElem (_("Timecode"), sigc::bind (sigc::mem_fun(*this, &AudioClock::set_mode), Timecode)));
+	}
+	ops_items.push_back (MenuElem (_("Bars:Beats"), sigc::bind (sigc::mem_fun(*this, &AudioClock::set_mode), BBT)));
+	ops_items.push_back (MenuElem (_("Minutes:Seconds"), sigc::bind (sigc::mem_fun(*this, &AudioClock::set_mode), MinSec)));
+	ops_items.push_back (MenuElem (_("Samples"), sigc::bind (sigc::mem_fun(*this, &AudioClock::set_mode), Frames)));
+	ops_items.push_back (MenuElem (_("Off"), sigc::bind (sigc::mem_fun(*this, &AudioClock::set_mode), Off)));
+
+	if (editable && !is_duration && !_follows_playhead) {
+		ops_items.push_back (SeparatorElem());
+		ops_items.push_back (MenuElem (_("Set From Playhead"), sigc::mem_fun(*this, &AudioClock::set_from_playhead)));
+		ops_items.push_back (MenuElem (_("Locate to this time"), sigc::mem_fun(*this, &AudioClock::locate)));
+	}
+}
+
+void
+AudioClock::set_from_playhead ()
+{
+	if (!_session) {
+		return;
+	}
 	
-	mode_items.push_back (MenuElem (_("SMPTE"), bind (mem_fun(*this, &AudioClock::set_mode), SMPTE)));
-	mode_items.push_back (MenuElem (_("Bars:Beats"), bind (mem_fun(*this, &AudioClock::set_mode), BBT)));
-	mode_items.push_back (MenuElem (_("Minutes:Seconds"), bind (mem_fun(*this, &AudioClock::set_mode), MinSec)));
-	mode_items.push_back (MenuElem (_("Audio Frames"), bind (mem_fun(*this, &AudioClock::set_mode), Frames)));
-	mode_items.push_back (MenuElem (_("Off"), bind (mem_fun(*this, &AudioClock::set_mode), Off)));
+	set (_session->transport_frame());
+}
 
-	ops_items.push_back (MenuElem (_("Mode"), *mode_menu));
+void
+AudioClock::locate ()
+{
+	if (!_session || is_duration) {
+		return;
+	}
+	
+	_session->request_locate (current_time(), false);
 }
 
 void
@@ -1758,56 +1998,131 @@ AudioClock::set_mode (Mode m)
 	*/
 
 	clock_base.grab_focus ();
-		
+
 	if (_mode == m) {
 		return;
 	}
+
+	clock_base.remove ();
+
+	_mode = m;
+
 	switch (_mode) {
-	case SMPTE:
+	case Timecode:
+		clock_base.add (timecode_packer_hbox);
+		break;
+
 	case BBT:
+		clock_base.add (bbt_packer_hbox);
+		break;
+
 	case MinSec:
+		clock_base.add (minsec_packer_hbox);
+		break;
+
 	case Frames:
-		clock_base.remove ();
+		clock_base.add (frames_packer_hbox);
 		break;
+
 	case Off:
+		clock_base.add (off_hbox);
 		break;
 	}
-	
-	_mode = m;
-	
+
+	set_size_requests ();
+
+	set (last_when, true);
+	clock_base.show_all ();
+	key_entry_state = 0;
+
+	if (!is_transient) {
+		ModeChanged (); /* EMIT SIGNAL */
+		mode_changed (); /* EMIT SIGNAL */
+	}
+}
+
+void
+AudioClock::set_size_requests ()
+{
+	/* note that in some fonts, "88" is narrower than "00" */
+
 	switch (_mode) {
-	case SMPTE:
-		clock_base.add (smpte_packer_hbox);
-		Gtkmm2ext::set_size_request_to_display_given_text (hours_label, "-88", 0, 2);
-		Gtkmm2ext::set_size_request_to_display_given_text (minutes_label, "88", 0, 2);
-		Gtkmm2ext::set_size_request_to_display_given_text (seconds_label, "88", 0, 2);
-		Gtkmm2ext::set_size_request_to_display_given_text (frames_label, "88", 0, 2);
+	case Timecode:
+		Gtkmm2ext::set_size_request_to_display_given_text (hours_label, "-88", 5, 5);
+		Gtkmm2ext::set_size_request_to_display_given_text (minutes_label, "88", 5, 5);
+		Gtkmm2ext::set_size_request_to_display_given_text (seconds_label, "88", 5, 5);
+		Gtkmm2ext::set_size_request_to_display_given_text (frames_label, "88", 5, 5);
 		break;
 
 	case BBT:
-		clock_base.add (bbt_packer_hbox);
-		Gtkmm2ext::set_size_request_to_display_given_text (bars_label, "-888", 0, 2);
-		Gtkmm2ext::set_size_request_to_display_given_text (beats_label, "88", 0, 2);
-		Gtkmm2ext::set_size_request_to_display_given_text (ticks_label, "8888", 0, 2);
+		Gtkmm2ext::set_size_request_to_display_given_text (bars_label, "-888", 5, 5);
+		Gtkmm2ext::set_size_request_to_display_given_text (beats_label, "88", 5, 5);
+		Gtkmm2ext::set_size_request_to_display_given_text (ticks_label, "8888", 5, 5);
 		break;
 
 	case MinSec:
-		clock_base.add (minsec_packer_hbox);
-		Gtkmm2ext::set_size_request_to_display_given_text (ms_hours_label, "99", 0, 2);
-		Gtkmm2ext::set_size_request_to_display_given_text (ms_minutes_label, "99", 0, 2);
-		Gtkmm2ext::set_size_request_to_display_given_text (ms_seconds_label, "99", 0, 2);
+		Gtkmm2ext::set_size_request_to_display_given_text (ms_hours_label, "88", 5, 5);
+		Gtkmm2ext::set_size_request_to_display_given_text (ms_minutes_label, "88", 5, 5);
+		Gtkmm2ext::set_size_request_to_display_given_text (ms_seconds_label, "88.888", 5, 5);
 		break;
 
 	case Frames:
-		clock_base.add (frames_packer_hbox);
-		Gtkmm2ext::set_size_request_to_display_given_text (audio_frames_label, "4294967296", 0, 2);
+		Gtkmm2ext::set_size_request_to_display_given_text (audio_frames_label, "8888888888", 5, 5);
+		break;
 
 	case Off:
+		Gtkmm2ext::set_size_request_to_display_given_text (off_hbox, "00000", 5, 5);
 		break;
+
 	}
+}
 
-	set (last_when, true);
-	clock_base.show_all ();
-	key_entry_state = 0;
+void
+AudioClock::set_bbt_reference (nframes64_t pos)
+{
+	bbt_reference_time = pos;
 }
 
+void
+AudioClock::on_style_changed (const Glib::RefPtr<Style>& old_style)
+{
+	HBox::on_style_changed (old_style);
+
+	/* propagate style changes to all component widgets that should inherit the main one */
+
+	Glib::RefPtr<RcStyle> rcstyle = get_modifier_style();
+
+	clock_base.modify_style (rcstyle);
+	audio_frames_label.modify_style (rcstyle);
+	hours_label.modify_style (rcstyle);
+	minutes_label.modify_style (rcstyle);
+	seconds_label.modify_style (rcstyle);
+	frames_label.modify_style (rcstyle);
+	bars_label.modify_style (rcstyle);
+	beats_label.modify_style (rcstyle);
+	ticks_label.modify_style (rcstyle);
+	ms_hours_label.modify_style (rcstyle);
+	ms_minutes_label.modify_style (rcstyle);
+	ms_seconds_label.modify_style (rcstyle);
+	hours_ebox.modify_style (rcstyle);
+	minutes_ebox.modify_style (rcstyle);
+	seconds_ebox.modify_style (rcstyle);
+	frames_ebox.modify_style (rcstyle);
+	audio_frames_ebox.modify_style (rcstyle);
+	bars_ebox.modify_style (rcstyle);
+	beats_ebox.modify_style (rcstyle);
+	ticks_ebox.modify_style (rcstyle);
+	ms_hours_ebox.modify_style (rcstyle);
+	ms_minutes_ebox.modify_style (rcstyle);
+	ms_seconds_ebox.modify_style (rcstyle);
+
+	colon1.modify_style (rcstyle);
+	colon2.modify_style (rcstyle);
+	colon3.modify_style (rcstyle);
+	colon4.modify_style (rcstyle);
+	colon5.modify_style (rcstyle);
+	b1.modify_style (rcstyle);
+	b2.modify_style (rcstyle);
+
+	set_size_requests ();
+}