TimerRecordDialog Class Reference

Dialog for Timer Record, i.e., timed or long recording. More...

#include <TimerRecordDialog.h>

Inheritance diagram for TimerRecordDialog:

Collaboration diagram for TimerRecordDialog:

Public Types
using	ProgressResult = BasicUI::ProgressResult

Public Member Functions
	TimerRecordDialog (wxWindow *parent, AudacityProject &project, bool bAlreadySaved)
	~TimerRecordDialog ()
void	OnTimer (wxTimerEvent &event)
int	RunWaitDialog ()
	Runs the wait for start dialog. Returns false if the user clicks stop. More...
Public Member Functions inherited from wxDialogWrapper
	wxDialogWrapper ()
	wxDialogWrapper (wxWindow *parent, wxWindowID id, const TranslatableString &title, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=wxDEFAULT_DIALOG_STYLE, const TranslatableString &name=XO("Dialog"))
bool	Create (wxWindow *parent, wxWindowID id, const TranslatableString &title, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=wxDEFAULT_DIALOG_STYLE, const TranslatableString &name=XO("Dialog"))
void	SetTitle (const TranslatableString &title)
void	SetLabel (const TranslatableString &title)
void	SetName (const TranslatableString &title)
void	SetName ()
Public Member Functions inherited from wxTabTraversalWrapper< wxDialog >
	wxTabTraversalWrapper (Args &&... args)
	wxTabTraversalWrapper (const wxTabTraversalWrapper &)=delete
	wxTabTraversalWrapper (wxTabTraversalWrapper &&)=delete
wxTabTraversalWrapper &	operator= (const wxTabTraversalWrapper &)=delete
wxTabTraversalWrapper &	operator= (wxTabTraversalWrapper &&)=delete

Private Member Functions
void	OnDatePicker_Start (wxDateEvent &event)
void	OnTimeText_Start (wxCommandEvent &event)
void	OnDatePicker_End (wxDateEvent &event)
void	OnTimeText_End (wxCommandEvent &event)
void	OnTimeText_Duration (wxCommandEvent &event)
void	OnOK (wxCommandEvent &event)
void	OnHelpButtonClick (wxCommandEvent &event)
TranslatableString	GetDisplayDate (wxDateTime &dt)
void	PopulateOrExchange (ShuttleGui &S)
bool	TransferDataFromWindow () override
void	UpdateDuration ()
void	UpdateEnd ()
ProgressResult	WaitForStart ()
void	OnAutoSavePathButton_Click (wxCommandEvent &event)
void	OnAutoExportPathButton_Click (wxCommandEvent &event)
void	OnAutoSaveCheckBox_Change (wxCommandEvent &event)
void	OnAutoExportCheckBox_Change (wxCommandEvent &event)
void	EnableDisableAutoControls (bool bEnable, int iControlGoup)
void	UpdateTextBoxControls ()
wxTextCtrlWrapper *	NewPathControl (wxWindow *wParent, const int iID, const TranslatableString &sCaption, const TranslatableString &sValue)
int	ExecutePostRecordActions (bool bWasStopped)
ProgressResult	PreActionDelay (int iActionIndex, TimerRecordCompletedActions eCompletedActions)

Private Attributes
AudacityProject &	mProject
wxDateTime	m_DateTime_Start
wxDateTime	m_DateTime_End
wxTimeSpan	m_TimeSpan_Duration
wxDatePickerCtrl *	m_pDatePickerCtrl_Start
NumericTextCtrl *	m_pTimeTextCtrl_Start
wxDatePickerCtrl *	m_pDatePickerCtrl_End
NumericTextCtrl *	m_pTimeTextCtrl_End
NumericTextCtrl *	m_pTimeTextCtrl_Duration
wxTimer	m_timer
wxCheckBox *	m_pTimerAutoSaveCheckBoxCtrl
wxTextCtrlWrapper *	m_pTimerSavePathTextCtrl
wxButton *	m_pTimerSavePathButtonCtrl
wxCheckBox *	m_pTimerAutoExportCheckBoxCtrl
wxTextCtrlWrapper *	m_pTimerExportPathTextCtrl
wxButton *	m_pTimerExportPathButtonCtrl
wxChoice *	m_pTimerAfterCompleteChoiceCtrl
bool	m_bProjectCleanupRequired
bool	m_bAutoSaveEnabled
wxFileName	m_fnAutoSaveFile
bool	m_bAutoExportEnabled
wxFileName	m_fnAutoExportFile
wxString	m_sAutoExportFormat
int	m_iAutoExportSampleRate {0}
int	m_iAutoExportChannels {0}
ExportProcessor::Parameters	m_AutoExportParameters
bool	m_bProjectAlreadySaved

Detailed Description

Dialog for Timer Record, i.e., timed or long recording.

Definition at line 57 of file TimerRecordDialog.h.

Member Typedef Documentation

ProgressResult

using TimerRecordDialog::ProgressResult = BasicUI::ProgressResult

Definition at line 60 of file TimerRecordDialog.h.

Constructor & Destructor Documentation

TimerRecordDialog()

TimerRecordDialog::TimerRecordDialog	(	wxWindow *	parent,
		AudacityProject &	project,
		bool	bAlreadySaved
	)

Definition at line 168 of file TimerRecordDialog.cpp.

: wxDialogWrapper(parent, -1, XO("Audacity Timer Record"), wxDefaultPosition,
           wxDefaultSize, wxCAPTION)
, mProject{ project }
{
   SetName();
 
   m_DateTime_Start = wxDateTime::UNow();
   long seconds; // default duration is 1 hour = 3600 seconds
   gPrefs->Read(wxT("/TimerRecord/LastDuration"), &seconds, 3600L);
   m_TimeSpan_Duration = wxTimeSpan::Seconds(seconds);
   m_DateTime_End = m_DateTime_Start + m_TimeSpan_Duration;
 
   m_pDatePickerCtrl_Start = NULL;
   m_pTimeTextCtrl_Start = NULL;
 
   m_pDatePickerCtrl_End = NULL;
   m_pTimeTextCtrl_End = NULL;
 
   m_pTimeTextCtrl_Duration = NULL;
 
   // Do we allow the user to change the Automatic Save file?
   m_bProjectAlreadySaved = bAlreadySaved;
 
   wxString exportPath;
   DefaultExportAudioPath.Read(&exportPath);
   if(exportPath.empty())
      exportPath = FileNames::FindDefaultPath(FileNames::Operation::Export);
   m_fnAutoExportFile.SetPath(exportPath);
 
   m_fnAutoExportFile.SetName(mProject.GetProjectName());
   if(m_fnAutoExportFile.GetName().IsEmpty())
      m_fnAutoExportFile.SetName(_("untitled"));
   
   DefaultExportAudioFormat.Read(&m_sAutoExportFormat);
   if(!m_sAutoExportFormat.empty())
   {
      auto [plugin, formatIndex]
         = ExportPluginRegistry::Get().FindFormat(m_sAutoExportFormat);
 
      if(plugin != nullptr)
      {
         const auto formatInfo = plugin->GetFormatInfo(formatIndex);
         m_fnAutoExportFile.SetExt(formatInfo.extensions[0]);
      }
   }
 
   m_iAutoExportSampleRate = ProjectRate::Get(mProject).GetRate();
 
   ShuttleGui S(this, eIsCreating);
   this->PopulateOrExchange(S);
 
   // Set initial focus to "1" of "01h" in Duration NumericTextCtrl,
   // instead of OK button (default).
   m_pTimeTextCtrl_Duration->SetFocus();
   m_pTimeTextCtrl_Duration->SetFieldFocus(3);
 
   m_timer.SetOwner(this, TIMER_ID);
   m_timer.Start(kSlowTimerInterval);
}

References project.

~TimerRecordDialog()

TimerRecordDialog::~TimerRecordDialog ( )

default

Member Function Documentation

EnableDisableAutoControls()

void TimerRecordDialog::EnableDisableAutoControls ( bool  bEnable, int  iControlGoup  )

private

Definition at line 489 of file TimerRecordDialog.cpp.

                                                                                {
 
   if (iControlGoup == CONTROL_GROUP_EXPORT) {
       m_pTimerExportPathTextCtrl->Enable( bEnable );
       m_pTimerExportPathButtonCtrl->Enable( bEnable);
   } else if (iControlGoup == CONTROL_GROUP_SAVE) {
       m_pTimerSavePathTextCtrl->Enable( bEnable);
       m_pTimerSavePathButtonCtrl->Enable(bEnable );
   }
 
   // Enable or disable the Choice box - if there is no Save or Export then this will be disabled
   if (m_pTimerAutoSaveCheckBoxCtrl->GetValue() || m_pTimerAutoExportCheckBoxCtrl->GetValue()) {
      m_pTimerAfterCompleteChoiceCtrl->Enable();
   } else {
      m_pTimerAfterCompleteChoiceCtrl->SetSelection(POST_TIMER_RECORD_NOTHING);
      m_pTimerAfterCompleteChoiceCtrl->Disable();
   }
}

