: ToolBar(project, TimeBarID, XO("Time"), wxT("Time"), true),

mListener(NULL),

mAudioTime(NULL)

{

project.Bind(EVT_PROJECT_SETTINGS_CHANGE, &TimeToolBar::OnSettingsChanged, this);

{

const auto &settings = ProjectSettings::Get(mProject);

// Get the default sample rate

auto rate = settings.GetRate();

// Get the default time format

auto format = settings.GetAudioTimeFormat();

// Create the read-only time control

mAudioTime = safenew NumericTextCtrl(this, AudioPositionID, NumericConverter::TIME, format, 0.0, rate);

mAudioTime->SetName(XO("Audio Position"));

mAudioTime->SetReadOnly(true);

// Add it to the toolbar

Add(mAudioTime, 0, wxALIGN_CENTER, 0);

// Calculate the width to height ratio

wxSize digitSize = mAudioTime->GetDigitSize();

mDigitRatio = (float)digitSize.x / digitSize.y;

// During initialization, we need to bypass some resizing to prevent the "best size"

// from being used as we want to ensure the saved size is used instead. See SetDocked()

// and OnUpdate() for more info.

mSettingInitialSize = true;

// Establish initial resizing limits

{

// Since the language may have changed, we need to force an update to accommodate

// different length text

wxCommandEvent e;

e.SetInt(mAudioTime->GetFormatIndex());

OnUpdate(e);

// Language may have changed so reset label

SetLabel(XO("Time"));

// Give the toolbar a chance

ToolBar::UpdatePrefs();

{

// Reset

SetMaxSize(wxDefaultSize);

SetMinSize(wxDefaultSize);

// Set the default time format

SetAudioTimeFormat(NumericConverter::HoursMinsSecondsFormat());

// Set the default size

SetSize(GetInitialWidth(), 48);

// Inform others the toobar has changed

Updated();

{

wxSize sz = GetSize();

// Anything less than a single height bar becomes single height

if (sz.y <= toolbarSingle) {

sz.y = toolbarSingle;

}

// Otherwise it will be a double height bar

else {

sz.y = 2 * toolbarSingle + toolbarGap;

}

return sz;

{

// It's important to call this FIRST since it unhides the resizer control.

// Not doing so causes the calculated best size to be off by the width

// of the resizer.

ToolBar::SetDocked(dock, pushed);

// Recalculate the min and max limits

SetResizingLimits();

// When moving from floater to dock, fit to toolbar since the resizer will

// be mispositioned

if (dock) {

// During initialization, the desired size is already set, so do not

// override it with the "best size". See OnUpdate for further info.

if (!mSettingInitialSize) {

// Fit() while retaining height

SetSize(GetBestSize().x, GetSize().y);

// Inform others the toolbar has changed

Updated();

}

}

{

// Remember the listener

mListener = l;

// Get (and set) the saved time format

SetAudioTimeFormat(mListener->TT_GetAudioTimeFormat());

// During initialization, if the saved format is the same as the default,

// OnUpdate() will not be called and need it to set the initial size.

if (mSettingInitialSize) {

wxCommandEvent e;

e.SetInt(mAudioTime->GetFormatIndex());

OnUpdate(e);

}

{

// Set the format if it's different from previous

if (mAudioTime->SetFormatString(mAudioTime->GetBuiltinFormat(format))) {

// Simulate an update since the format has changed.

wxCommandEvent e;

e.SetInt(mAudioTime->GetFormatIndex());

OnUpdate(e);

}

{

// Fit() while retaining height

SetSize(GetBestSize().x, GetSize().y);

// Inform others the toobar has changed

Updated();

{

// Reset limits

SetMinSize(wxDefaultSize);

SetMaxSize(wxDefaultSize);

// If docked we use the current bar height since it's always a single or double height

// toolbar. For floaters, single height toolbar is the minimum height.

int minH = IsDocked() ? GetSize().y : toolbarSingle;

// Get the content size given the smallest digit height we allow

wxSize minSize = ComputeSizing(minDigitH);

// Account for any borders added by the window manager

minSize.x += (mAudioTime->GetSize().x - mAudioTime->GetClientSize().x);

// Calculate the space used by other controls and sizer borders with this toolbar

wxSize outer = (GetSize() - GetSizer()->GetSize());

// And account for them in the width

minSize.x += outer.x;

// Override the height

minSize.y = minH;

// Get the maximum digit height we can use. This is restricted to the toolbar's

// current height minus any control borders

int digH = minH - (mAudioTime->GetSize().y - mAudioTime->GetClientSize().y);

// Get the content size using the digit height, if docked. Otherwise use the

// maximum digit height we allow.

wxSize maxSize = ComputeSizing(IsDocked() ? digH : maxDigitH);

// Account for the other controls and sizer borders within this toolbar

maxSize.x += outer.x;

// Account for any borders added by the window manager and +1 to keep toolbar

// from dropping to next smaller size when grabbing the resizer.

maxSize.x += (mAudioTime->GetSize().x - mAudioTime->GetClientSize().x) + 1;

// Override the height

maxSize.y = IsDocked() ? minH : wxDefaultCoord;

// And finally set them both

SetMinSize(minSize);

SetMaxSize(maxSize);

{

evt.Skip(false);

if (evt.GetInt() == ProjectSettings::ChangedProjectRate && mAudioTime)

{

const auto &settings = ProjectSettings::Get(mProject);

mAudioTime->SetSampleRate(settings.GetRate());

}

{

evt.Skip(false);

// Reset to allow resizing to work

SetMinSize(wxDefaultSize);

SetMaxSize(wxDefaultSize);

// Save format name before recreating the controls so they resize properly

if (mListener) {

mListener->TT_SetAudioTimeFormat(mAudioTime->GetBuiltinName(evt.GetInt()));

}

// During initialization, the desired size will have already been set at this point

// and the "best" size" would override it, so we simply send a size event to force

// the content to fit inside the toolbar.

if (mSettingInitialSize) {

mSettingInitialSize = false;

SendSizeEvent();

}

// Otherwise we want the toolbar to resize to fit around the content

else {

// Fit() while retaining height

SetSize(GetBestSize().x, GetSize().y);

}

// Go set the new size limits

SetResizingLimits();

// Inform others the toobar has changed

Updated();

{

evt.Skip();

// Can fire before we're ready

if (!mAudioTime) {

return;

}

// Make sure everything is where it's supposed to be

Layout();

// Get the sizer's size and remove any borders the time control might have.

wxSize sizerBR = GetSizer()->GetSize() - (mAudioTime->GetSize() - mAudioTime->GetClientSize());

// Get the content size of the time control. This can be different than the

// control itself due to borders and sizer enduced changes.

wxSize timeBR = mAudioTime->GetDimensions();

// Get the current digit box height

int h = mAudioTime->GetDigitSize().y;

// Increase current size to find the best fit within the new size

if (sizerBR.x >= timeBR.x && sizerBR.y >= timeBR.y) {

do {

h++;

timeBR = ComputeSizing(h);

} while (h < maxDigitH && sizerBR.x >= timeBR.x && sizerBR.y >= timeBR.y);

h--;

}

// In all other cases, we need to decrease current size to fit within new size

else if (sizerBR.x < timeBR.x || sizerBR.y < timeBR.y) {

do {

h--;

timeBR = ComputeSizing(h);

} while (h >= minDigitH && (sizerBR.x < timeBR.x || sizerBR.y < timeBR.y));

}

if (h != mAudioTime->GetDigitSize().y) {

mAudioTime->SetDigitSize(h * mDigitRatio, h);

}

// Redraw the display immediately to smooth out resizing

Update();

{

evt.Skip();

double audioTime;

auto &projectAudioIO = ProjectAudioIO::Get(mProject);

if (projectAudioIO.IsAudioActive()) {

auto gAudioIO = AudioIOBase::Get();

audioTime = gAudioIO->GetStreamTime();

}

else {

const auto &playRegion = ViewInfo::Get(mProject).playRegion;

audioTime = playRegion.GetStart();

}

mAudioTime->SetValue(wxMax(0.0, audioTime));