ProgressDialog Class Reference

ProgressDialog Class. More...

#include <ProgressDialog.h>

Inheritance diagram for ProgressDialog:

Collaboration diagram for ProgressDialog:

Public Types
using	MessageColumn = std::vector< TranslatableString >
using	MessageTable = std::vector< MessageColumn >

Public Member Functions
	ProgressDialog ()
	Methods for ProgressDialog. More...
	ProgressDialog (const TranslatableString &title, const TranslatableString &message={}, int flags=pdlgDefaultFlags, const TranslatableString &sRemainingLabelText={})
virtual	~ProgressDialog ()
bool	Create (const TranslatableString &title, const TranslatableString &message={}, int flags=pdlgDefaultFlags, const TranslatableString &sRemainingLabelText={})
void	Reinit ()
ProgressResult	Update (int value, const TranslatableString &message={})
ProgressResult	Update (double current, const TranslatableString &message={})
ProgressResult	Update (double current, double total, const TranslatableString &message={})
ProgressResult	Update (wxULongLong_t current, wxULongLong_t total, const TranslatableString &message={})
ProgressResult	Update (wxLongLong current, wxLongLong total, const TranslatableString &message={})
ProgressResult	Update (wxLongLong_t current, wxLongLong_t total, const TranslatableString &message={})
ProgressResult	Update (int current, int total, const TranslatableString &message={})
void	SetMessage (const TranslatableString &message)
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

Protected Member Functions
	ProgressDialog (const TranslatableString &title, const MessageTable &columns, int flags=pdlgDefaultFlags, const TranslatableString &sRemainingLabelText={})
bool	Create (const TranslatableString &title, const MessageTable &columns, int flags=pdlgDefaultFlags, const TranslatableString &sRemainingLabelText={})

Protected Attributes
wxWindowRef	mHadFocus
wxStaticText *	mElapsed
wxStaticText *	mRemaining
wxGauge *	mGauge
wxLongLong_t	mStartTime
wxLongLong_t	mLastUpdate
wxLongLong_t	mYieldTimer
int	mLastValue
bool	mCancel
bool	mStop
bool	mIsTransparent
bool	m_bShowElapsedTime = true
bool	m_bConfirmAction = false

Private Member Functions
void	Init ()
bool	SearchForWindow (const wxWindowList &list, const wxWindow *searchfor) const
void	OnCancel (wxCommandEvent &e)
void	OnStop (wxCommandEvent &e)
void	OnCloseWindow (wxCloseEvent &e)
void	Beep () const
bool	ConfirmAction (const TranslatableString &sPrompt, const TranslatableString &sTitle, int iButtonID=-1)
void	AddMessageAsColumn (wxBoxSizer *pSizer, const MessageColumn &column, bool bFirstColumn)

Private Attributes
wxEventLoopGuarantor	mLoop
std::unique_ptr< wxWindowDisabler >	mDisable
wxStaticText *	mMessage {}
int	mLastW { 0 }
int	mLastH { 0 }

Detailed Description

ProgressDialog Class.

Custom progress dialog with Audacity specific semantics.

Definition at line 50 of file ProgressDialog.h.

Member Typedef Documentation

MessageColumn

using ProgressDialog::MessageColumn = std::vector< TranslatableString >

Definition at line 61 of file ProgressDialog.h.

MessageTable

using ProgressDialog::MessageTable = std::vector< MessageColumn >

Definition at line 62 of file ProgressDialog.h.

Constructor & Destructor Documentation

ProgressDialog() [1/3]

ProgressDialog::ProgressDialog

(

)

Methods for ProgressDialog.

Definition at line 996 of file ProgressDialog.cpp.

:  wxDialogWrapper()
{
}

ProgressDialog() [2/3]

ProgressDialog::ProgressDialog	(	const TranslatableString &	title,
		const TranslatableString &	message = {},
		int	flags = pdlgDefaultFlags,
		const TranslatableString &	sRemainingLabelText = {}
	)

Definition at line 1001 of file ProgressDialog.cpp.

:  wxDialogWrapper()
{
   Create(title, message, flags, sRemainingLabelText);
}

References Create(), and title.