References CONTROL_GROUP_EXPORT, CONTROL_GROUP_SAVE, m_pTimerAfterCompleteChoiceCtrl, m_pTimerAutoExportCheckBoxCtrl, m_pTimerAutoSaveCheckBoxCtrl, m_pTimerExportPathButtonCtrl, m_pTimerExportPathTextCtrl, m_pTimerSavePathButtonCtrl, m_pTimerSavePathTextCtrl, and POST_TIMER_RECORD_NOTHING.

Referenced by OnAutoExportCheckBox_Change(), OnAutoSaveCheckBox_Change(), and PopulateOrExchange().

Here is the caller graph for this function:

ExecutePostRecordActions()

int TimerRecordDialog::ExecutePostRecordActions ( bool  bWasStopped )

private

Definition at line 598 of file TimerRecordDialog.cpp.

                                                                {
   // MY: We no longer automatically (and silently) call ->Save() when the
   // timer recording is completed.  We can now Save and/or Export depending
   // on the options selected by the user.
   // Once completed, we can also close Audacity, restart the system or
   // shutdown the system.
   // If there was any error with the auto save or export then we will not do
   // the actions requested and instead present an error mesasge to the user.
   // Finally, if there is no post-record action selected then we output
   // a dialog detailing what has been carried out instead.
 
   bool bSaveOK = false;
   bool bExportOK = false;
   int iPostRecordAction = m_pTimerAfterCompleteChoiceCtrl->GetSelection();
   int iOverriddenAction = iPostRecordAction;
   bool bErrorOverride = false;
 
   // Do Automatic Save?
   if (m_bAutoSaveEnabled) {
 
      auto &projectFileManager = ProjectFileManager::Get( mProject );
      // MY: If this project has already been saved then simply execute a Save here
      if (m_bProjectAlreadySaved) {
         bSaveOK = projectFileManager.Save();
      } else {
         bSaveOK = projectFileManager.SaveFromTimerRecording(m_fnAutoSaveFile);
      }
   }
 
   // Do Automatic Export?
   if (m_bAutoExportEnabled) {
      const auto& tracks = TrackList::Get(mProject);
      if(ExportUtils::FindExportWaveTracks(tracks, false).empty())
      {
         ShowExportErrorDialog(XO("All audio is muted."), XO("Warning"), false);
         bExportOK = true;
      }
      else
      {
         const auto t0 = std::max(.0, tracks.GetStartTime());
 
         auto [exportPlugin, formatIndex] =
            ExportPluginRegistry::Get().FindFormat(m_sAutoExportFormat);
 
         if(exportPlugin != nullptr)
         {
            auto builder = ExportTaskBuilder {}
               .SetFileName(m_fnAutoExportFile)
               .SetParameters(m_AutoExportParameters)
               .SetRange(t0, tracks.GetEndTime(), false)
               .SetSampleRate(m_iAutoExportSampleRate)
               .SetNumChannels(m_iAutoExportChannels)
               .SetPlugin(exportPlugin, formatIndex);
            
            ExportProgressUI::ExceptionWrappedCall([&]
            {
               const auto result = ExportProgressUI::Show(builder.Build(mProject));
               bExportOK = result == ExportResult::Success ||
                  result == ExportResult::Stopped;
            });
 
            if(bExportOK)
            {
               DefaultExportAudioPath.Write(m_fnAutoExportFile.GetPath());
               DefaultExportAudioFormat.Write(m_sAutoExportFormat);
            }
         }
      }
   }
 
   // Check if we need to override the post recording action
   bErrorOverride = ((m_bAutoSaveEnabled && !bSaveOK) || (m_bAutoExportEnabled && !bExportOK));
   if (bErrorOverride || bWasStopped) {
      iPostRecordAction = POST_TIMER_RECORD_NOTHING;
   }
 
   if (iPostRecordAction == POST_TIMER_RECORD_NOTHING) {
      // If there is no post-record action then we can show a message indicating what has been done
 
      auto sMessage = (bWasStopped ? XO("Timer Recording stopped.") :
                                         XO("Timer Recording completed."));
 
      if (m_bAutoSaveEnabled) {
         if (bSaveOK) {
            sMessage = XO("%s\n\nRecording saved: %s").Format(
                            sMessage, m_fnAutoSaveFile.GetFullPath());
         } else {
            sMessage = XO("%s\n\nError saving recording.").Format( sMessage );
         }
      }
      if (m_bAutoExportEnabled) {
         if (bExportOK) {
            sMessage = XO("%s\n\nRecording exported: %s").Format(
                            sMessage, m_fnAutoExportFile.GetFullPath());
         } else {
            sMessage = XO("%s\n\nError exporting recording.").Format( sMessage );
         }
      }
 
      if (bErrorOverride) {
 
         if ((iOverriddenAction != iPostRecordAction) &&
             (iOverriddenAction != POST_TIMER_RECORD_NOTHING)) {
            // Inform the user that we have overridden the selected action
            sMessage = XO("%s\n\n'%s' has been canceled due to the error(s) noted above.").Format(
                            sMessage,
                            m_pTimerAfterCompleteChoiceCtrl->GetString(iOverriddenAction));
         }
 
         // Show Error Message Box
         AudacityMessageBox(
            sMessage,
            XO("Error"),
            wxICON_EXCLAMATION | wxOK);
      } else {
 
         if (bWasStopped && (iOverriddenAction != POST_TIMER_RECORD_NOTHING)) {
            sMessage = XO("%s\n\n'%s' has been canceled as the recording was stopped.").Format(
                            sMessage,
                            m_pTimerAfterCompleteChoiceCtrl->GetString(iOverriddenAction));
         }
 
         AudacityMessageBox(
            sMessage,
            XO("Timer Recording"),
            wxICON_INFORMATION | wxOK);
      }
   }
 
   // MY: Lets do some actions that only apply to Exit/Restart/Shutdown
   if (iPostRecordAction >= POST_TIMER_RECORD_CLOSE) {
      do {
 
         // Set the flags as appropriate based on what we have done
         wxUint32 eActionFlags = TR_ACTION_NOTHING;
         if (m_bAutoSaveEnabled && bSaveOK) {
            eActionFlags |= TR_ACTION_SAVED;
         }
         if (m_bAutoExportEnabled && bExportOK) {
            eActionFlags |= TR_ACTION_EXPORTED;
         }
 
         // Lets show a warning dialog telling the user what is about to happen.
         // If the user no longer wants to carry out this action then they can click
         // Cancel and we will do POST_TIMER_RECORD_NOTHING instead.
         auto iDelayOutcome = PreActionDelay(iPostRecordAction, (TimerRecordCompletedActions)eActionFlags);
         if (iDelayOutcome != ProgressResult::Success) {
            // Cancel the action!
            iPostRecordAction = POST_TIMER_RECORD_NOTHING;
            break;
         }
      } while (false);
   }
 
   // Return the action as required
   return iPostRecordAction;
}

References AudacityMessageBox(), anonymous_namespace{TimerRecordDialog.cpp}::DefaultExportAudioFormat, anonymous_namespace{TimerRecordDialog.cpp}::DefaultExportAudioPath, ExportProgressUI::ExceptionWrappedCall(), ExportUtils::FindExportWaveTracks(), ExportPluginRegistry::FindFormat(), ExportPluginRegistry::Get(), TrackList::Get(), ProjectFileManager::Get(), m_AutoExportParameters, m_bAutoExportEnabled, m_bAutoSaveEnabled, m_bProjectAlreadySaved, m_fnAutoExportFile, m_fnAutoSaveFile, m_iAutoExportChannels, m_iAutoExportSampleRate, m_pTimerAfterCompleteChoiceCtrl, m_sAutoExportFormat, mProject, POST_TIMER_RECORD_CLOSE, POST_TIMER_RECORD_NOTHING, PreActionDelay(), ExportTaskBuilder::SetFileName(), ExportTaskBuilder::SetNumChannels(), ExportTaskBuilder::SetParameters(), ExportTaskBuilder::SetPlugin(), ExportTaskBuilder::SetRange(), ExportTaskBuilder::SetSampleRate(), ExportProgressUI::Show(), ShowExportErrorDialog(), Stopped, BasicUI::Success, Success, TR_ACTION_EXPORTED, TR_ACTION_NOTHING, TR_ACTION_SAVED, tracks, Setting< T >::Write(), and XO().

