BasicUI Namespace Reference

Classes
struct	ErrorDialogOptions
	Options for variations of error dialogs; the default is for modal dialogs. More...
class	GenericProgressDialog
	Abstraction of a progress dialog with undefined time-to-completion estimate. More...
struct	MessageBoxOptions
class	ProgressDialog
	Abstraction of a progress dialog with well defined time-to-completion estimate. More...
class	Services
	Abstract class defines a few user interface services, not mentioning particular toolkits. More...
class	WindowPlacement
	Subclasses may hold information such as a parent window pointer for a dialog. More...

Functions
Services *	Get ()
	Fetch the global instance, or nullptr if none is yet installed. More...
Services *	Install (Services *pInstance)
	Install an implementation; return the previously installed instance. More...
Functions that invoke global Services
These dispatch to the global Services, if supplied. If none was supplied, they are mostly no-ops, with exceptions as noted. All should be called on the main thread only, except as noted.
void	CallAfter (Action action)
	Schedule an action to be done later, and in the main thread. More...
void	Yield ()
	Dispatch waiting events, including actions enqueued by CallAfter. More...
void	ShowErrorDialog (const WindowPlacement &placement, const TranslatableString &dlogTitle, const TranslatableString &message, const ManualPageID &helpPage, const ErrorDialogOptions &options={})
	Show an error dialog with a link to the manual for further help. More...
MessageBoxResult	ShowMessageBox (const TranslatableString &message, MessageBoxOptions options={})
	Show a modal message box with either Ok or Yes and No, and optionally Cancel. More...
std::unique_ptr< ProgressDialog >	MakeProgress (const TranslatableString &title, const TranslatableString &message, unsigned flags=(ProgressShowStop|ProgressShowCancel), const TranslatableString &remainingLabelText={})
	Create and display a progress dialog. More...
std::unique_ptr< GenericProgressDialog >	MakeGenericProgress (const WindowPlacement &placement, const TranslatableString &title, const TranslatableString &message)
	Create and display a progress dialog (return nullptr if Services not installed) More...

Variables
static Services *	theInstance = nullptr
static std::recursive_mutex	sActionsMutex
static std::vector< Action >	sActions

Types used in the Services interface
enum	ErrorDialogType { ErrorDialogType::ModelessError, ErrorDialogType::ModalError, ErrorDialogType::ModalErrorReport }
enum	Icon {   Icon::None, Icon::Warning, Icon::Error, Icon::Question,   Icon::Information }
enum	Button { Button::Default, Button::Ok, Button::YesNo }
enum	MessageBoxResult : int {   MessageBoxResult::None, MessageBoxResult::Yes, MessageBoxResult::No, MessageBoxResult::Ok,   MessageBoxResult::Cancel }
enum	ProgressDialogOptions : unsigned { ProgressShowStop = (1 << 0), ProgressShowCancel = (1 << 1), ProgressHideTime = (1 << 2), ProgressConfirmStopOrCancel = (1 << 3) }
enum	ProgressResult : unsigned { ProgressResult::Cancelled = 0, ProgressResult::Success, ProgressResult::Failed, ProgressResult::Stopped }
using	Action = std::function< void()>
TranslatableString	DefaultCaption ()
	"Message", suitably translated More...

Typedef Documentation

Action

using BasicUI::Action = typedef std::function<void()>

Definition at line 24 of file BasicUI.h.

Enumeration Type Documentation

Button

enum BasicUI::Button

strong

Enumerator
Default	Like Ok, except maybe minor difference of dialog position.
Ok	One button.
YesNo	Two buttons.

Definition at line 85 of file BasicUI.h.

                  {
   Default, 
   Ok,      
   YesNo    
};

ErrorDialogType

enum BasicUI::ErrorDialogType

strong

Enumerator
ModelessError
ModalError
ModalErrorReport	If error reporting is enabled, may give option to send; if not, then like ModalError

Definition at line 40 of file BasicUI.h.

                           {
   ModelessError,
   ModalError,
   ModalErrorReport, 
};

Icon

enum BasicUI::Icon

strong

Enumerator
None
Warning
Error
Question
Information

Definition at line 77 of file BasicUI.h.

                {
   None,
   Warning,
   Error,
   Question,
   Information,
};

MessageBoxResult

enum BasicUI::MessageBoxResult : int

strong

Enumerator
None	May be returned if no Services are installed.
Yes
No
Ok
Cancel

Definition at line 129 of file BasicUI.h.

                            : int {
   None, 
   Yes,
   No,
   Ok,
   Cancel,
};

ProgressDialogOptions

enum BasicUI::ProgressDialogOptions : unsigned