Here is the call graph for this function:

ProgressDialog() [3/3]

ProgressDialog::ProgressDialog ( const TranslatableString &  title, const MessageTable &  columns, int  flags = pdlgDefaultFlags, const TranslatableString &  sRemainingLabelText = {}  )

protected

Definition at line 1010 of file ProgressDialog.cpp.

:  wxDialogWrapper()
{
   Create(title, columns, flags, sRemainingLabelText);
}

References Create(), and title.

Here is the call graph for this function:

~ProgressDialog()

ProgressDialog::~ProgressDialog ( )

virtual

Definition at line 1022 of file ProgressDialog.cpp.

{
   // Delete the window disabler before hiding the dialog to allow
   // focus to return to the original window.
   mDisable.reset();
 
   if (IsShown())
   {
      Show(false);
 
      Beep();
   }
 
#if defined(__WXGTK__)
   // Under GTK, when applying any effect that prompts the user, it's more than
   // like that FindFocus() will return NULL.  So, make sure something has focus.
   if (GetParent()) {
      GetParent()->SetFocus();
   }
#endif
 
   // Restore saved focus, but only if the window still exists.
   //
   // PRL:  I'm conservatively preserving the old existence test, but I think
   // it's redundant now that we use wxWindowRef to avoid a dangling pointer
   if (mHadFocus && SearchForWindow(wxTopLevelWindows, mHadFocus)) {
      mHadFocus->SetFocus();
   }
}

References Beep(), mDisable, mHadFocus, and SearchForWindow().

Here is the call graph for this function:

Member Function Documentation

AddMessageAsColumn()

void ProgressDialog::AddMessageAsColumn ( wxBoxSizer *  pSizer, const MessageColumn &  column, bool  bFirstColumn  )

private

Definition at line 1102 of file ProgressDialog.cpp.

                                                           {
 
   // Assuming that we don't want empty columns, bail out if there is no text.
   if (column.empty())
      return;
 
   // Join strings
   auto sText = column[0];
   std::for_each( column.begin() + 1, column.end(),
      [&](const TranslatableString &text)
         { sText.Join( text, wxT("\n") ); });
 
   // Create a statictext object and add to the sizer
   wxStaticText* oText = safenew wxStaticText(this,
                                              wxID_ANY,
                                              sText.Translation(),
                                              wxDefaultPosition,
                                              wxDefaultSize,
                                              wxALIGN_LEFT);
   oText->SetName(sText.Translation()); // fix for bug 577 (NVDA/Narrator screen readers do not read static text in dialogs)
 
   // If this is the first column then set the mMessage pointer so non-TimerRecord usages
   // will still work correctly in SetMessage()
   if (bFirstColumn) {
      mMessage = oText;
   }
 
   pSizer->Add(oText, 1, wxEXPAND | wxALL, 5);
}

References mMessage, safenew, and anonymous_namespace{LogWindow.cpp}::sText.

Referenced by Create().

Here is the caller graph for this function:

Beep()

void ProgressDialog::Beep ( ) const

private

Definition at line 1603 of file ProgressDialog.cpp.

{
   int after;
   bool should;
   wxString name;
 
   gPrefs->Read(wxT("/GUI/BeepOnCompletion"), &should, false);
   gPrefs->Read(wxT("/GUI/BeepAfterDuration"), &after, 60);
   gPrefs->Read(wxT("/GUI/BeepFileName"), &name, wxEmptyString);
 
   if (should && wxGetUTCTimeMillis().GetValue() - mStartTime > after * 1000)
   {
      wxBusyCursor busy;
      wxSound s;
 
      if (name.empty())
      {
         s.Create(sizeof(beep), beep);
      }
      else
      {
         s.Create(name);
      }
 
      if (s.IsOk())
      {
         s.Play(wxSOUND_SYNC);
      }
   }
}

References beep, TranslatableString::empty(), gPrefs, mStartTime, and name.

Referenced by ~ProgressDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

ConfirmAction()

bool ProgressDialog::ConfirmAction ( const TranslatableString &  sPrompt, const TranslatableString &  sTitle, int  iButtonID = -1  )

private