Referenced by RunWaitDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

GetDisplayDate()

TranslatableString TimerRecordDialog::GetDisplayDate ( wxDateTime &  dt )

private

Definition at line 756 of file TimerRecordDialog.cpp.

{
#if defined(__WXMSW__)
   // On Windows, wxWidgets uses the system date control and it displays the
   // date based on the Windows locale selected by the user.  But, wxDateTime
   // using the strftime function to return the formatted date.  Since the
   // default locale for the Windows CRT environment is "C", the dates come
   // back in a different format.
   //
   // So, we make direct Windows calls to format the date like it the date
   // control.
   //
   // (Most of this taken from src/msw/datectrl.cpp)
 
   const wxDateTime::Tm tm(dt.GetTm());
   SYSTEMTIME st;
   wxString s;
   int len;
 
   st.wYear = (WXWORD)tm.year;
   st.wMonth = (WXWORD)(tm.mon - wxDateTime::Jan + 1);
   st.wDay = tm.mday;
   st.wDayOfWeek = st.wMinute = st.wSecond = st.wMilliseconds = 0;
 
   len = ::GetDateFormat(LOCALE_USER_DEFAULT,
                         DATE_SHORTDATE,
                         &st,
                         NULL,
                         NULL,
                         0);
   if (len > 0) {
      len = ::GetDateFormat(LOCALE_USER_DEFAULT,
                            DATE_SHORTDATE,
                            &st,
                            NULL,
                            wxStringBuffer(s, len),
                            len);
      if (len > 0) {
         s += wxT(" ") + dt.FormatTime();
         return Verbatim( s );
      }
   }
#endif
 
   // Use default formatting
wxPrintf(wxT("%s\n"), dt.Format());
   return Verbatim( dt.FormatDate() + wxT(" ") + dt.FormatTime() );
}

References Verbatim(), and wxT().

Referenced by RunWaitDialog(), and WaitForStart().

Here is the call graph for this function:

Here is the caller graph for this function:

NewPathControl()

wxTextCtrlWrapper * TimerRecordDialog::NewPathControl ( wxWindow *  wParent, const int  iID, const TranslatableString &  sCaption, const TranslatableString &  sValue  )

private

Definition at line 805 of file TimerRecordDialog.cpp.

{
   wxTextCtrlWrapper * pTextCtrl;
   wxASSERT(wParent); // to justify safenew
   pTextCtrl = safenew wxTextCtrlWrapper(wParent, iID, sValue.Translation());
   pTextCtrl->SetName(sCaption.Translation());
   return pTextCtrl;
}

References safenew, and TranslatableString::Translation().

Referenced by PopulateOrExchange().

Here is the call graph for this function:

Here is the caller graph for this function:

OnAutoExportCheckBox_Change()

void TimerRecordDialog::OnAutoExportCheckBox_Change ( wxCommandEvent &  event )

private

Definition at line 401 of file TimerRecordDialog.cpp.

                                                                                   {
   EnableDisableAutoControls(m_pTimerAutoExportCheckBoxCtrl->GetValue(), CONTROL_GROUP_EXPORT);
}

References CONTROL_GROUP_EXPORT, EnableDisableAutoControls(), and m_pTimerAutoExportCheckBoxCtrl.

Here is the call graph for this function:

OnAutoExportPathButton_Click()

void TimerRecordDialog::OnAutoExportPathButton_Click ( wxCommandEvent &  event )

private

Definition at line 377 of file TimerRecordDialog.cpp.

{
   // Set the options required
   TimerRecordExportDialog exportDialog(mProject, this);
   exportDialog.Bind(
      m_fnAutoExportFile,
      m_sAutoExportFormat,
      m_iAutoExportSampleRate,
      m_iAutoExportChannels,
      m_AutoExportParameters);
 
   if(exportDialog.ShowModal() != wxID_OK)
      return;
   
   m_pTimerExportPathTextCtrl->SetValue(m_fnAutoExportFile.GetFullPath());
 
   // Update the text controls
   this->UpdateTextBoxControls();
}

References TimerRecordExportDialog::Bind(), m_AutoExportParameters, m_fnAutoExportFile, m_iAutoExportChannels, m_iAutoExportSampleRate, m_pTimerExportPathTextCtrl, m_sAutoExportFormat, mProject, and UpdateTextBoxControls().

Here is the call graph for this function:

OnAutoSaveCheckBox_Change()

void TimerRecordDialog::OnAutoSaveCheckBox_Change ( wxCommandEvent &  event )

private

Definition at line 397 of file TimerRecordDialog.cpp.

                                                                                 {
   EnableDisableAutoControls(m_pTimerAutoSaveCheckBoxCtrl->GetValue(), CONTROL_GROUP_SAVE);
}

References CONTROL_GROUP_SAVE, EnableDisableAutoControls(), and m_pTimerAutoSaveCheckBoxCtrl.

Here is the call graph for this function:

OnAutoSavePathButton_Click()

void TimerRecordDialog::OnAutoSavePathButton_Click ( wxCommandEvent &  event )

private

Definition at line 339 of file TimerRecordDialog.cpp.

{
   auto &projectFileIO = ProjectFileIO::Get(mProject);
 
   wxString fName = SelectFile(FileNames::Operation::Export,
      XO("Save Timer Recording As"),
      m_fnAutoSaveFile.GetPath(),
      m_fnAutoSaveFile.GetFullName(),
      wxT("aup3"),
      { FileNames::AudacityProjects },
      wxFD_SAVE | wxRESIZE_BORDER,
      this);
 
   if (fName.empty())
      return;
 
   // If project already exists then abort - we do not allow users to overwrite an existing project
   // unless it is the current project.
   if (wxFileExists(fName) && (projectFileIO.GetFileName() != fName)) {
      AudacityMessageDialog m(
         nullptr,
         XO("The selected file name could not be used\nfor Timer Recording because it \
would overwrite another project.\nPlease try again and select an original name."),
         XO("Error Saving Timer Recording Project"),
         wxOK|wxICON_ERROR );
      m.ShowModal();
      return;
   }
 
   // Set this boolean to false so we now do a SaveAs at the end of the recording
   // unless we're saving the current project.
   m_bProjectAlreadySaved = projectFileIO.GetFileName() == fName? true : false;
 
   m_fnAutoSaveFile = fName;
   m_fnAutoSaveFile.SetExt(wxT("aup3"));
   this->UpdateTextBoxControls();
}

References FileNames::AudacityProjects, ProjectFileIO::Get(), m_bProjectAlreadySaved, m_fnAutoSaveFile, mProject, SelectFile(), UpdateTextBoxControls(), wxT(), and XO().

Here is the call graph for this function:

OnDatePicker_End()

void TimerRecordDialog::OnDatePicker_End ( wxDateEvent &  event )

private

Definition at line 285 of file TimerRecordDialog.cpp.

{
   m_DateTime_End = m_pDatePickerCtrl_End->GetValue();
   double dTime = m_pTimeTextCtrl_End->GetValue();
   long hr = (long)(dTime / 3600.0);
   long min = (long)((dTime - (hr * 3600.0)) / 60.0);
   long sec = (long)(dTime - (hr * 3600.0) - (min * 60.0));
   m_DateTime_End.SetHour(hr);
   m_DateTime_End.SetMinute(min);
   m_DateTime_End.SetSecond(sec);
 
   // DatePickerCtrls use SetRange to make sure End is never less than Start, but
   // need to implement it for the TimeTextCtrls.
   if (m_DateTime_End < m_DateTime_Start) {
      m_DateTime_End = m_DateTime_Start;
      m_pDatePickerCtrl_End->SetValue(m_DateTime_End);
      m_pTimeTextCtrl_End->SetValue(wxDateTime_to_AudacityTime(m_DateTime_End));
   }
 
   this->UpdateDuration(); // Keep Start constant and update Duration for changed End.
}

References NumericConverter::GetValue(), m_DateTime_End, m_DateTime_Start, m_pDatePickerCtrl_End, m_pTimeTextCtrl_End, min(), NumericTextCtrl::SetValue(), UpdateDuration(), and wxDateTime_to_AudacityTime().

Referenced by OnTimeText_End().

Here is the call graph for this function:

Here is the caller graph for this function:

OnDatePicker_Start()

void TimerRecordDialog::OnDatePicker_Start ( wxDateEvent &  event )

private

Definition at line 243 of file TimerRecordDialog.cpp.

