AudacityApp Class Reference

AudacityApp is the 'main' class for Audacity. More...

#include <AudacityApp.h>

Inheritance diagram for AudacityApp:

Collaboration diagram for AudacityApp:

Public Member Functions
	AudacityApp ()
	~AudacityApp ()
bool	Initialize (int &argc, wxChar **argv) override
bool	OSXIsGUIApplication () override
void	CleanUp () override
bool	OnInit () override
bool	InitPart2 ()
int	OnRun () override
int	OnExit (void) override
void	OnFatalException () override
bool	OnExceptionInMainLoop () override
void	OnIdle (wxIdleEvent &)
void	OnMenuAbout (wxCommandEvent &event)
void	OnMenuNew (wxCommandEvent &event)
void	OnMenuOpen (wxCommandEvent &event)
void	OnMenuPreferences (wxCommandEvent &event)
void	OnMenuExit (wxCommandEvent &event)
void	OnQueryEndSession (wxCloseEvent &event)
void	OnEndSession (wxCloseEvent &event)
void	OnMRUClear (wxCommandEvent &event)
void	OnMRUFile (wxCommandEvent &event)
bool	MRUOpen (const FilePath &fileName)
bool	SafeMRUOpen (const wxString &fileName)
void	OnReceiveCommand (AppCommandEvent &event)
void	OnKeyDown (wxKeyEvent &event)
void	OnTimer (wxTimerEvent &event)
void	OnServerEvent (wxSocketEvent &evt)
void	OnSocketEvent (wxSocketEvent &evt)
void	MacOpenFile (const wxString &fileName) override
void	MacPrintFile (const wxString &fileName) override
void	MacNewFile () override
void	AssociateFileTypes ()
void	MacActivateApp ()
void	MacFinishLaunching ()

Static Public Member Functions
static void	OnThemeChange (struct ThemeChangeMessage)

Private Member Functions
void	OnInit0 ()
void	InitCommandHandler ()
bool	InitTempDir ()
bool	CreateSingleInstanceChecker (const wxString &dir)
void	ShowSplashScreen ()
void	HideSplashScreen (bool fadeOut=true)
std::unique_ptr< wxCmdLineParser >	ParseCommandLine ()
Private Member Functions inherited from AppEvents::ProviderBase
virtual	~ProviderBase ()=default
void	HandleAppInitialized ()
void	HandleAppIdle ()
void	HandleAppClosing ()

Private Attributes
Observer::Subscription	mThemeChangeSubscription
std::unique_ptr< CommandHandler >	mCmdHandler
std::unique_ptr< wxSingleInstanceChecker >	mChecker
wxTimer	mTimer
wxTimer	mSplashTimer
std::unique_ptr< wxSplashScreen >	mSplashScreen
std::unique_ptr< IPCServ >	mIPCServ

Detailed Description

AudacityApp is the 'main' class for Audacity.

It handles initialization and termination by subclassing wxApp.

Definition at line 39 of file AudacityApp.h.

Constructor & Destructor Documentation

AudacityApp()

AudacityApp::AudacityApp

(

)

Definition at line 1237 of file AudacityApp.cpp.

{
}

~AudacityApp()

AudacityApp::~AudacityApp

(

)

Definition at line 1267 of file AudacityApp.cpp.

{
}

Member Function Documentation

AssociateFileTypes()

void AudacityApp::AssociateFileTypes

(

)

Definition at line 2661 of file AudacityApp.cpp.

{
   // Check pref in case user has already decided against it.
   bool bWantAssociateFiles = true;
   if (gPrefs->Read(wxT("/WantAssociateFiles"), &bWantAssociateFiles) &&
         !bWantAssociateFiles)
   {
      // User has already decided against it
      return;
   }
 
   wxRegKey associateFileTypes;
 
   auto IsDefined = [&](const wxString &type)
   {
      associateFileTypes.SetName(wxString::Format(wxT("HKCR\\%s"), type));
      bool bKeyExists = associateFileTypes.Exists();
      if (!bKeyExists)
      {
         // Not at HKEY_CLASSES_ROOT. Try HKEY_CURRENT_USER.
         associateFileTypes.SetName(wxString::Format(wxT("HKCU\\Software\\Classes\\%s"), type));
         bKeyExists = associateFileTypes.Exists();
      }
      return bKeyExists;
   };
 
   auto DefineType = [&](const wxString &type)
   {
      wxString root_key = wxT("HKCU\\Software\\Classes\\");
 
      // Start with HKEY_CLASSES_CURRENT_USER.
      associateFileTypes.SetName(wxString::Format(wxT("%s%s"), root_key, type));
      if (!associateFileTypes.Create(true))
      {
         // Not at HKEY_CLASSES_CURRENT_USER. Try HKEY_CURRENT_ROOT.
         root_key = wxT("HKCR\\");
         associateFileTypes.SetName(wxString::Format(wxT("%s%s"), root_key, type));
         if (!associateFileTypes.Create(true))
         {
            // Actually, can't create keys. Empty root_key to flag failure.
            root_key.empty();
         }
      }
 
      if (!root_key.empty())
      {
         associateFileTypes = wxT("Audacity.Project"); // Finally set value for the key
      }
 
      return root_key;
   };
 
   // Check for legacy and UP types
   if (IsDefined(wxT(".aup3")) && IsDefined(wxT(".aup")) && IsDefined(wxT("Audacity.Project")))
   {
      // Already defined, so bail
      return;
   }
 
   // File types are not currently associated.
   int wantAssoc =
      AudacityMessageBox(
         XO(
"Audacity project (.aup3) files are not currently \nassociated with Audacity. \n\nAssociate them, so they open on double-click?"),
         XO("Audacity Project Files"),
         wxYES_NO | wxICON_QUESTION);
 
   if (wantAssoc == wxNO)
   {
      // User said no. Set a pref so we don't keep asking.
      gPrefs->Write(wxT("/WantAssociateFiles"), false);
      gPrefs->Flush();
      return;
   }
 
   // Show that user wants associations
   gPrefs->Write(wxT("/WantAssociateFiles"), true);
   gPrefs->Flush();
 
   wxString root_key;
 
   root_key = DefineType(wxT(".aup3"));
   if (root_key.empty())
   {
      //v Warn that we can't set keys. Ask whether to set pref for no retry?
   }
   else
   {
      DefineType(wxT(".aup"));
 
      associateFileTypes = wxT("Audacity.Project"); // Finally set value for .AUP key
      associateFileTypes.SetName(root_key + wxT("Audacity.Project"));
      if (!associateFileTypes.Exists())
      {
         associateFileTypes.Create(true);
         associateFileTypes = wxT("Audacity Project File");
      }
 
      associateFileTypes.SetName(root_key + wxT("Audacity.Project\\shell"));
      if (!associateFileTypes.Exists())
      {
         associateFileTypes.Create(true);
         associateFileTypes = wxT("");
      }
 
      associateFileTypes.SetName(root_key + wxT("Audacity.Project\\shell\\open"));
      if (!associateFileTypes.Exists())
      {
         associateFileTypes.Create(true);
      }
 
      associateFileTypes.SetName(root_key + wxT("Audacity.Project\\shell\\open\\command"));
      wxString tmpRegAudPath;
      if(associateFileTypes.Exists())
      {
         tmpRegAudPath = associateFileTypes.QueryDefaultValue().Lower();
      }
 
      if (!associateFileTypes.Exists() ||
            (tmpRegAudPath.Find(wxT("audacity.exe")) >= 0))
      {
         associateFileTypes.Create(true);
         associateFileTypes = (wxString)argv[0] + (wxString)wxT(" \"%1\"");
      }
 
#if 0
      // These can be use later to support more startup messages
      // like maybe "Import into existing project" or some such.
      // Leaving here for an example...
      associateFileTypes.SetName(root_key + wxT("Audacity.Project\\shell\\open\\ddeexec"));
      if (!associateFileTypes.Exists())
      {
         associateFileTypes.Create(true);
         associateFileTypes = wxT("%1");
      }
 
      associateFileTypes.SetName(root_key + wxT("Audacity.Project\\shell\\open\\ddeexec\\Application"));
      if (!associateFileTypes.Exists())
      {
         associateFileTypes.Create(true);
         associateFileTypes = IPC_APPL;
      }
 
      associateFileTypes.SetName(root_key + wxT("Audacity.Project\\shell\\open\\ddeexec\\Topic"));
      if (!associateFileTypes.Exists())
      {
         associateFileTypes.Create(true);
         associateFileTypes = IPC_TOPIC;
      }
#endif
   }
}