Definition at line 1636 of file ProgressDialog.cpp.

                                                    {
 
   // Check if confirmations are enabled?
   // If not then return TRUE
   if (m_bConfirmAction == false) {
      return true;
   }
 
   AudacityMessageDialog dlgMessage(
      this,
      sPrompt,
      sTitle,
      wxYES_NO | wxICON_QUESTION | wxNO_DEFAULT | wxSTAY_ON_TOP );
   int iAction = dlgMessage.ShowModal();
 
   bool bReturn = (iAction == wxID_YES);
   if ((bReturn == false) && (iButtonID > -1)) {
      // Set the focus back to the relevant button
      FindWindowById(iButtonID, this)->SetFocus();
   }
 
   return bReturn;
}

References m_bConfirmAction.

Referenced by OnCancel(), OnCloseWindow(), and OnStop().

Here is the caller graph for this function:

Create() [1/2]

bool ProgressDialog::Create ( const TranslatableString &  title, const MessageTable &  columns, int  flags = pdlgDefaultFlags, const TranslatableString &  sRemainingLabelText = {}  )

protected

Definition at line 1153 of file ProgressDialog.cpp.

{
   Init();
 
   wxWindow *parent = 
#if defined(__WXMAC__)
      // Bug 2703: In release builds, the progress dialog will fall behind
      // the top level dialog (like effects dialogs). This does not happen
      // in debug builds and I was not able to track down the reason. So,
      // this is a workaround and should be reviewed as some point, like
      // when upgrading to the next WX version.
      GetParentForModalDialog(mHadFocus, 0);
#else
      GetParentForModalDialog(nullptr, 0);
#endif
 
   // Set this boolean to indicate if we are using the "Elapsed" labels
   m_bShowElapsedTime = !(flags & pdlgHideElapsedTime);
   // Set this boolean to indicate if we confirm the Cancel/Stop actions
   m_bConfirmAction = (flags & pdlgConfirmStopCancel)!=0;
 
   bool success = wxDialogWrapper::Create(parent,
                                   wxID_ANY,
                                   title,
                                   wxDefaultPosition,
                                   wxDefaultSize,
                                   wxDEFAULT_DIALOG_STYLE |
                                   wxFRAME_FLOAT_ON_PARENT);
   if (!success)
   {
      return false;
   }
 
   SetName(); // This was added for NVDA screen reader and may now be redundant.
   SetExtraStyle(GetExtraStyle() | wxWS_EX_TRANSIENT);   // Ancient code. Is it still required?
 
   {
      wxWindow *window;
 
      // There may be more than one column, so create a BoxSizer container
      auto uColSizer = std::make_unique<wxBoxSizer>(wxHORIZONTAL);
      auto colSizer = uColSizer.get();
 
      // TODO:  this setting-up of a grid of text in a sizer might be worth
      // extracting as a utility for building other dialogs.
      {
         bool bFirstCol = true;
         for (const auto &column : columns) {
            AddMessageAsColumn(colSizer, column, bFirstCol);
            bFirstCol = false;
         }
      }
 
      // and put message column(s) into a main vertical sizer.
      auto vertSizer = std::make_unique<wxBoxSizer>(wxVERTICAL);
      vertSizer->Add(uColSizer.release(), 1, wxEXPAND | wxALL, 10);
 
      mGauge = safenew wxGauge(this,
                               wxID_ANY,
                               1000,
                               wxDefaultPosition,
                               wxDefaultSize,
                               wxGA_HORIZONTAL);
      vertSizer->Add(mGauge, 0, wxEXPAND | wxLEFT | wxRIGHT | wxBOTTOM, 10);
 
      {
         auto uGridSizer = std::make_unique<wxFlexGridSizer>(2, 2, 10, 10);
         // Only one row if we are not going to show the elapsed time
         if (m_bShowElapsedTime == false) {
            uGridSizer = std::make_unique<wxFlexGridSizer>(1, 2, 10, 10);
         }
         auto gridSizer = uGridSizer.get();
 
         if (m_bShowElapsedTime) {
            window = safenew wxStaticText(this,
                                          wxID_ANY,
                                          _("Elapsed Time:"),
                                          wxDefaultPosition,
                                          wxDefaultSize,
                                          wxALIGN_RIGHT);
 
            window->SetName(window->GetLabel()); // fix for bug 577 (NVDA/Narrator screen readers do not read static text in dialogs)
            gridSizer->Add(window, 0, wxALIGN_RIGHT);
 
            mElapsed = safenew wxStaticText(this,
                                            wxID_ANY,
                                            wxT("00:00:00"),
                                            wxDefaultPosition,
                                            wxDefaultSize,
                                            wxALIGN_LEFT);
 
            mElapsed->SetName(mElapsed->GetLabel()); // fix for bug 577 (NVDA/Narrator screen readers do not read static text in dialogs)
            gridSizer->Add(mElapsed, 0, wxALIGN_LEFT);
         }
 
         // Customised "Remaining" label text
         auto sRemainingText = sRemainingLabelText;
         if (sRemainingText.empty()) {
            sRemainingText = XO("Remaining Time:");
         }
 
         window = safenew wxStaticText(this,
                                       wxID_ANY,
                                       sRemainingText.Translation(),
                                       wxDefaultPosition,
                                       wxDefaultSize,
                                       wxALIGN_RIGHT);
         window->SetName(window->GetLabel()); // fix for bug 577 (NVDA/Narrator screen readers do not read static text in dialogs)
         gridSizer->Add(window, 0, wxALIGN_RIGHT);
 
         mRemaining = safenew wxStaticText(this,
                                           wxID_ANY,
                                           wxT("00:00:00"),
                                           wxDefaultPosition,
                                           wxDefaultSize,
                                           wxALIGN_LEFT);
         mRemaining->SetName(mRemaining->GetLabel()); // fix for bug 577 (NVDA/Narrator screen readers do not read static text in dialogs)
         gridSizer->Add(mRemaining, 0, wxALIGN_LEFT);
 
         vertSizer->Add(uGridSizer.release(), 0, wxALIGN_CENTER | wxLEFT | wxRIGHT | wxBOTTOM, 10);
      }
 
      {
         auto uButtonBar = std::make_unique<wxBoxSizer>(wxHORIZONTAL);
         auto buttonBarSizer = uButtonBar.get();
 
         if (!(flags & pdlgHideStopButton)) {
            window = safenew wxButton(this, wxID_OK, _("Stop"));
            buttonBarSizer->Add(window, 0, wxRIGHT, 10);
         }
         if (!(flags & pdlgHideCancelButton)) {
            window = safenew wxButton(this, wxID_CANCEL, _("Cancel"));
            buttonBarSizer->Add(window, 0, wxRIGHT, 10);
         }
         vertSizer->Add(uButtonBar.release(), 0, wxALIGN_RIGHT | wxRIGHT | wxBOTTOM, 10);
      }
 
      SetSizerAndFit(vertSizer.release());
   }
   Layout();
 
   // Center progress bar on Parent if it is nice and wide, otherwise Center on screen.
   int parentWidth = -1, parentHeight=-1;
   if( GetParent() )  GetParent()->GetSize( &parentWidth, &parentHeight );
   if (parentWidth > 400) 
      CenterOnParent();
   else
      CenterOnScreen();
 
   Reinit();
 
   // Even though we won't necessarily show the dialog due to the 500ms
   // delay, we MUST disable other windows/menus anyway since we run the risk
   // of allowing other tasks to run before this one is complete.
   //
   // Reviewed this code per Proposed Features #1, at
   // http://wiki.audacityteam.org/wiki/Proposal_Timer_Record_Improvements.
   // Note that this causes a problem for Timer Record wait dialog
   // (see TimerRecordDialog::RunWaitDialog()), because it makes it
   // impossible to do any editing, even in other open projects,
   // while waiting for Timer Record to start -- and then also
   // while it's recording, it has a ProgressDialog, so really,
   // no editing in any project until Timer Record finishes.
   mDisable = std::make_unique<wxWindowDisabler>(this);
 
   return true;
}