Enumerator
ProgressShowStop
ProgressShowCancel
ProgressHideTime
ProgressConfirmStopOrCancel

Definition at line 137 of file BasicUI.h.

                           : unsigned {
   ProgressShowStop            = (1 << 0),
   ProgressShowCancel          = (1 << 1),
   ProgressHideTime            = (1 << 2),
   ProgressConfirmStopOrCancel = (1 << 3),
};

ProgressResult

enum BasicUI::ProgressResult : unsigned

strong

Enumerator
Cancelled
Success
Failed
Stopped

Definition at line 144 of file BasicUI.h.

{
   Cancelled = 0, //<! User says that whatever is happening is undesirable and shouldn't have happened at all
   Success,       //<! User says nothing, everything works fine, continue doing whatever we're doing
   Failed,        //<! Something has gone wrong, we should stop and cancel everything we did
   Stopped        //<! Nothing is wrong, but user says we should stop now and leave things as they are now
};

Function Documentation

CallAfter()

BASIC_UI_API void BasicUI::CallAfter

(

Action

action

)

Schedule an action to be done later, and in the main thread.

This function may be called in other threads than the main. If no Services are yet installed, the action is not lost, but may be dispatched by Yield(). The action may itself invoke CallAfter to enqueue other actions.

Definition at line 38 of file BasicUI.cpp.

{
   if (auto p = Get())
      p->DoCallAfter(action);
   else {
      // No services yet -- but don't lose the action.  Put it in a queue
      auto guard = std::lock_guard{ sActionsMutex };
      sActions.emplace_back(std::move(action));
   }
}

References Get(), sActions, and sActionsMutex.

Referenced by AdornedRulerPanel::AdornedRulerPanel(), PrefsListener::Broadcast(), AudacityException::EnqueueAction(), ProjectWindow::HandleResize(), AudacityApp::InitPart2(), TrackPanel::OnAudioIO(), AudacityApp::OnExceptionInMainLoop(), AudacityApp::OnInit(), TrackPanel::OnMouseEvent(), ErrorReportDialog::OnSend(), ProjectWindow::RedrawProject(), AdornedRulerPanel::Refresh(), and TrackPanel::Refresh().

Here is the call graph for this function:

Here is the caller graph for this function:

DefaultCaption()

BASIC_UI_API TranslatableString BasicUI::DefaultCaption

(

)

"Message", suitably translated

Definition at line 70 of file BasicUI.cpp.

{
   return XO("Message");
}

References XO.

Referenced by MessageBoxException::DelayedHandlerAction().

Here is the caller graph for this function:

Get()

BASIC_UI_API Services * BasicUI::Get

(

)

Fetch the global instance, or nullptr if none is yet installed.

Definition at line 26 of file BasicUI.cpp.

{ return theInstance; }

References theInstance.

Referenced by audacity::sentry::AddExceptionContext(), audacity::sentry::anonymous_namespace{SentryReport.cpp}::AddOSContext(), CallAfter(), audacity::network_manager::CurlHandleManager::CurlHandleManager(), EffectUI::DoEffect(), FindProjectFrame(), anonymous_namespace{ProjectWindows.cpp}::ProjectWindows::Get(), BackgroundCell::Get(), WaveTrackView::Get(), GetAttachedWindows(), PlatformCompatibility::GetExecutablePath(), Languages::GetLanguages(), GetProjectFrame(), GetProjectPanel(), UpdateManager::GetUpdates(), UpdateDataParser::HandleXMLTag(), MakeGenericProgress(), AudacityApp::OnInit(), Grid::OnKeyDown(), NyquistEffect::Process(), RemoveDependencies(), audacity::sentry::anonymous_namespace{SentryReport.cpp}::SerializeException(), SetProjectFrame(), SetProjectPanel(), anonymous_namespace{ViewMenus.cpp}::ViewMenu(), and Yield().

Here is the caller graph for this function:

Install()

BASIC_UI_API Services * BasicUI::Install

(

Services *

pInstance

)

Install an implementation; return the previously installed instance.

Definition at line 28 of file BasicUI.cpp.

{
   auto result = theInstance;
   theInstance = pInstance;
   return result;
}

References theInstance.

Referenced by AudacityApp::OnInit().

Here is the caller graph for this function:

MakeGenericProgress()

std::unique_ptr<GenericProgressDialog> BasicUI::MakeGenericProgress ( const WindowPlacement &  placement, const TranslatableString &  title, const TranslatableString &  message  )

inline

Create and display a progress dialog (return nullptr if Services not installed)