References CommandLineArgs::argv, AudacityMessageBox(), audacity::BasicSettings::Flush(), gPrefs, IPC_APPL, IPC_TOPIC, audacity::BasicSettings::Read(), audacity::BasicSettings::Write(), wxT(), and XO().

Referenced by InitPart2().

Here is the call graph for this function:

Here is the caller graph for this function:

CleanUp()

void AudacityApp::CleanUp ( )

override

Definition at line 1250 of file AudacityApp.cpp.

{
   //Reset the current wxConfigBase instance manually
   //to avoid double deletion in wxWidgets 3.2
   //See Bug #5511
   wxConfigBase::Set(nullptr);
   gConfig.reset();
   wxApp::CleanUp();
}

References gConfig.

CreateSingleInstanceChecker()

bool AudacityApp::CreateSingleInstanceChecker ( const wxString &  dir )

private

Definition at line 1980 of file AudacityApp.cpp.

{
   wxString name = wxString::Format(wxT("audacity-lock-%s"), wxGetUserId());
   mChecker.reset();
   auto checker = std::make_unique<wxSingleInstanceChecker>();
 
   auto runningTwoCopiesStr = XO("Running two copies of Audacity simultaneously may cause\ndata loss or cause your system to crash.\n\n");
 
   if (!checker->Create(name, dir))
   {
      // Error initializing the wxSingleInstanceChecker.  We don't know
      // whether there is another instance running or not.
 
      auto prompt = XO(
"Audacity was not able to lock the temporary files directory.\nThis folder may be in use by another copy of Audacity.\n")
         + runningTwoCopiesStr
         + XO("Do you still want to start Audacity?");
      int action = AudacityMessageBox(
         prompt,
         XO("Error Locking Temporary Folder"),
         wxYES_NO | wxICON_EXCLAMATION, NULL);
      if (action == wxNO)
         return false;
   }
   else if ( checker->IsAnotherRunning() ) {
      // Parse the command line to ensure correct syntax, but
      // ignore options other than -v, and only use the filenames, if any.
      auto parser = ParseCommandLine();
      if (!parser)
      {
         // Complaints have already been made
         return false;
      }
 
      if (parser->Found(wxT("v")))
      {
         wxPrintf("Audacity v%s\n", AUDACITY_VERSION_STRING);
         return false;
      }
 
      // Windows and Linux require absolute file names as command may
      // not come from current working directory.
      FilePaths filenames;
      for (size_t i = 0, cnt = parser->GetParamCount(); i < cnt; i++)
      {
         wxFileName filename(parser->GetParam(i));
         if (filename.MakeAbsolute())
         {
            filenames.push_back(filename.GetLongPath());
         }
      }
 
   #ifdef HAS_CUSTOM_URL_HANDLING
      wxString url;
      parser->Found("u", &url);
   #endif
 
 
      // On Windows, we attempt to make a connection
      // to an already active Audacity.  If successful, we send
      // the first command line argument (the audio file name)
      // to that Audacity for processing.
      wxClient client;
 
      // We try up to 50 times since there's a small window
      // where the server may not have been fully initialized.
      for (int i = 0; i < 50; i++)
      {
         std::unique_ptr<wxConnectionBase> conn{ client.MakeConnection(wxEmptyString, IPC_APPL, IPC_TOPIC) };
         if (conn)
         {
            bool ok = false;
         #ifdef HAS_CUSTOM_URL_HANDLING
            if (!url.empty())
            {
               if (!conn->Execute(urlPrefix + url))
                  return false;
            }
         #endif
 
            if (filenames.size() > 0)
            {
               for (size_t i = 0, cnt = filenames.size(); i < cnt; i++)
               {
                  ok = conn->Execute(filenames[i]);
               }
            }
            else
            {
               // Send an empty string to force existing Audacity to front
               ok = conn->Execute(wxEmptyString);
            }
 
            if (ok)
               return false;
         }
 
         using namespace std::chrono;
         std::this_thread::sleep_for(10ms);
      }
      // There is another copy of Audacity running.  Force quit.
 
      auto prompt =  XO(
"The system has detected that another copy of Audacity is running.\n")
         + runningTwoCopiesStr
         + XO(
"Use the New or Open commands in the currently running Audacity\nprocess to open multiple projects simultaneously.\n");
      AudacityMessageBox(
         prompt, XO("Audacity is already running"),
         wxOK | wxICON_ERROR);
 
      return false;
   }
 
   // Create the DDE IPC server
   mIPCServ = std::make_unique<IPCServ>(IPC_APPL);
   mChecker = std::move(checker);
   return true;
}

References AudacityMessageBox(), IPC_APPL, IPC_TOPIC, mChecker, mIPCServ, name, ParseCommandLine(), audacity::cloud::audiocom::anonymous_namespace{OAuthService.cpp}::urlPrefix, wxT(), and XO().

Referenced by InitPart2().

Here is the call graph for this function:

Here is the caller graph for this function:

HideSplashScreen()

void AudacityApp::HideSplashScreen ( bool  fadeOut = true )

private

Definition at line 1320 of file AudacityApp.cpp.

{
   const int fadeDurationMs = 120;
   const int fadeStepMs = 16;
 
   const int maxTransparency = 255;
   const int numSteps = fadeDurationMs / fadeStepMs;
   const int transparencyDecrement = maxTransparency / numSteps;
 
   int currentAlpha = maxTransparency;
 
   // Splash was already destroyed
   if (!mSplashScreen) {
      return;
   }
 
   if (!fadeOut) {
      mSplashScreen->Destroy();
      mSplashScreen.release();
      return;
   }
 
   mSplashTimer.Start(fadeStepMs);
 
   mSplashTimer.Bind(wxEVT_TIMER, [this, currentAlpha, transparencyDecrement](wxTimerEvent& evt) mutable {
      currentAlpha -= transparencyDecrement;
      if (!mSplashScreen) {
         mSplashTimer.Stop();
      }
      else if (currentAlpha <= 0) {
         mSplashTimer.Stop();
         mSplashScreen->Destroy();
         mSplashScreen.release();
      }
      else if (mSplashScreen->CanSetTransparent()) {
         mSplashScreen->SetTransparent(currentAlpha);
      }
   });
}

References anonymous_namespace{RegisterBuiltinEffects.cpp}::fadeOut, mSplashScreen, and mSplashTimer.

Referenced by InitPart2().

Here is the caller graph for this function:

InitCommandHandler()

void AudacityApp::InitCommandHandler ( )

private

Definition at line 1849 of file AudacityApp.cpp.

{
   mCmdHandler = std::make_unique<CommandHandler>();
   //SetNextHandler(mCmdHandler);
}

References mCmdHandler.

Referenced by InitPart2().

Here is the caller graph for this function:

Initialize()

bool AudacityApp::Initialize ( int &  argc, wxChar **  argv  )

override

Definition at line 1241 of file AudacityApp.cpp.