References _, AddMessageAsColumn(), wxDialogWrapper::Create(), Init(), m_bConfirmAction, m_bShowElapsedTime, mDisable, mElapsed, mGauge, mHadFocus, mRemaining, pdlgConfirmStopCancel, pdlgHideCancelButton, pdlgHideElapsedTime, pdlgHideStopButton, Reinit(), safenew, wxDialogWrapper::SetName(), title, and XO.

Here is the call graph for this function:

Create() [2/2]

bool ProgressDialog::Create	(	const TranslatableString &	title,
		const TranslatableString &	message = {},
		int	flags = pdlgDefaultFlags,
		const TranslatableString &	sRemainingLabelText = {}
	)

Definition at line 1134 of file ProgressDialog.cpp.

{
   MessageTable columns(1);
   columns.back().push_back(message);
   auto result = Create(title, columns, flags, sRemainingLabelText);
 
   if (result) {
      // Record some values used in case of change of message
      // TODO: make the following work in case of message tables
      wxClientDC dc(this);
      dc.GetMultiLineTextExtent(message.Translation(), &mLastW, &mLastH);
   }
 
   return result;
}

References Create(), mLastH, mLastW, title, and TranslatableString::Translation().

Referenced by Create(), and ProgressDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

Init()

void ProgressDialog::Init ( )