{
   m_DateTime_Start = m_pDatePickerCtrl_Start->GetValue();
   double dTime = m_pTimeTextCtrl_Start->GetValue();
   long hr = (long)(dTime / 3600.0);
   long min = (long)((dTime - (hr * 3600.0)) / 60.0);
   long sec = (long)(dTime - (hr * 3600.0) - (min * 60.0));
   m_DateTime_Start.SetHour(hr);
   m_DateTime_Start.SetMinute(min);
   m_DateTime_Start.SetSecond(sec);
 
   // User might have had the dialog up for a while, or
   // had a future day, set hour of day less than now's, then changed day to today.
   wxTimerEvent dummyTimerEvent;
   this->OnTimer(dummyTimerEvent);
 
   // Always update End for changed Start, keeping Duration constant.
   // Note that OnTimer sometimes calls UpdateEnd, so sometimes this is redundant,
   // but OnTimer doesn't need to always call UpdateEnd, but we must here.
   this->UpdateEnd();
}

References NumericConverter::GetValue(), m_DateTime_Start, m_pDatePickerCtrl_Start, m_pTimeTextCtrl_Start, min(), OnTimer(), and UpdateEnd().

Referenced by OnTimeText_Start().

Here is the call graph for this function:

Here is the caller graph for this function:

OnHelpButtonClick()

void TimerRecordDialog::OnHelpButtonClick ( wxCommandEvent &  event )

private

Definition at line 405 of file TimerRecordDialog.cpp.

{
   HelpSystem::ShowHelp(this, L"Timer_Record", true);
}

References HelpSystem::ShowHelp().

Here is the call graph for this function:

OnOK()

void TimerRecordDialog::OnOK ( wxCommandEvent &  event )

private

Definition at line 410 of file TimerRecordDialog.cpp.

{
   this->TransferDataFromWindow();
   if (!m_TimeSpan_Duration.IsPositive())
   {
      AudacityMessageBox(
         XO("Duration is zero. Nothing will be recorded."),
         XO("Error in Duration"),
         wxICON_EXCLAMATION | wxOK);
      return;
   }
 
   // Validate that we have a Save and/or Export path setup if the appropriate check box is ticked
   wxString sTemp = m_fnAutoSaveFile.GetFullPath();
   if (m_pTimerAutoSaveCheckBoxCtrl->IsChecked()) {
      if (!m_fnAutoSaveFile.IsOk() || m_fnAutoSaveFile.IsDir()) {
         AudacityMessageBox(
            XO("Automatic Save path is invalid."),
            XO("Error in Automatic Save"),
            wxICON_EXCLAMATION | wxOK);
         return;
      }
   }
   if (m_pTimerAutoExportCheckBoxCtrl->IsChecked()) {
      if (!m_fnAutoExportFile.IsOk() || m_fnAutoExportFile.IsDir()) {
         AudacityMessageBox(
            XO("Automatic Export path is invalid."),
            XO("Error in Automatic Export"),
            wxICON_EXCLAMATION | wxOK);
         return;
      }
   }
 
   // MY: Estimate here if we have enough disk space to
   // complete this Timer Recording.
   // If we don't think there is enough space then ask the user
   // if they want to continue.
   // We don't stop the user from starting the recording
   // as its possible that they plan to free up some
   // space before the recording begins
   auto &projectManager = ProjectManager::Get( mProject );
 
   // How many minutes do we have left on the disc?
   int iMinsLeft = projectManager.GetEstimatedRecordingMinsLeftOnDisk();
 
   // How many minutes will this recording require?
   int iMinsRecording = m_TimeSpan_Duration.GetMinutes();
 
   // Do we have enough space?
   if (iMinsRecording >= iMinsLeft) {
 
      // Format the strings
      auto sRemainingTime = projectManager.GetHoursMinsString(iMinsLeft);
      auto sPlannedTime = projectManager.GetHoursMinsString(iMinsRecording);
 
      // Create the message string
      auto sMessage = XO(
"You may not have enough free disk space to complete this Timer Recording, based on your current settings.\n\nDo you wish to continue?\n\nPlanned recording duration:   %s\nRecording time remaining on disk:   %s")
         .Format( sPlannedTime, sRemainingTime );
 
      AudacityMessageDialog dlgMessage(
         nullptr,
         sMessage,
         XO("Timer Recording Disk Space Warning"),
         wxYES_NO | wxNO_DEFAULT | wxICON_WARNING);
      if (dlgMessage.ShowModal() != wxID_YES ) {
         // User decided not to continue - bail out!
         return;
      }
   }
 
   m_timer.Stop(); // Don't need to keep updating m_DateTime_Start to prevent backdating.
   this->EndModal(wxID_OK);
   wxLongLong duration = m_TimeSpan_Duration.GetSeconds();
   // this will assert if the duration won't fit in a long
   gPrefs->Write(wxT("/TimerRecord/LastDuration"), duration.ToLong());
   gPrefs->Flush();
}

References AudacityMessageBox(), audacity::BasicSettings::Flush(), ProjectManager::Get(), gPrefs, m_fnAutoExportFile, m_fnAutoSaveFile, m_pTimerAutoExportCheckBoxCtrl, m_pTimerAutoSaveCheckBoxCtrl, m_timer, m_TimeSpan_Duration, mProject, TransferDataFromWindow(), audacity::BasicSettings::Write(), wxT(), and XO().

Here is the call graph for this function:

OnTimer()

void TimerRecordDialog::OnTimer

(

wxTimerEvent &

event

)

Definition at line 232 of file TimerRecordDialog.cpp.

{
   wxDateTime dateTime_UNow = wxDateTime::UNow();
   if (m_DateTime_Start < dateTime_UNow) {
      m_DateTime_Start = dateTime_UNow;
      m_pDatePickerCtrl_Start->SetValue(m_DateTime_Start);
      m_pTimeTextCtrl_Start->SetValue(wxDateTime_to_AudacityTime(m_DateTime_Start));
      this->UpdateEnd(); // Keep Duration constant and update End for changed Start.
   }
}

References m_DateTime_Start, m_pDatePickerCtrl_Start, m_pTimeTextCtrl_Start, NumericTextCtrl::SetValue(), UpdateEnd(), and wxDateTime_to_AudacityTime().

Referenced by OnDatePicker_Start(), and RunWaitDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

OnTimeText_Duration()

void TimerRecordDialog::OnTimeText_Duration ( wxCommandEvent &  event )

private

Definition at line 327 of file TimerRecordDialog.cpp.

{
   double dTime = m_pTimeTextCtrl_Duration->GetValue();
   long hr = (long)(dTime / 3600.0);
   long min = (long)((dTime - (hr * 3600.0)) / 60.0);
   long sec = (long)(dTime - (hr * 3600.0) - (min * 60.0));
   m_TimeSpan_Duration = wxTimeSpan(hr, min, sec); //v milliseconds?
 
   this->UpdateEnd(); // Keep Start constant and update End for changed Duration.
}

References NumericConverter::GetValue(), m_pTimeTextCtrl_Duration, m_TimeSpan_Duration, min(), and UpdateEnd().

Here is the call graph for this function:

OnTimeText_End()

void TimerRecordDialog::OnTimeText_End ( wxCommandEvent &  event )

private

Definition at line 307 of file TimerRecordDialog.cpp.

{
   //v NumericTextCtrl doesn't implement upper ranges, i.e.,
   // if I tell it "024 h 060 m 060 s", then
   // user increments the hours past 23, it rolls over to 0
   // (although if you increment below 0, it stays at 0).
   // So instead, set the max to 99 and just catch hours > 24 and fix the ctrls.
   double dTime = m_pTimeTextCtrl_End->GetValue();
   long days = (long)(dTime / (24.0 * 3600.0));
   if (days > 0) {
      dTime -= (double)days * 24.0 * 3600.0;
      m_DateTime_End += wxTimeSpan::Days(days);
      m_pDatePickerCtrl_End->SetValue(m_DateTime_End);
      m_pTimeTextCtrl_End->SetValue(dTime);
   }
 
   wxDateEvent dummyDateEvent;
   this->OnDatePicker_End(dummyDateEvent);
}

References NumericConverter::GetValue(), m_DateTime_End, m_pDatePickerCtrl_End, m_pTimeTextCtrl_End, OnDatePicker_End(), and NumericTextCtrl::SetValue().

Here is the call graph for this function:

OnTimeText_Start()

void TimerRecordDialog::OnTimeText_Start ( wxCommandEvent &  event )

private

Definition at line 265 of file TimerRecordDialog.cpp.