{
   if(!PluginHost::IsHostProcess())
   {
      InitCrashreports();
   }
   return wxApp::Initialize(argc, argv);
}

References CommandLineArgs::argc, CommandLineArgs::argv, anonymous_namespace{AudacityApp.cpp}::InitCrashreports(), Journal::Events::anonymous_namespace{JournalEvents.cpp}::Initialize(), and PluginHost::IsHostProcess().

Here is the call graph for this function:

InitPart2()

bool AudacityApp::InitPart2

(

)

Definition at line 1524 of file AudacityApp.cpp.

{
#if defined(__WXMAC__)
   SetExitOnFrameDelete(false);
#endif
 
   // Make sure the temp dir isn't locked by another process.
   {
      auto key =
         PreferenceKey(FileNames::Operation::Temp, FileNames::PathType::_None);
      auto temp = gPrefs->Read(key);
      if (temp.empty() || !CreateSingleInstanceChecker(temp)) {
         FinishPreferences();
         return false;
      }
   }
 
   //<<<< Try to avoid dialogs before this point.
   // The reason is that InitTempDir starts the single instance checker.
   // If we're waiitng in a dialog before then we can very easily
   // start multiple instances, defeating the single instance checker.
 
   // Initialize the CommandHandler
   InitCommandHandler();
 
   // Initialize the ModuleManager, including loading found modules
   ModuleManager::Get().Initialize();
 
   // Initialize the PluginManager
   PluginManager::Get().Initialize( [](const FilePath &localFileName){
      return std::make_unique<SettingsWX>(
         AudacityFileConfig::Create({}, {}, localFileName)
      );
   });
 
   // Parse command line and handle options that might require
   // immediate exit...no need to initialize all of the audio
   // stuff to display the version string.
   std::shared_ptr< wxCmdLineParser > parser{ ParseCommandLine() };
   if (!parser)
   {
      // Either user requested help or a parsing error occurred
      exit(1);
   }
 
   wxString journalFileName;
   const bool playingJournal = parser->Found("j", &journalFileName);
 
#if defined(__WXMSW__) && !defined(__WXUNIVERSAL__) && !defined(__CYGWIN__)
   if (!playingJournal)
      this->AssociateFileTypes();
#endif
 
   if (parser->Found(wxT("v")))
   {
      wxPrintf("Audacity v%s\n", AUDACITY_VERSION_STRING);
      exit(0);
   }
 
   long lval;
   if (parser->Found(wxT("b"), &lval))
   {
      if (lval < 256 || lval > 100000000)
      {
         wxPrintf(_("Block size must be within 256 to 100000000\n"));
         exit(1);
      }
 
      Sequence::SetMaxDiskBlockSize(lval);
   }
 
   if (playingJournal)
      Journal::SetInputFileName( journalFileName );
 
   AudacityProject *project;
 
   ShowSplashScreen();
 
   {
      // ANSWER-ME: Why is YieldFor needed at all?
      //Leo: allegedly it hangs on CJK input otherwise, #805
      //wxEventLoopBase::GetActive()->YieldFor(wxEVT_CATEGORY_UI|wxEVT_CATEGORY_USER_INPUT|wxEVT_CATEGORY_UNKNOWN);
      wxEventLoopBase::GetActive()->YieldFor(wxEVT_CATEGORY_UI | wxEVT_CATEGORY_USER_INPUT);
 
      //JKC: Would like to put module loading here.
 
      // More initialization
 
      InitDitherers();
      AudioIO::Init();
 
#ifdef __WXMAC__
 
      // On the Mac, users don't expect a program to quit when you close the last window.
      // Create a menubar that will show when all project windows are closed.
 
      auto fileMenu = std::make_unique<wxMenu>();
      auto urecentMenu = std::make_unique<wxMenu>();
      auto recentMenu = urecentMenu.get();
      fileMenu->Append(wxID_NEW, wxString(_("&New")) + wxT("\tCtrl+N"));
      fileMenu->Append(wxID_OPEN, wxString(_("&Open...")) + wxT("\tCtrl+O"));
      fileMenu->AppendSubMenu(urecentMenu.release(), _("Open &Recent..."));
      fileMenu->Append(wxID_ABOUT, _("&About Audacity..."));
      fileMenu->Append(wxID_PREFERENCES, wxString(_("&Preferences...")) + wxT("\tCtrl+,"));
 
      {
         auto menuBar = std::make_unique<wxMenuBar>();
         menuBar->Append(fileMenu.release(), _("&File"));
 
         // PRL:  Are we sure wxWindows will not leak this menuBar?
         // The online documentation is not explicit.
         wxMenuBar::MacSetCommonMenuBar(menuBar.release());
      }
 
      auto &recentFiles = FileHistory::Global();
      recentFiles.UseMenu(recentMenu);
 
#endif //__WXMAC__
   }
 
   //Search for the new plugins
   std::vector<wxString> failedPlugins;
   if(!playingJournal && !SkipEffectsScanAtStartup.Read())
   {
      HideSplashScreen(true);
      auto newPlugins = PluginManager::Get().CheckPluginUpdates();
      if(!newPlugins.empty())
      {
         PluginStartupRegistration reg(newPlugins);
         reg.Run();
         failedPlugins = reg.GetFailedPluginsPaths();
      }
   }
 
   // Must do this before creating the first project, else the early exit path
   // may crash
   if ( !Journal::Begin( FileNames::DataDir() ) )
      return false;
 
   // Workaround Bug 1377 - Crash after Audacity starts and low disk space warning appears
   // The temporary splash window is closed AND cleaned up, before attempting to create
   // a project and possibly creating a modal warning dialog by doing so.
   // Also fixes problem of warning being obscured.
   // Downside is that we have no splash screen for the (brief) time that we spend
   // creating the project.
   // Root cause is problem with wxSplashScreen and other dialogs co-existing, that
   // seemed to arrive with wx3.
   {
      project = ProjectManager::New();
   }
 
   if (!playingJournal && ProjectSettings::Get(*project).GetShowSplashScreen())
   {
      // This may do a check-for-updates at every start up.
      // Mainly this is to tell users of ALPHAS who don't know that they have an ALPHA.
      // Disabled for now, after discussion.
      // project->MayCheckForUpdates();
#ifdef HAS_WHATS_NEW
      WhatsNewDialog::Show(*project);
#endif
   }
 
   // Update Manager may spawn a modal dialog, we need to hide the splash screen before that
   bool splashFadeOut = !playingJournal;
   HideSplashScreen(splashFadeOut);
 
#if defined(HAVE_UPDATES_CHECK)
   UpdateManager::Start(playingJournal);
#endif
 
   Importer::Get().Initialize();
   ExportPluginRegistry::Get().Initialize();
 
   // Bug1561: delay the recovery dialog, to avoid crashes.
   CallAfter( [=] () mutable {
      // Remove duplicate shortcuts when there's a change of version
      int vMajorInit, vMinorInit, vMicroInit;
      GetPreferencesVersion(vMajorInit, vMinorInit, vMicroInit);
      if (vMajorInit != AUDACITY_VERSION || vMinorInit != AUDACITY_RELEASE
         || vMicroInit != AUDACITY_REVISION) {
         MenuCreator::Get(*project).RemoveDuplicateShortcuts();
      }
      //
      // Auto-recovery
      //
      bool didRecoverAnything = false;
      // This call may reassign project (passed by reference)
      if (!playingJournal)
      {
         if (!ShowAutoRecoveryDialogIfNeeded(project, &didRecoverAnything))
         {
            QuitAudacity(true);
         }
      }
 
      //
      // Remainder of command line parsing, but only if we didn't recover
      //
      if (project && !didRecoverAnything)
      {
         if (parser->Found(wxT("t")))
         {
            RunBenchmark( nullptr, *project);
            QuitAudacity(true);
         }
 
         for (size_t i = 0, cnt = parser->GetParamCount(); i < cnt; i++)
         {
            // PRL: Catch any exceptions, don't try this file again, continue to
            // other files.
            SafeMRUOpen(parser->GetParam(i));
         }
 
         if(!failedPlugins.empty())
         {
            auto dialog = safenew IncompatiblePluginsDialog(GetTopWindow(), wxID_ANY, ScanType::Startup, failedPlugins);
            dialog->Bind(wxEVT_CLOSE_WINDOW, [dialog](wxCloseEvent&) { dialog->Destroy(); });
            dialog->Show();
         }
      }
   } );
 
   gInited = true;
 
   ModuleManager::Get().Dispatch(AppInitialized);
 
   mTimer.SetOwner(this, kAudacityAppTimerID);
   mTimer.Start(200);
 
#ifdef EXPERIMENTAL_EASY_CHANGE_KEY_BINDINGS
   static CommandManager::GlobalMenuHook::Scope scope{
   [](const CommandID &id){
      if (::wxGetMouseState().ShiftDown()) {
         // Only want one page of the preferences
         PrefsPanel::Factories factories;
         factories.push_back(KeyConfigPrefsFactory( id ));
         const auto pProject = GetActiveProject().lock();
         auto pWindow = FindProjectFrame( pProject.get() );
         // pProject may be null
         GlobalPrefsDialog dialog( pWindow, pProject.get(), factories );
         dialog.ShowModal();
         MenuCreator::RebuildAllMenuBars();
         return true;
      }
      else
         return false;
   } };
#endif
 
#if defined(__WXMAC__)
   // The first time this version of Audacity is run or when the preferences
   // are reset, execute the "tccutil" command to reset the microphone permissions
   // currently assigned to Audacity.  The end result is that the user will be
   // prompted to approve/deny Audacity access (again).
   //
   // This should resolve confusion of why Audacity appears to record, but only
   // gets silence due to Audacity being denied microphone access previously.
   bool permsReset = false;
   gPrefs->Read(wxT("/MicrophonePermissionsReset"), &permsReset, false);
   if (!permsReset) {
      system("tccutil reset Microphone org.audacityteam.audacity");
      gPrefs->Write(wxT("/MicrophonePermissionsReset"), true);
   }
#endif
 
#if defined(__WXMAC__)
   // Bug 2709: Workaround CoreSVG locale issue
   Bind(wxEVT_MENU_OPEN, [=](wxMenuEvent &event)
   {
      wxSetlocale(LC_NUMERIC, wxString(wxT("C")));
      event.Skip();
   });
 
   Bind(wxEVT_MENU_CLOSE, [=](wxMenuEvent &event)
   {
      wxSetlocale(LC_NUMERIC, Languages::GetLocaleName());
      event.Skip();
   });
#endif
 
#ifdef HAS_CUSTOM_URL_HANDLING
   // Schemes are case insensitive as per RFC: https://www.rfc-editor.org/rfc/rfc3986#section-3.1
   URLSchemesRegistry::Get().RegisterScheme(AUDACITY_NAME);
 
   wxString url;
   if (parser->Found("u", &url))
   {
      auto utf8Url = url.ToUTF8();
      URLSchemesRegistry::Get().HandleURL({ utf8Url.data(), utf8Url.length() });
   }
#endif
 
   HandleAppInitialized();
 
   return TRUE;
}