private

Definition at line 1052 of file ProgressDialog.cpp.

{
   // There's a problem where the focus is not returned to the window that had
   // it before creating this object.  The reason is because the focus events
   // that are sent to the parent window after the wxWindowDisabler are created
   // are tossed and focus will not get restored to the parent once the disabler
   // is deleted.  (See bug #1173 for more info)
   //
   // So, we capture and restore the focus ourselves.
   mHadFocus = wxWindow::FindFocus();
 
#if defined(__WXGTK__)
   // Under GTK, when applying any effect that prompts the user, it's more than
   // likely that FindFocus() will return NULL.  So, make sure something has focus.
   if (GetParent())
   {
      GetParent()->SetFocus();
   }
#endif
}

References mHadFocus.

Referenced by Create().

Here is the caller graph for this function:

OnCancel()

void ProgressDialog::OnCancel ( wxCommandEvent &  e )

private

Definition at line 1571 of file ProgressDialog.cpp.

{
   if (!ConfirmAction(
         XO("Are you sure you wish to cancel?"),
         XO("Confirm Cancel"), wxID_CANCEL)) {
      return;
   }
   FindWindowById(wxID_CANCEL, this)->Disable();
   mCancel = true;
}

References ConfirmAction(), mCancel, and XO.

Here is the call graph for this function:

OnCloseWindow()

void ProgressDialog::OnCloseWindow ( wxCloseEvent &  e )

private

Definition at line 1594 of file ProgressDialog.cpp.

{
   if (!ConfirmAction(
         XO("Are you sure you wish to close?"), XO("Confirm Close"))) {
      return;
   }
   mCancel = true;
}

References ConfirmAction(), mCancel, and XO.

Here is the call graph for this function:

OnStop()

void ProgressDialog::OnStop ( wxCommandEvent &  e )

private

Definition at line 1582 of file ProgressDialog.cpp.

{
   if (!ConfirmAction(
         XO("Are you sure you wish to stop?"),
         XO("Confirm Stop"), wxID_OK)) {
      return;
   }
   FindWindowById(wxID_OK, this)->Disable();
   mCancel = false;
   mStop = true;
}

References ConfirmAction(), mCancel, mStop, and XO.

Here is the call graph for this function:

Reinit()

void ProgressDialog::Reinit

(

)

Definition at line 1073 of file ProgressDialog.cpp.

{
   mLastValue = 0;
 
   mStartTime = wxGetUTCTimeMillis().GetValue();
   mLastUpdate = mStartTime;
   mYieldTimer = mStartTime;
   mCancel = false;
   mStop = false;
 
   // Because wxGTK is very sensitive about maintaining focus when
   // this window is not shown, we always show it.  But, since we
   // want a 500ms delay before it's actually visible for those
   // quick tasks, we show it as transparent.  If the initial
   // delay is exceeded, then we reset the dialog to full opacity.
   SetTransparent(0);
   mIsTransparent = true;
 
   auto button = FindWindowById(wxID_CANCEL, this);
   if (button)
      button->Enable();
   button = FindWindowById(wxID_OK, this);
   if (button)
      button->Enable();
 
   wxDialogWrapper::Show(true);
}