{
   //v NumericTextCtrl doesn't implement upper ranges, i.e.,
   // if I tell it "024 h 060 m 060 s", then
   // user increments the hours past 23, it rolls over to 0
   // (although if you increment below 0, it stays at 0).
   // So instead, set the max to 99 and just catch hours > 24 and fix the ctrls.
   double dTime = m_pTimeTextCtrl_Start->GetValue();
   long days = (long)(dTime / (24.0 * 3600.0));
   if (days > 0) {
      dTime -= (double)days * 24.0 * 3600.0;
      m_DateTime_Start += wxTimeSpan::Days(days);
      m_pDatePickerCtrl_Start->SetValue(m_DateTime_Start);
      m_pTimeTextCtrl_Start->SetValue(dTime);
   }
 
   wxDateEvent dummyDateEvent;
   this->OnDatePicker_Start(dummyDateEvent);
}

References NumericConverter::GetValue(), m_DateTime_Start, m_pDatePickerCtrl_Start, m_pTimeTextCtrl_Start, OnDatePicker_Start(), and NumericTextCtrl::SetValue().

Here is the call graph for this function:

PopulateOrExchange()

void TimerRecordDialog::PopulateOrExchange ( ShuttleGui &  S )

private

Definition at line 816 of file TimerRecordDialog.cpp.

{
   bool bAutoSave = gPrefs->ReadBool("/TimerRecord/AutoSave", false);
   bool bAutoExport = gPrefs->ReadBool("/TimerRecord/AutoExport", false);
   int iPostTimerRecordAction = gPrefs->ReadLong("/TimerRecord/PostAction", 0);
 
   S.SetBorder(5);
   using Options = NumericTextCtrl::Options;
   /* i18n-hint a format string for hours, minutes, and seconds */
   auto strFormat = XO("099 h 060 m 060 s");
   /* i18n-hint a format string for days, hours, minutes, and seconds */
   auto strFormat1 = XO("099 days 024 h 060 m 060 s");
 
   S.StartMultiColumn(2, wxCENTER);
   {
      S.StartVerticalLay(true);
      {
         /* i18n-hint: This string is used to configure the controls for times when the recording is
         * started and stopped. As such it is important that only the alphabetic parts of the string
         * are translated, with the numbers left exactly as they are.
         * The 'h' indicates the first number displayed is hours, the 'm' indicates the second number
         * displayed is minutes, and the 's' indicates that the third number displayed is seconds.
         */
         S.StartStatic(XO("Start Date and Time"), true);
         {
            m_pDatePickerCtrl_Start =
               safenew wxDatePickerCtrl(S.GetParent(), // wxWindow *parent,
               ID_DATEPICKER_START, // wxWindowID id,
               m_DateTime_Start); // const wxDateTime& dt = wxDefaultDateTime,
            // const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDP_DEFAULT | wxDP_SHOWCENTURY, const wxValidator& validator = wxDefaultValidator, const wxString& name = "datectrl")
            m_pDatePickerCtrl_Start->SetRange(wxDateTime::Today(), wxInvalidDateTime); // No backdating.
#if wxUSE_ACCESSIBILITY
            m_pDatePickerCtrl_Start->SetAccessible( safenew DatePickerCtrlAx(m_pDatePickerCtrl_Start));
#endif
            S.Name(XO("Start Date"))
               .AddWindow(m_pDatePickerCtrl_Start);
 
            m_pTimeTextCtrl_Start = safenew NumericTextCtrl(FormatterContext::EmptyContext(),
               S.GetParent(), ID_TIMETEXT_START, NumericConverterType_TIME(),
               {}, 0,
               Options{}
                  .MenuEnabled(false)
                  .CustomFormat(strFormat)
                  .Value(true, wxDateTime_to_AudacityTime(m_DateTime_Start)));
            S.Name(XO("Start Time"))
               .AddWindow(m_pTimeTextCtrl_Start);
         }
         S.EndStatic();
 
         S.StartStatic(XO("End Date and Time"), true);
         {
            m_pDatePickerCtrl_End =
               safenew wxDatePickerCtrl(S.GetParent(), // wxWindow *parent,
               ID_DATEPICKER_END, // wxWindowID id,
               m_DateTime_End); // const wxDateTime& dt = wxDefaultDateTime,
            // const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
            //                            long style = wxDP_DEFAULT | wxDP_SHOWCENTURY,
            //                            const wxValidator& validator = wxDefaultValidator,
            //                            const wxString& name = "datectrl")
            m_pDatePickerCtrl_End->SetRange(m_DateTime_Start, wxInvalidDateTime); // No backdating.
#if wxUSE_ACCESSIBILITY
            m_pDatePickerCtrl_End->SetAccessible( safenew DatePickerCtrlAx(m_pDatePickerCtrl_End));
#endif
            S.Name(XO("End Date"))
               .AddWindow(m_pDatePickerCtrl_End);
 
            m_pTimeTextCtrl_End = safenew NumericTextCtrl(FormatterContext::EmptyContext(),
               S.GetParent(), ID_TIMETEXT_END, NumericConverterType_TIME(),
               {}, 0,
               Options{}
                  .MenuEnabled(false)
                  .CustomFormat(strFormat)
                  .Value(true, wxDateTime_to_AudacityTime(m_DateTime_End)));
            S.Name(XO("End Time"))
               .AddWindow(m_pTimeTextCtrl_End);
         }
         S.EndStatic();
 
         S.StartStatic(XO("Duration"), true);
         {
            m_pTimeTextCtrl_Duration = safenew NumericTextCtrl(FormatterContext::EmptyContext(),
               S.GetParent(), ID_TIMETEXT_DURATION, NumericConverterType_TIME(),
               {}, 0,
               Options{}
                  .MenuEnabled(false)
                  .CustomFormat(strFormat1)
                  .Value(true, m_TimeSpan_Duration.GetSeconds().ToDouble()));
            /* i18n-hint: This string is used to configure the controls which shows the recording
            * duration. As such it is important that only the alphabetic parts of the string
            * are translated, with the numbers left exactly as they are.
            * The string 'days' indicates that the first number in the control will be the number of days,
            * then the 'h' indicates the second number displayed is hours, the 'm' indicates the third
            * number displayed is minutes, and the 's' indicates that the fourth number displayed is
            * seconds.
            */
            S.Name(XO("Duration"))
               .AddWindow(m_pTimeTextCtrl_Duration);
         }
         S.EndStatic();
      }
      S.EndVerticalLay();
 
      S.StartVerticalLay(true);
      {
         S.StartStatic(XO("Automatic Save"), true);
         {
            // If checked, the project will be saved when the recording is completed
            m_pTimerAutoSaveCheckBoxCtrl = S.Id(ID_AUTOSAVE_CHECKBOX).AddCheckBox(XXO("Enable &Automatic Save?"),
                                                                                    bAutoSave);
            S.StartMultiColumn(3, wxEXPAND);
            {
               TranslatableString sInitialValue;
               auto sSaveValue = ProjectFileIO::Get(mProject).GetFileName();
               if (!sSaveValue.empty()) {
                  m_fnAutoSaveFile.Assign(sSaveValue);
                  sInitialValue = XO("Current Project");
               }
               S.AddPrompt(XXO("Save Project As:"));
               m_pTimerSavePathTextCtrl = NewPathControl(
                  S.GetParent(), ID_AUTOSAVEPATH_TEXT,
                  XO("Save Project As:"), sInitialValue);
               m_pTimerSavePathTextCtrl->SetReadOnly(true);
               S.AddWindow(m_pTimerSavePathTextCtrl);
               m_pTimerSavePathButtonCtrl = S.Id(ID_AUTOSAVEPATH_BUTTON).AddButton(XXO("Select..."));
               }
            S.EndMultiColumn();
         }
         S.EndStatic();
 
         S.StartStatic(XO("Automatic Export"), true);
         {
            m_pTimerAutoExportCheckBoxCtrl = S.Id(ID_AUTOEXPORT_CHECKBOX).AddCheckBox(XXO("Enable Automatic &Export?"), bAutoExport);
            S.StartMultiColumn(3, wxEXPAND);
            {
               S.AddPrompt(XXO("Export Project As:"));
               m_pTimerExportPathTextCtrl = NewPathControl(
                  S.GetParent(), ID_AUTOEXPORTPATH_TEXT,
                  XO("Export Project As:"), {});
               m_pTimerExportPathTextCtrl->SetReadOnly(true);
               m_pTimerExportPathTextCtrl->SetValue(m_fnAutoExportFile.GetFullPath());
               S.AddWindow(m_pTimerExportPathTextCtrl);
               m_pTimerExportPathButtonCtrl = S.Id(ID_AUTOEXPORTPATH_BUTTON).AddButton(XXO("Select..."));
            }
            S.EndMultiColumn();
         }
         S.EndStatic();
 
         S.StartStatic(XO("Options"), true);
         {
 
            S.StartMultiColumn(1, wxEXPAND);
            {
               S.SetStretchyCol( 0 );
               m_pTimerAfterCompleteChoiceCtrl = S.AddChoice(XXO("After Recording completes:"),
                     {
                        XO("Do nothing") ,
                        XO("Exit Audacity") ,
                  #ifdef __WINDOWS__
                        XO("Restart system") ,
                        XO("Shutdown system") ,
                  #endif
                     },
                     iPostTimerRecordAction
               );
            }
            S.EndMultiColumn();
         }
         S.EndStatic();
 
      }
      S.EndVerticalLay();
   }
   S.EndMultiColumn();
 
   // MY: Added the help button here
   S.AddStandardButtons(eOkButton | eCancelButton | eHelpButton);
 
   Layout();
   Fit();
   SetMinSize(GetSize());
   Center();
 
   EnableDisableAutoControls(bAutoSave, CONTROL_GROUP_SAVE);
   EnableDisableAutoControls(bAutoExport, CONTROL_GROUP_EXPORT);
}