References _, AppInitialized, AssociateFileTypes(), Journal::Begin(), BasicUI::CallAfter(), PluginManager::CheckPluginUpdates(), AudacityFileConfig::Create(), CreateSingleInstanceChecker(), FileNames::DataDir(), ModuleManager::Dispatch(), FindProjectFrame(), FinishPreferences(), ExportPluginRegistry::Get(), Importer::Get(), ModuleManager::Get(), PluginManager::Get(), URLSchemesRegistry::Get(), MenuCreator::Get(), ProjectSettings::Get(), GetActiveProject(), Languages::GetLocaleName(), GetPreferencesVersion(), ProjectSettings::GetShowSplashScreen(), gInited, FileHistory::Global(), gPrefs, AppEvents::ProviderBase::HandleAppInitialized(), URLSchemesRegistry::HandleURL(), HideSplashScreen(), id, AudioIO::Init(), InitCommandHandler(), InitDitherers(), ExportPluginRegistry::Initialize(), Importer::Initialize(), ModuleManager::Initialize(), PluginManager::Initialize(), kAudacityAppTimerID, key, KeyConfigPrefsFactory(), mTimer, ProjectManager::New(), ParseCommandLine(), FileNames::PreferenceKey(), project, QuitAudacity(), audacity::BasicSettings::Read(), Setting< T >::Read(), MenuCreator::RebuildAllMenuBars(), anonymous_namespace{CompareAudioCommand.cpp}::reg, URLSchemesRegistry::RegisterScheme(), MenuCreator::RemoveDuplicateShortcuts(), RunBenchmark(), SafeMRUOpen(), safenew, anonymous_namespace{wxCommandTargets.cpp}::scope, Journal::SetInputFileName(), Sequence::SetMaxDiskBlockSize(), WhatsNewDialog::Show(), ShowAutoRecoveryDialogIfNeeded(), PrefsDialog::ShowModal(), ShowSplashScreen(), SkipEffectsScanAtStartup, UpdateManager::Start(), Startup, audacity::BasicSettings::Write(), and wxT().

Referenced by OnInit().

Here is the caller graph for this function:

InitTempDir()

bool AudacityApp::InitTempDir ( )

private

Definition at line 1903 of file AudacityApp.cpp.

{
   // We need to find a temp directory location.
   auto tempFromPrefs = TempDirectory::TempDir();
   auto tempDefaultLoc = TempDirectory::DefaultTempDir();
 
   wxString temp;
 
   #ifdef __WXGTK__
   if (tempFromPrefs.length() > 0 && tempFromPrefs[0] != wxT('/'))
      tempFromPrefs = wxT("");
   #endif
 
   // Stop wxWidgets from printing its own error messages
 
   wxLogNull logNo;
 
   // Try temp dir that was stored in prefs first
   if( TempDirectory::IsTempDirectoryNameOK( tempFromPrefs ) )
      SetToExtantDirectory( temp, tempFromPrefs );
 
   // If that didn't work, try the default location
 
   if (temp.empty())
      SetToExtantDirectory( temp, tempDefaultLoc );
 
   // Check temp directory ownership on *nix systems only
   #ifdef __UNIX__
   struct stat tempStatBuf;
   if ( lstat(temp.mb_str(), &tempStatBuf) != 0 ) {
      temp.clear();
   }
   else {
      if ( geteuid() != tempStatBuf.st_uid ) {
         temp.clear();
      }
   }
   #endif
 
   if (temp.empty()) {
      // Failed
      if( !TempDirectory::IsTempDirectoryNameOK( tempFromPrefs ) ) {
         AudacityMessageBox(XO(
"Audacity could not find a safe place to store temporary files.\nAudacity needs a place where automatic cleanup programs won't delete the temporary files.\nPlease enter an appropriate directory in the preferences dialog."));
      } else {
         AudacityMessageBox(XO(
"Audacity could not find a place to store temporary files.\nPlease enter an appropriate directory in the preferences dialog."));
      }
 
      // Only want one page of the preferences
      PrefsPanel::Factories factories;
      factories.push_back(DirectoriesPrefsFactory());
      GlobalPrefsDialog dialog(nullptr, nullptr, factories);
      dialog.ShowModal();
 
      AudacityMessageBox(XO(
"Audacity is now going to exit. Please launch Audacity again to use the new temporary directory."));
      return false;
   }
 
   // The permissions don't always seem to be set on
   // some platforms.  Hopefully this fixes it...
   #ifdef __UNIX__
   chmod(OSFILENAME(temp), 0700);
   #endif
 
   TempDirectory::ResetTempDir();
   FileNames::UpdateDefaultPath(FileNames::Operation::Temp, temp);
 
   return true;
}