References mCancel, mIsTransparent, mLastUpdate, mLastValue, mStartTime, mStop, and mYieldTimer.

Referenced by Create().

Here is the caller graph for this function:

SearchForWindow()

bool ProgressDialog::SearchForWindow ( const wxWindowList &  list, const wxWindow *  searchfor  ) const

private

Definition at line 1558 of file ProgressDialog.cpp.

{
   for (auto win : list)
   {
      if (win == searchfor || SearchForWindow(win->GetChildren(), searchfor))
      {
         return true;
      }
   }
 
   return false;
}

References SearchForWindow().

Referenced by SearchForWindow(), and ~ProgressDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

SetMessage()

void ProgressDialog::SetMessage

(

const TranslatableString &

message

)

Definition at line 1510 of file ProgressDialog.cpp.

{
   if (!message.empty())
   {
      mMessage->SetLabel(message.Translation());
 
      int w, h;
      wxClientDC dc(mMessage);
      dc.GetMultiLineTextExtent(message.Translation(), &w, &h);
 
      auto sizeUpdated = false;
      const auto currentSize = GetClientSize();
      auto ds = currentSize;
 
      // TODO: make the following work in case of message tables
      if (w > mLastW)
      {
         ds.x += (w - mLastW);
         sizeUpdated = true;
         mLastW = w;
      }
 
      if (h > mLastH)
      {
         ds.y += (h - mLastH);
         sizeUpdated = true;
         mLastH = h;
      }
 
      if (sizeUpdated)
      {
#if defined(__WXMAC__)
         wxSize sz = mMessage->GetSize();
         mMessage->SetMinSize(wxSize(wxMax(sz.x, mLastW), wxMax(sz.y, mLastH)));
#endif
         // No need to adjust for the margin here since we only add
         // to the existing dimensions.
         ds.x = wxMax(wxMax(ds.x, mLastW), wxMax(ds.y, mLastH));
         SetClientSize(ds);
         SetPosition(GetPosition() - (ds - currentSize) / 2);
         wxDialogWrapper::Update();
      }
   }
}

References TranslatableString::empty(), mLastH, mLastW, mMessage, and TranslatableString::Translation().

Referenced by anonymous_namespace{wxWidgetsBasicUI.cpp}::MyProgressDialog::SetMessage(), and Update().

Here is the call graph for this function:

Here is the caller graph for this function:

Update() [1/7]

ProgressResult ProgressDialog::Update	(	double	current,
		const TranslatableString &	message = {}
	)

Definition at line 1421 of file ProgressDialog.cpp.

{
   return Update((int)(current * 1000), message);
}

References Update().

Here is the call graph for this function:

Update() [2/7]

ProgressResult ProgressDialog::Update	(	double	current,
		double	total,
		const TranslatableString &	message = {}
	)

Definition at line 1494 of file ProgressDialog.cpp.

{
   if (total != 0)
   {
      return Update((int)(current * 1000.0 / total), message);
   }
   else
   {
      return Update(1000, message);
   }
}

References Update().

Here is the call graph for this function:

Update() [3/7]

ProgressResult ProgressDialog::Update	(	int	current,
		int	total,
		const TranslatableString &	message = {}
	)

Definition at line 1478 of file ProgressDialog.cpp.

{
   if (total != 0)
   {
      return Update((int)(current *  ((double)(1000.0 / total))), message);
   }
   else
   {
      return Update(1000, message);
   }
}

References Update().

Here is the call graph for this function:

Update() [4/7]

ProgressResult ProgressDialog::Update	(	int	value,
		const TranslatableString &	message = {}
	)

Definition at line 1327 of file ProgressDialog.cpp.