References CONTROL_GROUP_EXPORT, CONTROL_GROUP_SAVE, eCancelButton, eHelpButton, FormatterContext::EmptyContext(), EnableDisableAutoControls(), eOkButton, ProjectFileIO::Get(), ProjectFileIO::GetFileName(), gPrefs, ID_AUTOEXPORT_CHECKBOX, ID_AUTOEXPORTPATH_BUTTON, ID_AUTOEXPORTPATH_TEXT, ID_AUTOSAVE_CHECKBOX, ID_AUTOSAVEPATH_BUTTON, ID_AUTOSAVEPATH_TEXT, ID_DATEPICKER_END, ID_DATEPICKER_START, ID_TIMETEXT_DURATION, ID_TIMETEXT_END, ID_TIMETEXT_START, m_DateTime_End, m_DateTime_Start, m_fnAutoExportFile, m_fnAutoSaveFile, m_pDatePickerCtrl_End, m_pDatePickerCtrl_Start, m_pTimerAfterCompleteChoiceCtrl, m_pTimerAutoExportCheckBoxCtrl, m_pTimerAutoSaveCheckBoxCtrl, m_pTimerExportPathButtonCtrl, m_pTimerExportPathTextCtrl, m_pTimerSavePathButtonCtrl, m_pTimerSavePathTextCtrl, m_pTimeTextCtrl_Duration, m_pTimeTextCtrl_End, m_pTimeTextCtrl_Start, m_TimeSpan_Duration, mProject, NewPathControl(), NumericConverterType_TIME(), audacity::BasicSettings::ReadBool(), audacity::BasicSettings::ReadLong(), S, safenew, wxTextCtrlWrapper::SetReadOnly(), wxDateTime_to_AudacityTime(), XO(), and XXO().

Here is the call graph for this function:

PreActionDelay()

ProgressResult TimerRecordDialog::PreActionDelay ( int  iActionIndex, TimerRecordCompletedActions  eCompletedActions  )

private

Definition at line 1120 of file TimerRecordDialog.cpp.

{
   auto sAction = Verbatim( m_pTimerAfterCompleteChoiceCtrl
      ->GetString(iActionIndex) );
 
   /* i18n-hint: %s is one of "Do nothing", "Exit Audacity", "Restart system",
      or "Shutdown system", and
      "in" means after a duration of time, shown below this string */
   auto sCountdownLabel = XO("%s in:").Format( sAction );
 
   // Two column layout.
   TimerProgressDialog::MessageTable columns{
      {
         XO("Timer Recording completed.") ,
         {} ,
         XO("Recording Saved:") ,
         XO("Recording Exported:") ,
         XO("Action after Timer Recording:") ,
      },
      {
         {} ,
         {} ,
         ((eCompletedActions & TR_ACTION_SAVED) ? XO("Yes") : XO("No")) ,
         ((eCompletedActions & TR_ACTION_EXPORTED) ? XO("Yes") : XO("No")) ,
         sAction ,
      },
   };
 
 
   wxDateTime dtNow = wxDateTime::UNow();
   wxTimeSpan tsWait = wxTimeSpan(0, 1, 0, 0);
   wxDateTime dtActionTime = dtNow.Add(tsWait);
 
   TimerProgressDialog dlgAction(tsWait.GetMilliseconds().GetValue(),
                          XO("Audacity Timer Record - Waiting"),
                          columns,
                          pdlgHideStopButton | pdlgHideElapsedTime,
                          sCountdownLabel);
 
   auto iUpdateResult = ProgressResult::Success;
   bool bIsTime = false;
   while (iUpdateResult == ProgressResult::Success && !bIsTime)
   {
      iUpdateResult = dlgAction.UpdateProgress();
      using namespace std::chrono;
      std::this_thread::sleep_for(kTimerInterval);
      bIsTime = (dtActionTime <= wxDateTime::UNow());
   }
   return iUpdateResult;
}

References kTimerInterval, m_pTimerAfterCompleteChoiceCtrl, pdlgHideElapsedTime, pdlgHideStopButton, BasicUI::Success, TR_ACTION_EXPORTED, TR_ACTION_SAVED, TimerProgressDialog::UpdateProgress(), Verbatim(), and XO().

Referenced by ExecutePostRecordActions().

Here is the call graph for this function:

Here is the caller graph for this function:

RunWaitDialog()

int TimerRecordDialog::RunWaitDialog

(

)

Runs the wait for start dialog. Returns false if the user clicks stop.

Runs the wait for start dialog. Returns -1 if the user clicks stop while we are recording or if the post recording actions fail.

Definition at line 521 of file TimerRecordDialog.cpp.

{
   auto updateResult = ProgressResult::Success;
 
   const auto gAudioIO = AudioIO::Get();
   gAudioIO->DelayActions(true);
   {
      auto cleanup = finally([gAudioIO]{ gAudioIO->DelayActions(false); });
 
      if (m_DateTime_Start > wxDateTime::UNow())
         updateResult = this->WaitForStart();
 
      if (updateResult != ProgressResult::Success)  {
         // Don't proceed, but don't treat it as canceled recording. User just canceled waiting.
         return POST_TIMER_RECORD_CANCEL_WAIT;
      } else {
         // Record for specified time.
         ProjectAudioManager::Get( mProject ).OnRecord(false);
         bool bIsRecording = true;
 
         auto sPostAction = Verbatim(
            m_pTimerAfterCompleteChoiceCtrl->GetStringSelection() );
 
         // Two column layout.
         TimerProgressDialog::MessageTable columns{
            {
               XO("Recording start:") ,
               XO("Duration:") ,
               XO("Recording end:") ,
               {} ,
               XO("Automatic Save enabled:") ,
               XO("Automatic Export enabled:") ,
               XO("Action after Timer Recording:") ,
            },
            {
               GetDisplayDate(m_DateTime_Start) ,
               Verbatim( m_TimeSpan_Duration.Format() ),
               GetDisplayDate(m_DateTime_End) ,
               {} ,
               (m_bAutoSaveEnabled ? XO("Yes") : XO("No")) ,
               (m_bAutoExportEnabled ? XO("Yes") : XO("No")) ,
               sPostAction ,
            }
         };
 
         TimerProgressDialog
            progress(m_TimeSpan_Duration.GetMilliseconds().GetValue(),
                     XO("Audacity Timer Record Progress"),
                     columns,
                     pdlgHideCancelButton | pdlgConfirmStopCancel);
 
         // Make sure that start and end time are updated, so we always get the full
         // duration, even if there's some delay getting here.
         wxTimerEvent dummyTimerEvent;
         this->OnTimer(dummyTimerEvent);
 
         // Loop for progress display during recording.
         while (bIsRecording && (updateResult == ProgressResult::Success)) {
            updateResult = progress.UpdateProgress();
            using namespace std::chrono;
            std::this_thread::sleep_for(kTimerInterval);
            bIsRecording = (wxDateTime::UNow() <= m_DateTime_End); // Call UNow() again for extra accuracy...
         }
      }
   }
 
   // Must do this AFTER the timer project dialog has been deleted to ensure the application
   // responds to the AUDIOIO events...see not about bug #334 in the ProgressDialog constructor.
   ProjectAudioManager::Get( mProject ).Stop();
 
   // Let the caller handle cancellation or failure from recording progress.
   if (updateResult == ProgressResult::Cancelled || updateResult == ProgressResult::Failed)
      return POST_TIMER_RECORD_CANCEL;
 
   return ExecutePostRecordActions((updateResult == ProgressResult::Stopped));
}