References AudacityMessageBox(), TempDirectory::DefaultTempDir(), DirectoriesPrefsFactory(), TempDirectory::IsTempDirectoryNameOK(), OSFILENAME, TempDirectory::ResetTempDir(), SetToExtantDirectory(), PrefsDialog::ShowModal(), TempDirectory::TempDir(), FileNames::UpdateDefaultPath(), wxT(), and XO().

Referenced by OnInit().

Here is the call graph for this function:

Here is the caller graph for this function:

MacActivateApp()

void AudacityApp::MacActivateApp

(

)

MacFinishLaunching()

void AudacityApp::MacFinishLaunching

(

)

Referenced by OnInit().

Here is the caller graph for this function:

MacNewFile()

void AudacityApp::MacNewFile ( )

override

Definition at line 963 of file AudacityApp.cpp.

{
   if (!gInited)
      return;
 
   // This method should only be used on the Mac platform
   // when no project windows are open.
 
   if (AllProjects{}.empty())
      (void) ProjectManager::New();
}

References AllProjects::empty(), gInited, and ProjectManager::New().

Here is the call graph for this function:

MacOpenFile()

void AudacityApp::MacOpenFile ( const wxString &  fileName )

override

Definition at line 951 of file AudacityApp.cpp.

{
   ofqueue.push_back(fileName);
}

References ofqueue.

MacPrintFile()

void AudacityApp::MacPrintFile ( const wxString &  fileName )

override

Definition at line 957 of file AudacityApp.cpp.

{
   ofqueue.push_back(fileName);
}

References ofqueue.

MRUOpen()

bool AudacityApp::MRUOpen

(

const FilePath &

fileName

)

Referenced by OnMRUFile(), and SafeMRUOpen().

Here is the caller graph for this function:

OnEndSession()

void AudacityApp::OnEndSession

(

wxCloseEvent &

event

)

Definition at line 2489 of file AudacityApp.cpp.

{
   bool force = !event.CanVeto();
 
   // Try to close each open window.  If the user hits Cancel
   // in a Save Changes dialog, don't continue.
   gIsQuitting = true;
   if (AllProjects{}.size())
      // PRL:  Always did at least once before close might be vetoed
      // though I don't know why that is important
      ProjectManager::SaveWindowSize();
   bool closedAll = CloseAllProjects( force );
   if ( !closedAll )
   {
      gIsQuitting = false;
      event.Veto();
   }
}

References CloseAllProjects(), gIsQuitting, ProjectManager::SaveWindowSize(), and AllProjects::size().

Referenced by OnQueryEndSession().

Here is the call graph for this function:

Here is the caller graph for this function:

OnExceptionInMainLoop()

bool AudacityApp::OnExceptionInMainLoop ( )

override

Definition at line 1188 of file AudacityApp.cpp.

{
   // This function is invoked from catch blocks in the wxWidgets framework,
   // and throw; without argument re-throws the exception being handled,
   // letting us dispatch according to its type.
 
   try { throw; }
   catch ( AudacityException &e ) {
      (void)e;// Compiler food
      // Here is the catch-all for our own exceptions
 
      // Use CallAfter to delay this to the next pass of the event loop,
      // rather than risk doing it inside stack unwinding.
      auto pProject = ::GetActiveProject().lock();
      auto pException = std::current_exception();
      CallAfter( [pException, pProject] {
 
         // Restore the state of the project to what it was before the
         // failed operation
         if (pProject) {
            ProjectHistory::Get( *pProject ).RollbackState();
 
            // Forget pending changes in the TrackList
            PendingTracks::Get(*pProject).ClearPendingTracks();
            Viewport::Get(*pProject).Redraw();
         }
 
         // Give the user an alert
         try { std::rethrow_exception( pException ); }
         catch( AudacityException &e )
            { e.DelayedHandlerAction(); }
 
      } );
 
      // Don't quit the program
      return true;
   }
   catch ( ... ) {
      // There was some other type of exception we don't know.
      // Let the inherited function do throw; again and whatever else it does.
      return wxApp::OnExceptionInMainLoop();
   }
   // Shouldn't ever reach this line
   return false;
}

References BasicUI::CallAfter(), PendingTracks::ClearPendingTracks(), AudacityException::DelayedHandlerAction(), ProjectHistory::Get(), PendingTracks::Get(), Viewport::Get(), GetActiveProject(), Viewport::Redraw(), and ProjectHistory::RollbackState().

Referenced by OnIdle().

Here is the call graph for this function:

Here is the caller graph for this function:

OnExit()

int AudacityApp::OnExit ( void  )

override

Definition at line 2508 of file AudacityApp.cpp.

{
   gIsQuitting = true;
   while(Pending())
   {
      Dispatch();
   }
 
   HandleAppClosing();
 
   Importer::Get().Terminate();
 
   if(gPrefs)
   {
      bool bFalse = false;
      //Should we change the commands.cfg location next startup?
      if(gPrefs->Read(wxT("/QDeleteCmdCfgLocation"), &bFalse))
      {
         gPrefs->DeleteEntry(wxT("/QDeleteCmdCfgLocation"));
         gPrefs->Write(wxT("/DeleteCmdCfgLocation"), true);
         gPrefs->Flush();
      }
   }
 
   FileHistory::Global().Save(*gPrefs);
 
   FinishPreferences();
 
   DeinitFFT();
 
#ifdef HAS_NETWORKING
   audacity::network_manager::NetworkManager::GetInstance().Terminate();
#endif
 
   AudioIO::Deinit();
 
   // Terminate the PluginManager (must be done before deleting the locale)
   PluginManager::Get().Terminate();
 
   return 0;
}

References AudioIO::Deinit(), DeinitFFT(), audacity::BasicSettings::DeleteEntry(), TypeSwitch::Dispatch(), FinishPreferences(), audacity::BasicSettings::Flush(), Importer::Get(), PluginManager::Get(), audacity::network_manager::NetworkManager::GetInstance(), gIsQuitting, FileHistory::Global(), gPrefs, AppEvents::ProviderBase::HandleAppClosing(), audacity::BasicSettings::Read(), FileHistory::Save(), Importer::Terminate(), PluginManager::Terminate(), audacity::network_manager::NetworkManager::Terminate(), audacity::BasicSettings::Write(), and wxT().

Here is the call graph for this function:

OnFatalException()

void AudacityApp::OnFatalException ( )

override

Definition at line 1172 of file AudacityApp.cpp.

{
#if defined(HAS_CRASH_REPORT)
   CrashReport::Generate(wxDebugReport::Context_Exception);
#endif
 
   exit(-1);
}

OnIdle()

void AudacityApp::OnIdle

(

wxIdleEvent &

evt

)

Definition at line 1831 of file AudacityApp.cpp.

{
   evt.Skip();
   try {
      HandleAppIdle();
 
      if ( Journal::Dispatch() )
         evt.RequestMore();
   }
   catch( ... ) {
      // Hmm, wxWidgets doesn't guard calls to the idle handler as for other
      // events.  So replicate some of the try-catch logic here.
      OnExceptionInMainLoop();
      // Fall through and return, allowing delayed handler action of
      // AudacityException to clean up
   }
}

References Journal::Dispatch(), AppEvents::ProviderBase::HandleAppIdle(), and OnExceptionInMainLoop().

Here is the call graph for this function:

OnInit()

bool AudacityApp::OnInit ( )

override

Definition at line 1442 of file AudacityApp.cpp.