{
   if (mCancel)
   {
      // for compatibility with old Update, that returned false on cancel
      return ProgressResult::Cancelled;
   }
   else if (mStop)
   {
      return ProgressResult::Stopped;
   }
 
   wxLongLong_t now = wxGetUTCTimeMillis().GetValue();
   wxLongLong_t elapsed = now - mStartTime;
 
   if (elapsed < 500)
   {
      return ProgressResult::Success;
   }
 
   if (mIsTransparent)
   {
      SetTransparent(255);
      mIsTransparent = false;
   }
 
   if (value <= 0)
   {
      value = 1;
   }
 
   if (value > 1000)
   {
      value = 1000;
   }
 
   wxLongLong_t estimate = elapsed * 1000ll / value;
   wxLongLong_t remains = (estimate + mStartTime) - now;
 
   SetMessage(message);
 
   if (value != mLastValue)
   {
      mGauge->SetValue(value);
      mGauge->Update();
      mLastValue = value;
   }
 
   // Only update if a full second has passed or track progress is complete
   if ((now - mLastUpdate > 1000) || (value == 1000))
   {
      if (m_bShowElapsedTime) {
         wxTimeSpan tsElapsed(0, 0, 0, elapsed);
         mElapsed->SetLabel(tsElapsed.Format(wxT("%H:%M:%S")));
         mElapsed->SetName(mElapsed->GetLabel()); // fix for bug 577 (NVDA/Narrator screen readers do not read static text in dialogs)
         mElapsed->Update();
      }
 
      wxTimeSpan tsRemains(0, 0, 0, remains);
      mRemaining->SetLabel(tsRemains.Format(wxT("%H:%M:%S")));
      mRemaining->SetName(mRemaining->GetLabel()); // fix for bug 577 (NVDA/Narrator screen readers do not read static text in dialogs)
      mRemaining->Update();
 
      mLastUpdate = now;
   }
 
   wxDialogWrapper::Update();
 
   // Copied from wx 3.0.2 generic progress dialog
   //
   // we have to yield because not only we want to update the display but
   // also to process the clicks on the cancel and skip buttons
   // NOTE: using YieldFor() this call shouldn't give re-entrancy problems
   //       for event handlers not interested to UI/user-input events.
   //
   // LL:  Added timer category to prevent extreme delays when processing effects
   //      (and probably other things).  I do not yet know why this happens and
   //      I'm not too keen on having timer events processed here, but you do
   //      what you have to do.
 
   // Nyquist effects call Update on every callback, but YieldFor is
   // quite slow on Linux / Mac, so don't call too frequently. (bug 1575)
   if ((now - mYieldTimer > 50) || (value == 1000)) {
      wxEventLoopBase::GetActive()->YieldFor(wxEVT_CATEGORY_UI | wxEVT_CATEGORY_USER_INPUT | wxEVT_CATEGORY_TIMER);
      mYieldTimer = now;
   }
 
   return ProgressResult::Success;
}

References RefreshCode::Cancelled, m_bShowElapsedTime, mCancel, mElapsed, mGauge, mIsTransparent, mLastUpdate, mLastValue, mRemaining, mStartTime, mStop, mYieldTimer, SetMessage(), and BasicUI::Success.

Referenced by ProjectFileIO::CopyTo(), ImportRaw(), TransportUtilities::PlayCurrentRegionAndWait(), TransportUtilities::PlayPlayRegionAndWait(), TransportUtilities::RecordAndWait(), RemoveDependencies(), and Update().

Here is the call graph for this function:

Here is the caller graph for this function:

Update() [5/7]

ProgressResult ProgressDialog::Update	(	wxLongLong	current,
		wxLongLong	total,
		const TranslatableString &	message = {}
	)

Definition at line 1446 of file ProgressDialog.cpp.

{
   if (total.GetValue() != 0)
   {
      return Update((int)(current.GetValue() * 1000ll / total.GetValue()), message);
   }
   else
   {
      return Update(1000, message);
   }
}

References Update().

Here is the call graph for this function:

Update() [6/7]

ProgressResult ProgressDialog::Update	(	wxLongLong_t	current,
		wxLongLong_t	total,
		const TranslatableString &	message = {}
	)

Definition at line 1462 of file ProgressDialog.cpp.

{
   if (total != 0)
   {
      return Update((int)(current * 1000ll / total), message);
   }
   else
   {
      return Update(1000, message);
   }
}

References Update().

Here is the call graph for this function:

Update() [7/7]

ProgressResult ProgressDialog::Update	(	wxULongLong_t	current,
		wxULongLong_t	total,
		const TranslatableString &	message = {}
	)

Definition at line 1430 of file ProgressDialog.cpp.

{
   if (total != 0)
   {
      return Update((int)(current * 1000 / total), message);
   }
   else
   {
      return Update(1000, message);
   }
}

References Update().

Here is the call graph for this function:

Member Data Documentation

m_bConfirmAction

bool ProgressDialog::m_bConfirmAction = false

protected

Definition at line 121 of file ProgressDialog.h.

Referenced by ConfirmAction(), and Create().

m_bShowElapsedTime

bool ProgressDialog::m_bShowElapsedTime = true

protected

Definition at line 120 of file ProgressDialog.h.

Referenced by Create(), Update(), and TimerProgressDialog::UpdateProgress().

mCancel

bool ProgressDialog::mCancel

protected

Definition at line 114 of file ProgressDialog.h.

Referenced by OnCancel(), OnCloseWindow(), OnStop(), Reinit(), Update(), and TimerProgressDialog::UpdateProgress().

mDisable

std::unique_ptr<wxWindowDisabler> ProgressDialog::mDisable

private

Definition at line 142 of file ProgressDialog.h.

Referenced by Create(), and ~ProgressDialog().

mElapsed

wxStaticText* ProgressDialog::mElapsed

protected

Definition at line 105 of file ProgressDialog.h.

Referenced by Create(), Update(), and TimerProgressDialog::UpdateProgress().

mGauge

wxGauge* ProgressDialog::mGauge

protected

Definition at line 107 of file ProgressDialog.h.

Referenced by Create(), Update(), and TimerProgressDialog::UpdateProgress().

mHadFocus

wxWindowRef ProgressDialog::mHadFocus

protected

Definition at line 103 of file ProgressDialog.h.

Referenced by Create(), Init(), and ~ProgressDialog().

mIsTransparent

bool ProgressDialog::mIsTransparent

protected

Definition at line 117 of file ProgressDialog.h.

Referenced by Reinit(), Update(), and TimerProgressDialog::UpdateProgress().

mLastH

int ProgressDialog::mLastH { 0 }

private

Definition at line 146 of file ProgressDialog.h.

Referenced by Create(), and SetMessage().

mLastUpdate

wxLongLong_t ProgressDialog::mLastUpdate

protected

Definition at line 110 of file ProgressDialog.h.

Referenced by Reinit(), Update(), and TimerProgressDialog::UpdateProgress().

mLastValue

int ProgressDialog::mLastValue

protected

Definition at line 112 of file ProgressDialog.h.

Referenced by Reinit(), Update(), and TimerProgressDialog::UpdateProgress().

mLastW

int ProgressDialog::mLastW { 0 }

private

Definition at line 145 of file ProgressDialog.h.

Referenced by Create(), and SetMessage().

mLoop

wxEventLoopGuarantor ProgressDialog::mLoop

private

Definition at line 140 of file ProgressDialog.h.

mMessage

wxStaticText* ProgressDialog::mMessage {}

private

Definition at line 144 of file ProgressDialog.h.

Referenced by AddMessageAsColumn(), and SetMessage().

mRemaining

wxStaticText* ProgressDialog::mRemaining

protected

Definition at line 106 of file ProgressDialog.h.

Referenced by Create(), Update(), and TimerProgressDialog::UpdateProgress().

mStartTime

wxLongLong_t ProgressDialog::mStartTime

protected

Definition at line 109 of file ProgressDialog.h.

Referenced by Beep(), Reinit(), Update(), and TimerProgressDialog::UpdateProgress().

mStop

bool ProgressDialog::mStop

protected

Definition at line 115 of file ProgressDialog.h.

Referenced by OnStop(), Reinit(), Update(), and TimerProgressDialog::UpdateProgress().

mYieldTimer

wxLongLong_t ProgressDialog::mYieldTimer

protected

Definition at line 111 of file ProgressDialog.h.

Referenced by Reinit(), and Update().

---

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

• ProgressDialog.h
• ProgressDialog.cpp