References BasicUI::Cancelled, ExecutePostRecordActions(), AudioIO::Get(), ProjectAudioManager::Get(), GetDisplayDate(), kTimerInterval, m_bAutoExportEnabled, m_bAutoSaveEnabled, m_DateTime_End, m_DateTime_Start, m_pTimerAfterCompleteChoiceCtrl, m_TimeSpan_Duration, mProject, ProjectAudioManager::OnRecord(), OnTimer(), pdlgConfirmStopCancel, pdlgHideCancelButton, POST_TIMER_RECORD_CANCEL, POST_TIMER_RECORD_CANCEL_WAIT, ProjectAudioManager::Stop(), BasicUI::Stopped, BasicUI::Success, TimerProgressDialog::UpdateProgress(), Verbatim(), WaitForStart(), and XO().

Referenced by anonymous_namespace{TimerRecordDialog.cpp}::OnTimerRecord().

Here is the call graph for this function:

Here is the caller graph for this function:

TransferDataFromWindow()

bool TimerRecordDialog::TransferDataFromWindow ( )

overrideprivate

Definition at line 1002 of file TimerRecordDialog.cpp.

{
   double dTime;
   long hr;
   long min;
   long sec;
 
   m_DateTime_Start = m_pDatePickerCtrl_Start->GetValue();
   dTime = m_pTimeTextCtrl_Start->GetValue();
   hr = (long)(dTime / 3600.0);
   min = (long)((dTime - (hr * 3600.0)) / 60.0);
   sec = (long)(dTime - (hr * 3600.0) - (min * 60.0));
   m_DateTime_Start.SetHour(hr);
   m_DateTime_Start.SetMinute(min);
   m_DateTime_Start.SetSecond(sec);
 
   m_DateTime_End = m_pDatePickerCtrl_End->GetValue();
   dTime = m_pTimeTextCtrl_End->GetValue();
   hr = (long)(dTime / 3600.0);
   min = (long)((dTime - (hr * 3600.0)) / 60.0);
   sec = (long)(dTime - (hr * 3600.0) - (min * 60.0));
   m_DateTime_End.SetHour(hr);
   m_DateTime_End.SetMinute(min);
   m_DateTime_End.SetSecond(sec);
 
   m_TimeSpan_Duration = m_DateTime_End - m_DateTime_Start;
 
   // Pull the settings from the auto save/export controls and write to the pref file
   m_bAutoSaveEnabled = m_pTimerAutoSaveCheckBoxCtrl->GetValue();
   m_bAutoExportEnabled = m_pTimerAutoExportCheckBoxCtrl->GetValue();
 
   // MY: Obtain the index from the choice control so we can save to the prefs file
   int iPostRecordAction = m_pTimerAfterCompleteChoiceCtrl->GetSelection();
 
   // Save the options back to the prefs file
   gPrefs->Write("/TimerRecord/AutoSave", m_bAutoSaveEnabled);
   gPrefs->Write("/TimerRecord/AutoExport", m_bAutoExportEnabled);
   gPrefs->Write("/TimerRecord/PostAction", iPostRecordAction);
 
   return true;
}

References NumericConverter::GetValue(), gPrefs, m_bAutoExportEnabled, m_bAutoSaveEnabled, m_DateTime_End, m_DateTime_Start, m_pDatePickerCtrl_End, m_pDatePickerCtrl_Start, m_pTimerAfterCompleteChoiceCtrl, m_pTimerAutoExportCheckBoxCtrl, m_pTimerAutoSaveCheckBoxCtrl, m_pTimeTextCtrl_End, m_pTimeTextCtrl_Start, m_TimeSpan_Duration, min(), and audacity::BasicSettings::Write().

Referenced by OnOK().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateDuration()

void TimerRecordDialog::UpdateDuration ( )

private

Definition at line 1045 of file TimerRecordDialog.cpp.

{
   m_TimeSpan_Duration = m_DateTime_End - m_DateTime_Start;
   m_pTimeTextCtrl_Duration->SetValue(m_TimeSpan_Duration.GetSeconds().ToDouble());
}

References m_DateTime_End, m_DateTime_Start, m_pTimeTextCtrl_Duration, m_TimeSpan_Duration, and NumericTextCtrl::SetValue().

Referenced by OnDatePicker_End().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateEnd()

void TimerRecordDialog::UpdateEnd ( )

private

Definition at line 1052 of file TimerRecordDialog.cpp.

{
   //v Use remaining disk -> record time calcs from AudacityProject::OnTimer to set range?
   m_DateTime_End = m_DateTime_Start + m_TimeSpan_Duration;
   //wxLogDebug( "Time start %s end %s",
   //   m_DateTime_Start.FormatISOCombined(' '),
   //   m_DateTime_End.FormatISOCombined(' ') );
 
   // Disable the range limitation (to fix Bug 1749 and 1978)
   // Otherwise SetVallue asserts when going back in time.
   m_pDatePickerCtrl_End->SetRange(wxInvalidDateTime, wxInvalidDateTime);
   m_pDatePickerCtrl_End->SetValue(m_DateTime_End);
   // Re-enable range limitation to constrain user input.
   m_pDatePickerCtrl_End->SetRange(m_DateTime_Start, wxInvalidDateTime); // No backdating.
   m_pDatePickerCtrl_End->Refresh();
   m_pTimeTextCtrl_End->SetValue(wxDateTime_to_AudacityTime(m_DateTime_End));
}

References m_DateTime_End, m_DateTime_Start, m_pDatePickerCtrl_End, m_pTimeTextCtrl_End, m_TimeSpan_Duration, NumericTextCtrl::SetValue(), and wxDateTime_to_AudacityTime().

Referenced by OnDatePicker_Start(), OnTimer(), and OnTimeText_Duration().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateTextBoxControls()

void TimerRecordDialog::UpdateTextBoxControls ( )

private

Definition at line 508 of file TimerRecordDialog.cpp.

                                              {
   // Will update the text box controls
   m_pTimerSavePathTextCtrl->SetValue(m_fnAutoSaveFile.GetFullPath());
   m_pTimerExportPathTextCtrl->SetValue(m_fnAutoExportFile.GetFullPath());
 
   // MY: Ensure we still display "Current Project" if this has already been saved
   if (m_bProjectAlreadySaved) {
      m_pTimerSavePathTextCtrl->SetValue(_("Current Project"));
   }
}

References _, m_bProjectAlreadySaved, m_fnAutoExportFile, m_fnAutoSaveFile, m_pTimerExportPathTextCtrl, and m_pTimerSavePathTextCtrl.

Referenced by OnAutoExportPathButton_Click(), and OnAutoSavePathButton_Click().

Here is the caller graph for this function:

WaitForStart()

ProgressResult TimerRecordDialog::WaitForStart ( )

private

Definition at line 1070 of file TimerRecordDialog.cpp.

{
   // MY: The Waiting For Start dialog now shows what actions will occur after recording has completed
   auto sPostAction = Verbatim(
         m_pTimerAfterCompleteChoiceCtrl->GetStringSelection() );
 
   // Two column layout.
   TimerProgressDialog::MessageTable columns{
      {
         XO("Waiting to start recording at:") ,
         XO("Recording duration:") ,
         XO("Scheduled to stop at:") ,
         {} ,
         XO("Automatic Save enabled:") ,
         XO("Automatic Export enabled:") ,
         XO("Action after Timer Recording:") ,
      },
      {
         GetDisplayDate(m_DateTime_Start),
         Verbatim( m_TimeSpan_Duration.Format() ),
         GetDisplayDate(m_DateTime_End) ,
         {} ,
         (m_bAutoSaveEnabled ? XO("Yes") : XO("No")) ,
         (m_bAutoExportEnabled ? XO("Yes") : XO("No")) ,
         sPostAction ,
      },
   };
 
   wxDateTime startWait_DateTime = wxDateTime::UNow();
   wxTimeSpan waitDuration = m_DateTime_Start - startWait_DateTime;
   TimerProgressDialog progress(waitDuration.GetMilliseconds().GetValue(),
      XO("Audacity Timer Record - Waiting for Start"),
      columns,
      pdlgHideStopButton | pdlgConfirmStopCancel | pdlgHideElapsedTime,
      /* i18n-hint: "in" means after a duration of time,
         which is shown below this string */
      XO("Recording will commence in:"));
 
   auto updateResult = ProgressResult::Success;
   bool bIsRecording = false;
   while (updateResult == ProgressResult::Success && !bIsRecording)
   {
      updateResult = progress.UpdateProgress();
      using namespace std::chrono;
      std::this_thread::sleep_for(kTimerInterval);
      bIsRecording = (m_DateTime_Start <= wxDateTime::UNow());
   }
   return updateResult;
}