{
   RegisterBuiltinEffects();
 
   // JKC: ANSWER-ME: Who actually added the event loop guarantor?
   // Although 'blame' says Leland, I think it came from a donated patch.
 
   // PRL:  It was added by LL at 54676a72285ba7ee3a69920e91fa390a71ef10c9 :
   // "   Ensure OnInit() has an event loop
   //     And allow events to flow so the splash window updates under GTK"
   // then mistakenly lost in the merge at
   // 37168ebbf67ae869ab71a3b5cbbf1d2a48e824aa
   // then restored at 7687972aa4b2199f0717165235f3ef68ade71e08
 
   // Ensure we have an event loop during initialization
   wxEventLoopGuarantor eventLoop;
 
   OnInit0();
 
   FileNames::InitializePathList();
 
   // Define languages for which we have translations, but that are not yet
   // supported by wxWidgets.
   //
   // TODO:  The whole Language initialization really need to be reworked.
   //        It's all over the place.
#if wxCHECK_VERSION(3, 0, 1) && !wxCHECK_VERSION(3, 1, 6)
   for (size_t i = 0, cnt = WXSIZEOF(userLangs); i < cnt; i++)
   {
      wxLocale::AddLanguage(userLangs[i]);
   }
#endif
 
   // Initialize preferences and language
   {
      InitPreferences(audacity::ApplicationSettings::Call());
      PopulatePreferences();
   }
 
   mThemeChangeSubscription = theTheme.Subscribe(OnThemeChange);
 
   {
      wxBusyCursor busy;
      theTheme.LoadPreferredTheme();
   }
 
   // AColor depends on theTheme.
   AColor::Init();
 
   // If this fails, we must exit the program.
   if (!InitTempDir()) {
      FinishPreferences();
      return false;
   }
 
   ThemeResources::Load();
 
#ifdef __WXMAC__
   // Bug2437:  When files are opened from Finder and another instance of
   // Audacity is running, we must return from OnInit() to wxWidgets before
   // MacOpenFile is called, informing us of the paths that need to be
   // opened.  So use CallAfter() to delay the rest of initialization.
   // See CreateSingleInstanceChecker() where we send those paths over a
   // socket to the prior instance.
 
   // This call is what probably makes the sleep unnecessary:
   MacFinishLaunching();
 
   using namespace std::chrono;
   // This sleep may be unnecessary, but it is harmless.  It less NS framework
   // events arrive on another thread, but it might not always be long enough.
   std::this_thread::sleep_for(100ms);
   CallAfter([this]{
      if (!InitPart2())
         exit(-1);
   });
   return true;
#else
   return InitPart2();
#endif
}

References GlobalHook< ApplicationSettings, std::unique_ptr< BasicSettings >()>::Call(), BasicUI::CallAfter(), FinishPreferences(), AColor::Init(), FileNames::InitializePathList(), InitPart2(), InitPreferences(), InitTempDir(), ThemeResources::Load(), ThemeBase::LoadPreferredTheme(), MacFinishLaunching(), mThemeChangeSubscription, OnInit0(), OnThemeChange(), anonymous_namespace{AudacityApp.cpp}::PopulatePreferences(), RegisterBuiltinEffects(), Observer::Publisher< Message, NotifyAll >::Subscribe(), and theTheme.

Here is the call graph for this function:

OnInit0()

void AudacityApp::OnInit0 ( )

private

Definition at line 1361 of file AudacityApp.cpp.