This function makes a "generic" progress dialog, for the case when time to completion cannot be estimated, but some indication of progress is still given

Definition at line 281 of file BasicUI.h.

{
   if (auto p = Get())
      return p->DoMakeGenericProgress(placement, title, message);
   else
      return nullptr;
}

References Get(), and title.

Referenced by DBConnection::Close(), ProjectFileIO::RenameOrWarn(), and ProjectFileIO::SaveProject().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeProgress()

std::unique_ptr<ProgressDialog> BasicUI::MakeProgress ( const TranslatableString &  title, const TranslatableString &  message, unsigned  flags = (ProgressShowStop | ProgressShowCancel), const TranslatableString &  remainingLabelText = {}  )

inline

Create and display a progress dialog.

Parameters

flags	bitwise OR of values in ProgressDialogOptions
remainingLabelText	if not empty substitutes for "Remaining Time:"

Returns

nullptr if Services not installed

Definition at line 263 of file BasicUI.h.

                                                   {})
{
   if (auto p = Get())
      return p->DoMakeProgress(title, message, flags, remainingLabelText);
   else
      return nullptr;
}

Referenced by UpdateManager::GetUpdates().

Here is the caller graph for this function:

ShowErrorDialog()

void BasicUI::ShowErrorDialog ( const WindowPlacement &  placement, const TranslatableString &  dlogTitle, const TranslatableString &  message, const ManualPageID &  helpPage, const ErrorDialogOptions &  options = {}  )

inline

Show an error dialog with a link to the manual for further help.

Parameters

placement	how to parent the dialog
dlogTitle	Text for title bar
message	The main message text
helpPage	Identifies manual page (and maybe an anchor)

Definition at line 233 of file BasicUI.h.

                                       {})
{
   if (auto p = Get())
      p->DoShowErrorDialog(placement, dlogTitle, message, helpPage, options);
}

Referenced by MessageBoxException::DelayedHandlerAction(), ProjectAudioManager::DoRecord(), ProjectFileManager::DoSave(), TempDirectory::FATFilesystemDenied(), UpdateManager::GetUpdates(), ProjectFileManager::Import(), ProjectAudioManager::PlayPlayRegion(), Effect::Preview(), ExportPCM::ReportTooBigError(), ProjectFileManager::SaveCopy(), ShowDiskFullExportErrorDialog(), ProjectFileIO::ShowError(), ShowExportErrorDialog(), AudioIO::StartMonitoring(), MenuManager::TellUserWhyDisallowed(), and TempDirectory::TempDir().

Here is the caller graph for this function:

ShowMessageBox()

MessageBoxResult BasicUI::ShowMessageBox ( const TranslatableString &  message, MessageBoxOptions  options = {}  )

inline

Show a modal message box with either Ok or Yes and No, and optionally Cancel.

Returns

indicates which button was pressed

Definition at line 248 of file BasicUI.h.

                               {})
{
   if (auto p = Get())
      return p->DoMessageBox(message, std::move(options));
   else
      return MessageBoxResult::None;
}

Referenced by anonymous_namespace{Registry.cpp}::BadPath(), CreateDirectory(), MessageBoxException::DelayedHandlerAction(), and ThemeBase::SaveComponents().

Here is the caller graph for this function:

Yield()

BASIC_UI_API void BasicUI::Yield

(

)

Dispatch waiting events, including actions enqueued by CallAfter.

This function must be called by the main thread. Actions enqueued by CallAfter before Services were installed will be dispatched in the sequence they were enqueued, unless an exception thrown by one of them stops the dispatching.

Definition at line 49 of file BasicUI.cpp.

{
   do {
      // Dispatch anything in the queue, added while there were no Services
      {
         auto guard = std::lock_guard{ sActionsMutex };
         std::vector<Action> actions;
         actions.swap(sActions);
         for (auto &action : actions)
            action();
      }
 
      // Dispatch according to Services, if present
      if (auto p = Get())
         p->DoYield();
   }
   // Re-test for more actions that might have been enqueued by actions just
   // dispatched
   while ( !sActions.empty() );
}

References Get(), sActions, and sActionsMutex.

Here is the call graph for this function:

Variable Documentation

sActions

std::vector<Action> BasicUI::sActions

static

Definition at line 36 of file BasicUI.cpp.

Referenced by CallAfter(), and Yield().

sActionsMutex

std::recursive_mutex BasicUI::sActionsMutex

static

Definition at line 35 of file BasicUI.cpp.

Referenced by CallAfter(), and Yield().

theInstance

Services* BasicUI::theInstance = nullptr

static

Definition at line 24 of file BasicUI.cpp.

Referenced by Get(), and Install().