References GetDisplayDate(), kTimerInterval, m_bAutoExportEnabled, m_bAutoSaveEnabled, m_DateTime_End, m_DateTime_Start, m_pTimerAfterCompleteChoiceCtrl, m_TimeSpan_Duration, pdlgConfirmStopCancel, pdlgHideElapsedTime, pdlgHideStopButton, BasicUI::Success, TimerProgressDialog::UpdateProgress(), Verbatim(), and XO().

Referenced by RunWaitDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_AutoExportParameters

ExportProcessor::Parameters TimerRecordDialog::m_AutoExportParameters

private

Definition at line 149 of file TimerRecordDialog.h.

Referenced by ExecutePostRecordActions(), and OnAutoExportPathButton_Click().

m_bAutoExportEnabled

bool TimerRecordDialog::m_bAutoExportEnabled

private

Definition at line 144 of file TimerRecordDialog.h.

Referenced by ExecutePostRecordActions(), RunWaitDialog(), TransferDataFromWindow(), and WaitForStart().

m_bAutoSaveEnabled

bool TimerRecordDialog::m_bAutoSaveEnabled

private

Definition at line 142 of file TimerRecordDialog.h.

Referenced by ExecutePostRecordActions(), RunWaitDialog(), TransferDataFromWindow(), and WaitForStart().

m_bProjectAlreadySaved

bool TimerRecordDialog::m_bProjectAlreadySaved

private

Definition at line 150 of file TimerRecordDialog.h.

Referenced by ExecutePostRecordActions(), OnAutoSavePathButton_Click(), and UpdateTextBoxControls().

m_bProjectCleanupRequired

bool TimerRecordDialog::m_bProjectCleanupRequired

private

Definition at line 139 of file TimerRecordDialog.h.

m_DateTime_End

wxDateTime TimerRecordDialog::m_DateTime_End

private

Definition at line 113 of file TimerRecordDialog.h.

Referenced by OnDatePicker_End(), OnTimeText_End(), PopulateOrExchange(), RunWaitDialog(), TransferDataFromWindow(), UpdateDuration(), UpdateEnd(), and WaitForStart().

m_DateTime_Start

wxDateTime TimerRecordDialog::m_DateTime_Start

private

Definition at line 112 of file TimerRecordDialog.h.

Referenced by OnDatePicker_End(), OnDatePicker_Start(), OnTimer(), OnTimeText_Start(), PopulateOrExchange(), RunWaitDialog(), TransferDataFromWindow(), UpdateDuration(), UpdateEnd(), and WaitForStart().

m_fnAutoExportFile

wxFileName TimerRecordDialog::m_fnAutoExportFile

private

Definition at line 145 of file TimerRecordDialog.h.

Referenced by ExecutePostRecordActions(), OnAutoExportPathButton_Click(), OnOK(), PopulateOrExchange(), and UpdateTextBoxControls().

m_fnAutoSaveFile

wxFileName TimerRecordDialog::m_fnAutoSaveFile

private

Definition at line 143 of file TimerRecordDialog.h.

Referenced by ExecutePostRecordActions(), OnAutoSavePathButton_Click(), OnOK(), PopulateOrExchange(), and UpdateTextBoxControls().

m_iAutoExportChannels

int TimerRecordDialog::m_iAutoExportChannels {0}

private

Definition at line 148 of file TimerRecordDialog.h.

Referenced by ExecutePostRecordActions(), and OnAutoExportPathButton_Click().

m_iAutoExportSampleRate

int TimerRecordDialog::m_iAutoExportSampleRate {0}

private

Definition at line 147 of file TimerRecordDialog.h.

Referenced by ExecutePostRecordActions(), and OnAutoExportPathButton_Click().

m_pDatePickerCtrl_End

wxDatePickerCtrl* TimerRecordDialog::m_pDatePickerCtrl_End

private

Definition at line 120 of file TimerRecordDialog.h.

Referenced by OnDatePicker_End(), OnTimeText_End(), PopulateOrExchange(), TransferDataFromWindow(), and UpdateEnd().

m_pDatePickerCtrl_Start

wxDatePickerCtrl* TimerRecordDialog::m_pDatePickerCtrl_Start

private

Definition at line 117 of file TimerRecordDialog.h.

Referenced by OnDatePicker_Start(), OnTimer(), OnTimeText_Start(), PopulateOrExchange(), and TransferDataFromWindow().

m_pTimerAfterCompleteChoiceCtrl

wxChoice* TimerRecordDialog::m_pTimerAfterCompleteChoiceCtrl

private

Definition at line 136 of file TimerRecordDialog.h.

Referenced by EnableDisableAutoControls(), ExecutePostRecordActions(), PopulateOrExchange(), PreActionDelay(), RunWaitDialog(), TransferDataFromWindow(), and WaitForStart().

m_pTimerAutoExportCheckBoxCtrl

wxCheckBox* TimerRecordDialog::m_pTimerAutoExportCheckBoxCtrl

private

Definition at line 131 of file TimerRecordDialog.h.

Referenced by EnableDisableAutoControls(), OnAutoExportCheckBox_Change(), OnOK(), PopulateOrExchange(), and TransferDataFromWindow().

m_pTimerAutoSaveCheckBoxCtrl

wxCheckBox* TimerRecordDialog::m_pTimerAutoSaveCheckBoxCtrl

private

Definition at line 128 of file TimerRecordDialog.h.

Referenced by EnableDisableAutoControls(), OnAutoSaveCheckBox_Change(), OnOK(), PopulateOrExchange(), and TransferDataFromWindow().

m_pTimerExportPathButtonCtrl

wxButton* TimerRecordDialog::m_pTimerExportPathButtonCtrl

private

Definition at line 133 of file TimerRecordDialog.h.

Referenced by EnableDisableAutoControls(), and PopulateOrExchange().

m_pTimerExportPathTextCtrl

wxTextCtrlWrapper* TimerRecordDialog::m_pTimerExportPathTextCtrl

private

Definition at line 132 of file TimerRecordDialog.h.

Referenced by EnableDisableAutoControls(), OnAutoExportPathButton_Click(), PopulateOrExchange(), and UpdateTextBoxControls().

m_pTimerSavePathButtonCtrl

wxButton* TimerRecordDialog::m_pTimerSavePathButtonCtrl

private

Definition at line 130 of file TimerRecordDialog.h.

Referenced by EnableDisableAutoControls(), and PopulateOrExchange().

m_pTimerSavePathTextCtrl

wxTextCtrlWrapper* TimerRecordDialog::m_pTimerSavePathTextCtrl

private

Definition at line 129 of file TimerRecordDialog.h.

Referenced by EnableDisableAutoControls(), PopulateOrExchange(), and UpdateTextBoxControls().

m_pTimeTextCtrl_Duration

NumericTextCtrl* TimerRecordDialog::m_pTimeTextCtrl_Duration

private

Definition at line 123 of file TimerRecordDialog.h.

Referenced by OnTimeText_Duration(), PopulateOrExchange(), and UpdateDuration().

m_pTimeTextCtrl_End

NumericTextCtrl* TimerRecordDialog::m_pTimeTextCtrl_End

private

Definition at line 121 of file TimerRecordDialog.h.

Referenced by OnDatePicker_End(), OnTimeText_End(), PopulateOrExchange(), TransferDataFromWindow(), and UpdateEnd().

m_pTimeTextCtrl_Start

NumericTextCtrl* TimerRecordDialog::m_pTimeTextCtrl_Start

private

Definition at line 118 of file TimerRecordDialog.h.

Referenced by OnDatePicker_Start(), OnTimer(), OnTimeText_Start(), PopulateOrExchange(), and TransferDataFromWindow().

m_sAutoExportFormat

wxString TimerRecordDialog::m_sAutoExportFormat

private

Definition at line 146 of file TimerRecordDialog.h.

Referenced by ExecutePostRecordActions(), and OnAutoExportPathButton_Click().

m_timer

wxTimer TimerRecordDialog::m_timer

private

Definition at line 125 of file TimerRecordDialog.h.

Referenced by OnOK().

m_TimeSpan_Duration

wxTimeSpan TimerRecordDialog::m_TimeSpan_Duration

private

Definition at line 114 of file TimerRecordDialog.h.

Referenced by OnOK(), OnTimeText_Duration(), PopulateOrExchange(), RunWaitDialog(), TransferDataFromWindow(), UpdateDuration(), UpdateEnd(), and WaitForStart().

mProject

AudacityProject& TimerRecordDialog::mProject

private

Definition at line 110 of file TimerRecordDialog.h.

Referenced by ExecutePostRecordActions(), OnAutoExportPathButton_Click(), OnAutoSavePathButton_Click(), OnOK(), PopulateOrExchange(), and RunWaitDialog().

---

The documentation for this class was generated from the following files:

• TimerRecordDialog.h
• TimerRecordDialog.cpp