{
   // Inject basic GUI services behind the facades
   {
      static wxWidgetsBasicUI uiServices;
      (void)BasicUI::Install(&uiServices);
 
      static WindowPlacementFactory::Scope scope {
      [](AudacityProject &project)
         -> std::unique_ptr<BasicUI::WindowPlacement> {
         return std::make_unique<wxWidgetsWindowPlacement>(
            &GetProjectFrame(project));
      } };
   }
 
   // Fire up SQLite
   if ( !ProjectFileIO::InitializeSQL() )
      this->CallAfter([]{
         ::AudacityMessageBox(
            XO("SQLite library failed to initialize.  Audacity cannot continue.") );
         QuitAudacity( true );
      });
 
 
   // cause initialization of wxWidgets' global logger target
   (void) AudacityLogger::Get();
 
#if defined(__WXMAC__)
   // Disable window animation
   wxSystemOptions::SetOption(wxMAC_WINDOW_PLAIN_TRANSITION, 1);
#endif
 
   // Some GTK themes produce larger combo boxes that make them taller
   // than our single toolbar height restriction.  This will remove some
   // of the extra space themes add.
#if defined(__WXGTK3__) && defined(HAVE_GTK)
   GtkWidget *combo = gtk_combo_box_new();
   GtkCssProvider *provider = gtk_css_provider_new();
   gtk_css_provider_load_from_data(GTK_CSS_PROVIDER(provider),
                                   ".linked entry,\n"
                                   ".linked button,\n"
                                   ".linked combobox box.linked button,\n"
                                   ".horizontal.linked entry,\n"
                                   ".horizontal.linked button,\n"
                                   ".horizontal.linked combobox box.linked button,\n"
                                   "combobox {\n"
                                   "   padding-top: 0px;\n"
                                   "   padding-bottom: 0px;\n"
                                   "   padding-left: 4px;\n"
                                   "   padding-right: 4px;\n"
                                   "   margin: 0px;\n"
                                   "   font-size: 95%;\n"
                                   "}", -1, NULL);
   gtk_style_context_add_provider_for_screen(gtk_widget_get_screen(combo),
                                             GTK_STYLE_PROVIDER (provider),
                                             GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
   g_object_unref(provider);
   g_object_unref(combo);
#elif defined(__WXGTK__) && defined(HAVE_GTK)
   gtk_rc_parse_string("style \"audacity\" {\n"
                       " GtkButton::inner_border = { 0, 0, 0, 0 }\n"
                       " GtkEntry::inner_border = { 0, 0, 0, 0 }\n"
                       " xthickness = 4\n"
                       " ythickness = 0\n"
                       "}\n"
                       "widget_class \"*GtkCombo*\" style \"audacity\"");
#endif
 
   wxTheApp->SetAppName(AppName);
   // Explicitly set since OSX will use it for the "Quit" menu item
   wxTheApp->SetAppDisplayName(AppName);
   wxTheApp->SetVendorName(AppName);
 
   ::wxInitAllImageHandlers();
 
   // AddHandler takes ownership
   wxFileSystem::AddHandler(safenew wxZipFSHandler);
}

References AppName, AudacityMessageBox(), BasicUI::CallAfter(), AudacityLogger::Get(), GetProjectFrame(), ProjectFileIO::InitializeSQL(), BasicUI::Install(), project, QuitAudacity(), safenew, anonymous_namespace{wxCommandTargets.cpp}::scope, and XO().

Referenced by OnInit().

Here is the call graph for this function:

Here is the caller graph for this function:

OnKeyDown()

void AudacityApp::OnKeyDown

(

wxKeyEvent &

event

)

Definition at line 1862 of file AudacityApp.cpp.

{
   if(event.GetKeyCode() == WXK_ESCAPE) {
      // Stop play, including scrub, but not record
      if ( auto project = ::GetActiveProject().lock() ) {
         auto token = ProjectAudioIO::Get( *project ).GetAudioIOToken();
         auto &scrubber = Scrubber::Get( *project );
         auto scrubbing = scrubber.HasMark();
         if (scrubbing)
            scrubber.Cancel();
         auto gAudioIO = AudioIO::Get();
         if((token > 0 &&
                  gAudioIO->IsAudioTokenActive(token) &&
                  gAudioIO->GetNumCaptureChannels() == 0) ||
            scrubbing)
            // ESC out of other play (but not record)
            ProjectAudioManager::Get( *project ).Stop();
         else
            event.Skip();
      }
   }
 
   event.Skip();
}

References AudioIO::Get(), ProjectAudioIO::Get(), ProjectAudioManager::Get(), Scrubber::Get(), GetActiveProject(), ProjectAudioIO::GetAudioIOToken(), project, and ProjectAudioManager::Stop().

Here is the call graph for this function:

OnMenuAbout()

void AudacityApp::OnMenuAbout

(

wxCommandEvent &

event

)

Definition at line 2560 of file AudacityApp.cpp.

{
   // This function shadows a similar function
   // in Menus.cpp, but should only be used on the Mac platform.
#ifdef __WXMAC__
   // Modeless dialog, consistent with other Mac applications
   // Not more than one at once!
   const auto instance = AboutDialog::ActiveIntance();
   if (instance)
      instance->Raise();
   else
      // This dialog deletes itself when dismissed
      (safenew AboutDialog{ nullptr })->Show(true);
#else
      wxASSERT(false);
#endif
}

References AboutDialog::ActiveIntance(), safenew, and ExportProgressUI::Show().

Here is the call graph for this function:

OnMenuExit()

void AudacityApp::OnMenuExit

(

wxCommandEvent &

event

)

Definition at line 2627 of file AudacityApp.cpp.

{
   // This function shadows a similar function
   // in Menus.cpp, but should only be used on the Mac platform
   // when no project windows are open. This check assures that
   // this happens, and enable the same code to be present on
   // all platforms.
 
   // LL:  Removed "if" to allow closing based on final project count.
   // if(AllProjects{}.empty())
      QuitAudacity();
 
   // LL:  Veto quit if projects are still open.  This can happen
   //      if the user selected Cancel in a Save dialog.
   event.Skip(AllProjects{}.empty());
 
}

References AllProjects::empty(), and QuitAudacity().

Here is the call graph for this function:

OnMenuNew()

void AudacityApp::OnMenuNew

(

wxCommandEvent &

event

)

Definition at line 2578 of file AudacityApp.cpp.

{
   // This function shadows a similar function
   // in Menus.cpp, but should only be used on the Mac platform
   // when no project windows are open. This check assures that
   // this happens, and enable the same code to be present on
   // all platforms.
 
   if(AllProjects{}.empty())
      (void) ProjectManager::New();
   else
      event.Skip();
}

References AllProjects::empty(), and ProjectManager::New().

Here is the call graph for this function:

OnMenuOpen()

void AudacityApp::OnMenuOpen

(

wxCommandEvent &

event

)

Definition at line 2593 of file AudacityApp.cpp.

{
   // This function shadows a similar function
   // in Menus.cpp, but should only be used on the Mac platform
   // when no project windows are open. This check assures that
   // this happens, and enable the same code to be present on
   // all platforms.
 
 
   if(AllProjects{}.empty())
      ProjectManager::OpenFiles(NULL);
   else
      event.Skip();
 
 
}

References AllProjects::empty(), and ProjectManager::OpenFiles().

Here is the call graph for this function:

OnMenuPreferences()

void AudacityApp::OnMenuPreferences

(

wxCommandEvent &

event

)

Definition at line 2610 of file AudacityApp.cpp.

{
   // This function shadows a similar function
   // in Menus.cpp, but should only be used on the Mac platform
   // when no project windows are open. This check assures that
   // this happens, and enable the same code to be present on
   // all platforms.
 
   if(AllProjects{}.empty()) {
      GlobalPrefsDialog dialog(nullptr /* parent */, nullptr );
      dialog.ShowModal();
   }
   else
      event.Skip();
 
}

References AllProjects::empty(), and PrefsDialog::ShowModal().

Here is the call graph for this function:

OnMRUClear()

void AudacityApp::OnMRUClear

(

wxCommandEvent &

event

)

Definition at line 1075 of file AudacityApp.cpp.

{
   FileHistory::Global().Clear();
}

References FileHistory::Clear(), and FileHistory::Global().

Here is the call graph for this function:

OnMRUFile()

void AudacityApp::OnMRUFile

(

wxCommandEvent &

event

)

Definition at line 1083 of file AudacityApp.cpp.

                                                 {
   int n = event.GetId() - FileHistory::ID_RECENT_FIRST;
   auto &history = FileHistory::Global();
   const auto &fullPathStr = history[ n ];
 
   // Try to open only if not already open.
   // Test IsAlreadyOpen() here even though AudacityProject::MRUOpen() also now checks,
   // because we don't want to Remove() just because it already exists,
   // and AudacityApp::OnMacOpenFile() calls MRUOpen() directly.
   // that method does not return the bad result.
   // PRL: Don't call SafeMRUOpen
   // -- if open fails for some exceptional reason of resource exhaustion that
   // the user can correct, leave the file in history.
   if (!ProjectFileManager::IsAlreadyOpen(fullPathStr) && !MRUOpen(fullPathStr))
      history.Remove(n);
}

References FileHistory::Global(), FileHistory::ID_RECENT_FIRST, ProjectFileManager::IsAlreadyOpen(), and MRUOpen().

Here is the call graph for this function:

OnQueryEndSession()

void AudacityApp::OnQueryEndSession

(

wxCloseEvent &

event

)

Definition at line 2475 of file AudacityApp.cpp.

{
   bool mustVeto = false;
 
#ifdef __WXMAC__
   mustVeto = wxDialog::OSXHasModalDialogsOpen();
#endif
 
   if ( mustVeto )
      event.Veto(true);
   else
      OnEndSession(event);
}

References OnEndSession().

Here is the call graph for this function:

OnReceiveCommand()

void AudacityApp::OnReceiveCommand

(

AppCommandEvent &

event

)

Definition at line 1856 of file AudacityApp.cpp.

{
   wxASSERT(NULL != mCmdHandler);
   mCmdHandler->OnReceiveCommand(event);
}

References mCmdHandler.

OnRun()

int AudacityApp::OnRun ( )

override

Definition at line 1821 of file AudacityApp.cpp.

{
   // Returns 0 to the command line if the run completed normally
   auto result = wxApp::OnRun();
   if (result == 0)
      // If not otherwise abnormal, report any journal sync failure
      result = Journal::GetExitCode();
   return result;
}

References Journal::GetExitCode().

Here is the call graph for this function:

OnServerEvent()

void AudacityApp::OnServerEvent

(

wxSocketEvent &

evt

)

OnSocketEvent()

void AudacityApp::OnSocketEvent

(

wxSocketEvent &

evt

)

OnThemeChange()

static void AudacityApp::OnThemeChange ( struct ThemeChangeMessage  )

static

Referenced by OnInit().

Here is the caller graph for this function:

OnTimer()

void AudacityApp::OnTimer

(

wxTimerEvent &

event

)

Definition at line 1100 of file AudacityApp.cpp.

{
   // Filenames are queued when Audacity receives a few of the
   // AppleEvent messages (via wxWidgets).  So, open any that are
   // in the queue and clean the queue.
   if (gInited) {
      if (ofqueue.size()) {
         // Load each file on the queue
         while (ofqueue.size()) {
            wxString name;
            name.swap(ofqueue[0]);
            ofqueue.erase( ofqueue.begin() );
 
            // Get the user's attention if no file name was specified
            if (name.empty()) {
               // Get the users attention
               if (auto project = GetActiveProject().lock()) {
                  auto &window = GetProjectFrame( *project );
                  window.Maximize();
                  window.Raise();
                  window.RequestUserAttention();
               }
               continue;
            }
 
         #ifdef HAS_CUSTOM_URL_HANDLING
            if (name.StartsWith(urlPrefix))
            {
               const auto utf8Url = name.ToUTF8();
               const size_t prefixSize = urlPrefix.Length();
 
               if (utf8Url.length() <= prefixSize)
                  continue;
 
               URLSchemesRegistry::Get().HandleURL(
                  { utf8Url.data() + prefixSize,
                    utf8Url.length() - prefixSize });
            }
            else
         #endif
            // TODO: Handle failures better.
            // Some failures are OK, e.g. file not found, just would-be-nices to do better,
            // so FAIL_MSG is more a case of an enhancement request than an actual  problem.
            // LL:  In all but one case an appropriate message is already displayed.  The
            //      instance that a message is NOT displayed is when a failure to write
            //      to the config file has occurred.
            // PRL: Catch any exceptions, don't try this file again, continue to
            // other files.
            if (!SafeMRUOpen(name)) {
               // Just log it.  Assertion failure is not appropriate on valid
               // defensive path against bad file data.
               wxLogMessage(wxT("MRUOpen failed"));
            }
         }
      }
   }
}

References URLSchemesRegistry::Get(), GetActiveProject(), GetProjectFrame(), gInited, URLSchemesRegistry::HandleURL(), name, ofqueue, project, SafeMRUOpen(), audacity::cloud::audiocom::anonymous_namespace{OAuthService.cpp}::urlPrefix, and wxT().

Here is the call graph for this function:

OSXIsGUIApplication()

bool AudacityApp::OSXIsGUIApplication ( )

override

Definition at line 1261 of file AudacityApp.cpp.

{
   return sOSXIsGUIApplication;
}

References IMPLEMENT_WX_THEME_SUPPORT::sOSXIsGUIApplication.

ParseCommandLine()

std::unique_ptr< wxCmdLineParser > AudacityApp::ParseCommandLine ( )

private

Definition at line 2426 of file AudacityApp.cpp.

{
   auto parser = std::make_unique<wxCmdLineParser>(argc, argv);
   if (!parser)
   {
      return nullptr;
   }
 
   /*i18n-hint: This controls the number of bytes that Audacity will
    *           use when writing files to the disk */
   parser->AddOption(wxT("b"), wxT("blocksize"), _("set max disk block size in bytes"),
                     wxCMD_LINE_VAL_NUMBER);
 
   const auto journalOptionDescription =
   /*i18n-hint: brief help message for Audacity's command-line options
     A journal contains a sequence of user interface interactions to be repeated
     "log," "trail," "trace" have somewhat similar meanings */
      _("replay a journal file");
 
   parser->AddOption(wxT("j"), wxT("journal"), journalOptionDescription);
 
   /*i18n-hint: This displays a list of available options */
   parser->AddSwitch(wxT("h"), wxT("help"), _("this help message"),
                     wxCMD_LINE_OPTION_HELP);
 
   /*i18n-hint: This runs a set of automatic tests on Audacity itself */
   parser->AddSwitch(wxT("t"), wxT("test"), _("run self diagnostics"));
 
   /*i18n-hint: This displays the Audacity version */
   parser->AddSwitch(wxT("v"), wxT("version"), _("display Audacity version"));
 
   /*i18n-hint: This is a list of one or more files that Audacity
    *           should open upon startup */
   parser->AddParam(_("audio or project file name"),
                    wxCMD_LINE_VAL_STRING,
                    wxCMD_LINE_PARAM_MULTIPLE | wxCMD_LINE_PARAM_OPTIONAL);
 
#ifdef HAS_CUSTOM_URL_HANDLING
   /* i18n-hint: This option is used to handle custom URLs in Audacity */
   parser->AddOption(wxT("u"), wxT("url"), _("Handle 'audacity://' url"));
#endif
 
   // Run the parser
   if (parser->Parse() == 0)
      return parser;
 
   return{};
}

References _, CommandLineArgs::argc, CommandLineArgs::argv, and wxT().

Referenced by CreateSingleInstanceChecker(), and InitPart2().

Here is the call graph for this function:

Here is the caller graph for this function:

SafeMRUOpen()

bool AudacityApp::SafeMRUOpen

(

const wxString &

fileName

)

Definition at line 1070 of file AudacityApp.cpp.

{
   return GuardedCall< bool >( [&]{ return MRUOpen( fullPathStr ); } );
}

References MRUOpen().

Referenced by InitPart2(), and OnTimer().

Here is the call graph for this function:

Here is the caller graph for this function:

ShowSplashScreen()

void AudacityApp::ShowSplashScreen ( )

private

Definition at line 1271 of file AudacityApp.cpp.

                                   {
   // Bug 718: Position splash screen on same screen 
   // as where Audacity project will appear.
   wxRect wndRect;
   bool bMaximized = false;
   bool bIconized = false;
   GetNextWindowPlacement(&wndRect, &bMaximized, &bIconized);
 
   // BG: Create a temporary window to set as the top window
   wxImage logoimage((const char**)Audacity_splash_xpm);
   logoimage.Scale(logoimage.GetWidth() * (2.0 / 3.0), logoimage.GetHeight() * (2.0 / 3.0), wxIMAGE_QUALITY_HIGH);
   if (GetLayoutDirection() == wxLayout_RightToLeft)
      logoimage = logoimage.Mirror();
   wxBitmap logo(logoimage);
 
   mSplashScreen = std::make_unique<wxSplashScreen>(
      logo,
      wxSPLASH_CENTRE_ON_SCREEN | wxSPLASH_NO_TIMEOUT,
      0,
      nullptr,
      wxID_ANY,
      wndRect.GetTopLeft(),
      wxDefaultSize,
      wxSTAY_ON_TOP);
 
   // If the user interacts with another top level window while the splash screen is visible
   // it gets destroyed automatically, need to hanlde that to prevent the fade out of deleted object
   mSplashScreen->Bind(wxEVT_DESTROY, [this](wxWindowDestroyEvent& event) {
         mSplashScreen.release();
         event.Skip();
      }
   );
 
   // Unfortunately with the Windows 10 Creators update, the splash screen 
   // now appears before setting its position.
   // On a dual monitor screen it will appear on one screen and then 
   // possibly jump to the second.
   // We could fix this by writing our own splash screen and using Hide() 
   // until the splash scren was correctly positioned, then Show()
 
   // Possibly move it on to the second screen...
   mSplashScreen->SetPosition(wndRect.GetTopLeft());
   // Centered on whichever screen it is on.
   mSplashScreen->Center();
   mSplashScreen->SetTitle(_("Audacity is starting up..."));
   SetTopWindow(mSplashScreen.get());
   mSplashScreen->Raise();
}

References _, GetNextWindowPlacement(), mSplashScreen, and wxImage().

Referenced by InitPart2().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

mChecker

std::unique_ptr<wxSingleInstanceChecker> AudacityApp::mChecker

private

Definition at line 120 of file AudacityApp.h.

Referenced by CreateSingleInstanceChecker().

mCmdHandler

std::unique_ptr<CommandHandler> AudacityApp::mCmdHandler

private

Definition at line 118 of file AudacityApp.h.

Referenced by InitCommandHandler(), and OnReceiveCommand().

mIPCServ

std::unique_ptr<IPCServ> AudacityApp::mIPCServ

private

Definition at line 136 of file AudacityApp.h.

Referenced by CreateSingleInstanceChecker().

mSplashScreen

std::unique_ptr<wxSplashScreen> AudacityApp::mSplashScreen

private

Definition at line 124 of file AudacityApp.h.

Referenced by HideSplashScreen(), and ShowSplashScreen().

mSplashTimer

wxTimer AudacityApp::mSplashTimer

private

Definition at line 123 of file AudacityApp.h.

Referenced by HideSplashScreen().

mThemeChangeSubscription

Observer::Subscription AudacityApp::mThemeChangeSubscription

private

Definition at line 116 of file AudacityApp.h.

Referenced by OnInit().

mTimer

wxTimer AudacityApp::mTimer

private

Definition at line 122 of file AudacityApp.h.

Referenced by InitPart2().

---

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

• AudacityApp.h
• AudacityApp.cpp