/**********************************************************************

Audacity: A Digital Audio Editor

AudacityApp.cpp

Dominic Mazzoni

******************************************************************//**

\class AudacityApp

\brief AudacityApp is the 'main' class for Audacity

It handles initialization and termination by subclassing wxApp.

*//*******************************************************************/

#if 0

// This may be used to debug memory leaks.

// See: Visual Leak Dectector @ http://vld.codeplex.com/

#include <vld.h>

#endif

#include "Audacity.h" // This should always be included first

#include "AudacityApp.h"

#include "TranslatableStringArray.h"

#include <wx/defs.h>

#include <wx/app.h>

#include <wx/bitmap.h>

#include <wx/docview.h>

#include <wx/event.h>

#include <wx/ipc.h>

#include <wx/log.h>

#include <wx/window.h>

#include <wx/intl.h>

#include <wx/menu.h>

#include <wx/snglinst.h>

#include <wx/splash.h>

#include <wx/stdpaths.h>

#include <wx/sysopt.h>

#include <wx/fontmap.h>

#include <wx/fs_zip.h>

#include <wx/image.h>

#include <wx/dir.h>

#include <wx/file.h>

#include <wx/filename.h>

#ifdef __WXGTK__

#include <unistd.h>

#endif

// chmod, lstat, geteuid

#ifdef __UNIX__

#include <sys/types.h>

#include <sys/file.h>

#include <sys/stat.h>

#endif

#include "AudacityException.h"

#include "AudacityLogger.h"

#include "AboutDialog.h"

#include "AColor.h"

#include "AudioIO.h"

#include "Benchmark.h"

#include "DirManager.h"

#include "commands/CommandHandler.h"

#include "commands/AppCommandEvent.h"

#include "commands/CommandContext.h"

#include "effects/Contrast.h"

#include "widgets/ASlider.h"

#include "FFmpeg.h"

#include "Internat.h"

#include "LangChoice.h"

#include "Languages.h"

#include "PluginManager.h"

#include "Prefs.h"

#include "Project.h"

#include "Screenshot.h"

#include "Sequence.h"

#include "WaveTrack.h"

#include "prefs/PrefsDialog.h"

#include "Theme.h"

#include "PlatformCompatibility.h"

#include "FileNames.h"

#include "AutoRecovery.h"

#include "SplashDialog.h"

#include "FFT.h"

#include "BlockFile.h"

#include "ondemand/ODManager.h"

#include "commands/Keyboard.h"

#include "widgets/ErrorDialog.h"

#include "prefs/DirectoriesPrefs.h"

#include "tracks/ui/Scrubbing.h"

//temporarilly commented out till it is added to all projects

//#include "Profiler.h"

#include "ModuleManager.h"

#include "import/Import.h"

#include "Experimental.h"

#if defined(EXPERIMENTAL_CRASH_REPORT)

#include <wx/debugrpt.h>

#include <wx/evtloop.h>

#include <wx/textdlg.h>

#endif

#ifdef EXPERIMENTAL_SCOREALIGN

#include "effects/ScoreAlignDialog.h"

#endif

#if 0

#ifdef _DEBUG

#ifdef _MSC_VER

#undef THIS_FILE

static char*THIS_FILE= __FILE__;

#define new new(_NORMAL_BLOCK, THIS_FILE, __LINE__)

#endif

#endif

#endif

// Windows specific linker control...only needed once so

// this is a good place (unless we want to add another file).

#if defined(__WXMSW__)

//#if wxCHECK_VERSION(3, 0, 2) && !wxCHECK_VERSION(3, 1, 0)

#include <wx/init.h>

//#endif

// These lines ensure that Audacity gets WindowsXP themes.

// Without them we get the old-style Windows98/2000 look under XP.

# if !defined(__WXWINCE__)

# pragma comment(linker,"\"/manifestdependency:type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"")

# endif

// These lines allows conditional inclusion of the various libraries

// that Audacity can use.

# if defined(USE_LIBFLAC)

# pragma comment(lib, "libflac++")

# pragma comment(lib, "libflac")

# endif

# if defined(USE_LIBID3TAG)

# pragma comment(lib, "libid3tag")

# endif

# if defined(USE_LIBMAD)

# pragma comment(lib, "libmad")

# endif

# if defined(USE_LIBTWOLAME)

# pragma comment(lib, "twolame")

# endif

# if defined(USE_LIBVORBIS)

# pragma comment(lib, "libogg")

# pragma comment(lib, "libvorbis")

# endif

# if defined(USE_LV2)

# pragma comment(lib, "lv2")

# endif

# if defined(USE_MIDI)

# pragma comment(lib, "portsmf")

# endif

# if defined(EXPERIMENTAL_MIDI_OUT)

# pragma comment(lib, "portmidi")

# endif

# if defined(EXPERIMENTAL_SCOREALIGN)

# pragma comment(lib, "libscorealign")

# endif

# if defined(USE_NYQUIST)

# pragma comment(lib, "libnyquist")

# endif

# if defined(USE_PORTMIXER)

# pragma comment(lib, "portmixer")

# endif

# if defined(USE_SBSMS)

# pragma comment(lib, "sbsms")

# endif

# if defined(USE_SOUNDTOUCH)

# pragma comment(lib, "soundtouch")

# endif

# if defined(USE_VAMP)

# pragma comment(lib, "libvamp")

# endif

# if defined(_DEBUG)

# define D "d"

# else

# define D ""

# endif

# if wxCHECK_VERSION(3, 1, 0)

# define V "31"

# elif wxCHECK_VERSION(3, 0, 0)

# define V "30"

# else

# define V "28"

# endif

# if defined(EXPERIMENTAL_CRASH_REPORT)

# pragma comment(lib, "wxmsw" V "u" D "_qa")

# endif

# pragma comment(lib, "wxbase" V "u" D)

# pragma comment(lib, "wxbase" V "u" D "_net")

# pragma comment(lib, "wxmsw" V "u" D "_adv")

# pragma comment(lib, "wxmsw" V "u" D "_core")

# pragma comment(lib, "wxmsw" V "u" D "_html")

# pragma comment(lib, "wxpng" D)

# pragma comment(lib, "wxzlib" D)

# pragma comment(lib, "wxjpeg" D)

# pragma comment(lib, "wxtiff" D)

# undef V

# undef D

#endif //(__WXMSW__)

// DA: Logo for Splash Screen

#ifdef EXPERIMENTAL_DA

#include "../images/DarkAudacityLogoWithName.xpm"

#else

#include "../images/AudacityLogoWithName.xpm"

#endif

////////////////////////////////////////////////////////////

/// Custom events

////////////////////////////////////////////////////////////

DEFINE_EVENT_TYPE(EVT_OPEN_AUDIO_FILE);

wxDEFINE_EVENT(EVT_LANGUAGE_CHANGE, wxCommandEvent);

#if 0

#ifdef __WXGTK__

static void wxOnAssert(const wxChar *fileName, int lineNumber, const wxChar *msg)

{

if (msg)

wxPrintf("ASSERTION FAILED: %s\n%s: %d\n", (const char *)wxString(msg).mb_str(), (const char *)wxString(fileName).mb_str(), lineNumber);

else

wxPrintf("ASSERTION FAILED!\n%s: %d\n", (const char *)wxString(fileName).mb_str(), lineNumber);

// Force core dump

int *i = 0;

if (*i)

exit(1);

exit(0);

}

#endif

#endif

static bool gInited = false;

bool gIsQuitting = false;

void QuitAudacity(bool bForce)

{

if (gIsQuitting)

return;

gIsQuitting = true;

wxTheApp->SetExitOnFrameDelete(true);

// Try to close each open window. If the user hits Cancel

// in a Save Changes dialog, don't continue.

// BG: unless force is true

// BG: Are there any projects open?

//- if (!gAudacityProjects.IsEmpty())

/*start+*/

if (gAudacityProjects.empty())

{

#ifdef __WXMAC__

AudacityProject::DeleteClipboard();

#endif

}

else

/*end+*/

{

SaveWindowSize();

while (gAudacityProjects.size())

{

// Closing the project has global side-effect

// of deletion from gAudacityProjects

if (bForce)

{

gAudacityProjects[0]->Close(true);

}

else

{

if (!gAudacityProjects[0]->Close())

{

gIsQuitting = false;

return;

}

}

}

}

ModuleManager::Get().Dispatch(AppQuiting);

#ifdef EXPERIMENTAL_SCOREALIGN

CloseScoreAlignDialog();

#endif

CloseScreenshotTools();

//release ODManager Threads

ODManager::Quit();

//print out profile if we have one by deleting it

//temporarilly commented out till it is added to all projects

//DELETE Profiler::Instance();

//remove our logger

std::unique_ptr<wxLog>{ wxLog::SetActiveTarget(NULL) }; // DELETE

if (bForce)

{

wxExit();

}

}

void QuitAudacity()

{

QuitAudacity(false);

}

void SaveWindowSize()

{

if (wxGetApp().GetWindowRectAlreadySaved())

{

return;

}

bool validWindowForSaveWindowSize = FALSE;

AudacityProject * validProject = NULL;

bool foundIconizedProject = FALSE;

size_t numProjects = gAudacityProjects.size();

for (size_t i = 0; i < numProjects; i++)

{

if (!gAudacityProjects[i]->IsIconized()) {

validWindowForSaveWindowSize = TRUE;

validProject = gAudacityProjects[i].get();

i = numProjects;

}

else

foundIconizedProject = TRUE;

}

if (validWindowForSaveWindowSize)

{

wxRect windowRect = validProject->GetRect();

wxRect normalRect = validProject->GetNormalizedWindowState();

bool wndMaximized = validProject->IsMaximized();

gPrefs->Write(wxT("/Window/X"), windowRect.GetX());

gPrefs->Write(wxT("/Window/Y"), windowRect.GetY());

gPrefs->Write(wxT("/Window/Width"), windowRect.GetWidth());

gPrefs->Write(wxT("/Window/Height"), windowRect.GetHeight());

gPrefs->Write(wxT("/Window/Maximized"), wndMaximized);

gPrefs->Write(wxT("/Window/Normal_X"), normalRect.GetX());

gPrefs->Write(wxT("/Window/Normal_Y"), normalRect.GetY());

gPrefs->Write(wxT("/Window/Normal_Width"), normalRect.GetWidth());

gPrefs->Write(wxT("/Window/Normal_Height"), normalRect.GetHeight());

gPrefs->Write(wxT("/Window/Iconized"), FALSE);

}

else

{

if (foundIconizedProject) {

validProject = gAudacityProjects[0].get();

bool wndMaximized = validProject->IsMaximized();

wxRect normalRect = validProject->GetNormalizedWindowState();

// store only the normal rectangle because the itemized rectangle

// makes no sense for an opening project window

gPrefs->Write(wxT("/Window/X"), normalRect.GetX());

gPrefs->Write(wxT("/Window/Y"), normalRect.GetY());

gPrefs->Write(wxT("/Window/Width"), normalRect.GetWidth());

gPrefs->Write(wxT("/Window/Height"), normalRect.GetHeight());

gPrefs->Write(wxT("/Window/Maximized"), wndMaximized);

gPrefs->Write(wxT("/Window/Normal_X"), normalRect.GetX());

gPrefs->Write(wxT("/Window/Normal_Y"), normalRect.GetY());

gPrefs->Write(wxT("/Window/Normal_Width"), normalRect.GetWidth());

gPrefs->Write(wxT("/Window/Normal_Height"), normalRect.GetHeight());

gPrefs->Write(wxT("/Window/Iconized"), TRUE);

}

else {

// this would be a very strange case that might possibly occur on the Mac

// Audacity would have to be running with no projects open

// in this case we are going to write only the default values

wxRect defWndRect;

GetDefaultWindowRect(&defWndRect);

gPrefs->Write(wxT("/Window/X"), defWndRect.GetX());

gPrefs->Write(wxT("/Window/Y"), defWndRect.GetY());

gPrefs->Write(wxT("/Window/Width"), defWndRect.GetWidth());

gPrefs->Write(wxT("/Window/Height"), defWndRect.GetHeight());

gPrefs->Write(wxT("/Window/Maximized"), FALSE);

gPrefs->Write(wxT("/Window/Normal_X"), defWndRect.GetX());

gPrefs->Write(wxT("/Window/Normal_Y"), defWndRect.GetY());

gPrefs->Write(wxT("/Window/Normal_Width"), defWndRect.GetWidth());

gPrefs->Write(wxT("/Window/Normal_Height"), defWndRect.GetHeight());

gPrefs->Write(wxT("/Window/Iconized"), FALSE);

}

}

gPrefs->Flush();

wxGetApp().SetWindowRectAlreadySaved(TRUE);

}

#if defined(__WXGTK__) && defined(HAVE_GTK)

///////////////////////////////////////////////////////////////////////////////

// Provide the ability to receive notification from the session manager

// when the user is logging out or shutting down.

//

// Most of this was taken from nsNativeAppSupportUnix.cpp from Mozilla.

///////////////////////////////////////////////////////////////////////////////

// TODO: May need updating. Is this code too obsolete (relying on Gnome2 so's) to be

// worth keeping anymore?

// CB suggests we use libSM directly ref:

// http://www.x.org/archive/X11R7.7/doc/libSM/SMlib.html#The_Save_Yourself_Callback

#include <dlfcn.h>

/* There is a conflict between the type names used in Glib >= 2.21 and those in

* wxGTK (http://trac.wxwidgets.org/ticket/10883)

* Happily we can avoid the hack, as we only need some of the headers, not

* the full GTK headers

*/

#include <glib-object.h>

typedef struct _GnomeProgram GnomeProgram;

typedef struct _GnomeModuleInfo GnomeModuleInfo;

typedef struct _GnomeClient GnomeClient;

typedef enum

{

GNOME_SAVE_GLOBAL,

GNOME_SAVE_LOCAL,

GNOME_SAVE_BOTH

} GnomeSaveStyle;

typedef enum

{

GNOME_INTERACT_NONE,

GNOME_INTERACT_ERRORS,

GNOME_INTERACT_ANY

} GnomeInteractStyle;

typedef enum

{

GNOME_DIALOG_ERROR,

GNOME_DIALOG_NORMAL

} GnomeDialogType;

typedef GnomeProgram * (*_gnome_program_init_fn)(const char *,

const char *,

const GnomeModuleInfo *,

int,

char **,

const char *,

...);

typedef const GnomeModuleInfo * (*_libgnomeui_module_info_get_fn)();

typedef GnomeClient * (*_gnome_master_client_fn)(void);

typedef void (*GnomeInteractFunction)(GnomeClient *,

gint,

GnomeDialogType,

gpointer);

typedef void (*_gnome_client_request_interaction_fn)(GnomeClient *,

GnomeDialogType,

GnomeInteractFunction,

gpointer);

typedef void (*_gnome_interaction_key_return_fn)(gint, gboolean);

static _gnome_client_request_interaction_fn gnome_client_request_interaction;

static _gnome_interaction_key_return_fn gnome_interaction_key_return;

static void interact_cb(GnomeClient * /* client */,

gint key,

GnomeDialogType /* type */,

gpointer /* data */)

{

wxCloseEvent e(wxEVT_QUERY_END_SESSION, wxID_ANY);

e.SetEventObject(&wxGetApp());

e.SetCanVeto(true);

wxGetApp().ProcessEvent(e);

gnome_interaction_key_return(key, e.GetVeto());

}

static gboolean save_yourself_cb(GnomeClient *client,

gint /* phase */,

GnomeSaveStyle /* style */,

gboolean shutdown,

GnomeInteractStyle interact,

gboolean /* fast */,

gpointer /* user_data */)

{

if (!shutdown || interact != GNOME_INTERACT_ANY) {

return TRUE;

}

if (gAudacityProjects.empty()) {

return TRUE;

}

gnome_client_request_interaction(client,

GNOME_DIALOG_NORMAL,

interact_cb,

NULL);

return TRUE;

}

class GnomeShutdown

{

public:

GnomeShutdown()

{

mArgv[0].reset(strdup("Audacity"));

mGnomeui = dlopen("libgnomeui-2.so.0", RTLD_NOW);

if (!mGnomeui) {

return;

}

mGnome = dlopen("libgnome-2.so.0", RTLD_NOW);

if (!mGnome) {

return;

}

_gnome_program_init_fn gnome_program_init = (_gnome_program_init_fn)

dlsym(mGnome, "gnome_program_init");

_libgnomeui_module_info_get_fn libgnomeui_module_info_get = (_libgnomeui_module_info_get_fn)

dlsym(mGnomeui, "libgnomeui_module_info_get");

_gnome_master_client_fn gnome_master_client = (_gnome_master_client_fn)

dlsym(mGnomeui, "gnome_master_client");

gnome_client_request_interaction = (_gnome_client_request_interaction_fn)

dlsym(mGnomeui, "gnome_client_request_interaction");

gnome_interaction_key_return = (_gnome_interaction_key_return_fn)

dlsym(mGnomeui, "gnome_interaction_key_return");

if (!gnome_program_init || !libgnomeui_module_info_get) {

return;

}

gnome_program_init(mArgv[0].get(),

"1.0",

libgnomeui_module_info_get(),

1,

reinterpret_cast<char**>(mArgv),

NULL);

mClient = gnome_master_client();

if (mClient == NULL) {

return;

}

g_signal_connect(mClient, "save-yourself", G_CALLBACK(save_yourself_cb), NULL);

}

virtual ~GnomeShutdown()

{

// Do not dlclose() the libraries here lest you want segfaults...

}

private:

MallocString<> mArgv[1];

void *mGnomeui;

void *mGnome;

GnomeClient *mClient;

};

// This variable exists to call the constructor and

// connect a signal for the 'save-yourself' message.

GnomeShutdown GnomeShutdownInstance;

#endif

// Where drag/drop or "Open With" filenames get stored until

// the timer routine gets around to picking them up.

static wxArrayString ofqueue;

//

// DDE support for opening multiple files with one instance

// of Audacity.

//

#define IPC_APPL wxT("audacity")

#define IPC_TOPIC wxT("System")

class IPCConn final : public wxConnection

{

public:

IPCConn()

: wxConnection()

{

};

~IPCConn()

{

};

bool OnExec(const wxString & WXUNUSED(topic),

const wxString & data)

{

// Add the filename to the queue. It will be opened by

// the OnTimer() event when it is safe to do so.

ofqueue.Add(data);

return true;

}

};

class IPCServ final : public wxServer

{

public:

IPCServ(const wxString & appl)

: wxServer()

{

Create(appl);

};

~IPCServ()

{

};

wxConnectionBase *OnAcceptConnection(const wxString & topic) override

{

if (topic != IPC_TOPIC) {

return NULL;

}

// Trust wxWidgets framework to DELETE it

return safenew IPCConn();

};

};

#if defined(__WXMAC__)

IMPLEMENT_APP_NO_MAIN(AudacityApp)

IMPLEMENT_WX_THEME_SUPPORT

int main(int argc, char *argv[])

{

wxDISABLE_DEBUG_SUPPORT();

return wxEntry(argc, argv);

}

#elif defined(__WXMSW__) && !wxCHECK_VERSION(3, 1, 0)

// Disable telling Windows that we support HiDPI displays. It is forced on

// in wxWidget versions between 3.0.0 and 3.1.0.

IMPLEMENT_APP_NO_MAIN(AudacityApp)

IMPLEMENT_WX_THEME_SUPPORT

extern "C" int WINAPI WinMain(HINSTANCE hInstance,

HINSTANCE hPrevInstance,

wxCmdLineArgType WXUNUSED(lpCmdLine),

int nCmdShow)

{

wxDISABLE_DEBUG_SUPPORT();

// Disable setting of HiDPI aware mode

wxMSWDisableSettingHighDPIAware();

/* NB: We pass NULL in place of lpCmdLine to behave the same as */

/* Borland-specific wWinMain() above. If it becomes needed */

/* to pass lpCmdLine to wxEntry() here, you'll have to fix */

/* wWinMain() above too. */

return wxEntry(hInstance, hPrevInstance, NULL, nCmdShow);

}

#else

IMPLEMENT_APP(AudacityApp)

#endif

#ifdef __WXMAC__

// in response of an open-document apple event

void AudacityApp::MacOpenFile(const wxString &fileName)

{

ofqueue.Add(fileName);

}

// in response of a print-document apple event

void AudacityApp::MacPrintFile(const wxString &fileName)

{

ofqueue.Add(fileName);

}

// in response of a open-application apple event

void AudacityApp::MacNewFile()

{

if (!gInited)

return;

// This method should only be used on the Mac platform

// when no project windows are open.

if (gAudacityProjects.size() == 0) {

CreateNewAudacityProject();

}

}

#endif //__WXMAC__

#define ID_RECENT_CLEAR 6100

#define ID_RECENT_FIRST 6101

#define ID_RECENT_LAST 6112

// IPC communication

#define ID_IPC_SERVER 6200

#define ID_IPC_SOCKET 6201

// we don't really care about the timer id, but set this value just in case we do in the future

#define kAudacityAppTimerID 0

BEGIN_EVENT_TABLE(AudacityApp, wxApp)

EVT_QUERY_END_SESSION(AudacityApp::OnQueryEndSession)

EVT_END_SESSION(AudacityApp::OnEndSession)

EVT_TIMER(kAudacityAppTimerID, AudacityApp::OnTimer)

#ifdef __WXMAC__

EVT_MENU(wxID_NEW, AudacityApp::OnMenuNew)

EVT_MENU(wxID_OPEN, AudacityApp::OnMenuOpen)

EVT_MENU(wxID_ABOUT, AudacityApp::OnMenuAbout)

EVT_MENU(wxID_PREFERENCES, AudacityApp::OnMenuPreferences)

EVT_MENU(wxID_EXIT, AudacityApp::OnMenuExit)

#endif

#ifndef __WXMSW__

EVT_SOCKET(ID_IPC_SERVER, AudacityApp::OnServerEvent)

EVT_SOCKET(ID_IPC_SOCKET, AudacityApp::OnSocketEvent)

#endif

// Recent file event handlers.

EVT_MENU(ID_RECENT_CLEAR, AudacityApp::OnMRUClear)

EVT_MENU_RANGE(ID_RECENT_FIRST, ID_RECENT_LAST, AudacityApp::OnMRUFile)

// Handle AppCommandEvents (usually from a script)

EVT_APP_COMMAND(wxID_ANY, AudacityApp::OnReceiveCommand)

// Global ESC key handling

EVT_KEY_DOWN(AudacityApp::OnKeyDown)

END_EVENT_TABLE()

// backend for OnMRUFile

// TODO: Would be nice to make this handle not opening a file with more panache.

// - Inform the user if DefaultOpenPath not set.

// - Switch focus to correct instance of project window, if already open.

bool AudacityApp::MRUOpen(const wxString &fullPathStr) {

// Most of the checks below are copied from AudacityProject::OpenFiles.

// - some rationalisation might be possible.

AudacityProject *proj = GetActiveProject();

if (!fullPathStr.IsEmpty())

{

// verify that the file exists

if (wxFile::Exists(fullPathStr))

{

FileNames::UpdateDefaultPath(FileNames::Operation::Open, fullPathStr);

// Make sure it isn't already open.

// Test here even though AudacityProject::OpenFile() also now checks, because

// that method does not return the bad result.

// That itself may be a FIXME.

if (AudacityProject::IsAlreadyOpen(fullPathStr))

return false;

// DMM: If the project is dirty, that means it's been touched at

// all, and it's not safe to open a NEW project directly in its

// place. Only if the project is brand-NEW clean and the user

// hasn't done any action at all is it safe for Open to take place

// inside the current project.

//

// If you try to Open a NEW project inside the current window when

// there are no tracks, but there's an Undo history, etc, then

// bad things can happen, including data files moving to the NEW

// project directory, etc.

if (proj && (proj->GetDirty() || !proj->GetIsEmpty()))

proj = nullptr;

// This project is clean; it's never been touched. Therefore

// all relevant member variables are in their initial state,

// and it's okay to open a NEW project inside this window.

AudacityProject::OpenProject( proj, fullPathStr );

}

else {

// File doesn't exist - remove file from history

AudacityMessageBox(wxString::Format(_("%s could not be found.\n\nIt has been removed from the list of recent files."),

fullPathStr));

return(false);

}

}

return(true);

}

bool AudacityApp::SafeMRUOpen(const wxString &fullPathStr)

{

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

}

void AudacityApp::OnMRUClear(wxCommandEvent& WXUNUSED(event))

{

mRecentFiles->Clear();

}

//vvv Basically, anything from Recent Files is treated as a .aup, until proven otherwise,

// then it tries to Import(). Very questionable handling, imo.

// Better, for example, to check the file type early on.

void AudacityApp::OnMRUFile(wxCommandEvent& event) {

int n = event.GetId() - ID_RECENT_FIRST;

const wxString &fullPathStr = mRecentFiles->GetHistoryFile(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 RemoveFileFromHistory() 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 (!AudacityProject::IsAlreadyOpen(fullPathStr) && !MRUOpen(fullPathStr))

mRecentFiles->RemoveFileFromHistory(n);

}

void AudacityApp::OnTimer(wxTimerEvent& WXUNUSED(event))

{

// 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.GetCount()) {

// Load each file on the queue

while (ofqueue.GetCount()) {

wxString name;

name.swap(ofqueue[0]);

ofqueue.RemoveAt(0);

// Get the user's attention if no file name was specified

if (name.IsEmpty()) {

// Get the users attention

AudacityProject *project = GetActiveProject();

if (project) {

project->Maximize();

project->Raise();

project->RequestUserAttention();

}

continue;

}

// 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)) {

wxFAIL_MSG(wxT("MRUOpen failed"));

}

}

}

}

// Check if a warning for missing aliased files should be displayed

if (ShouldShowMissingAliasedFileWarning()) {

// find which project owns the blockfile

// note: there may be more than 1, but just go with the first one.

//size_t numProjects = gAudacityProjects.size();

AProjectHolder offendingProject;

wxString missingFileName;

{

ODLocker locker { &m_LastMissingBlockFileLock };

offendingProject = m_LastMissingBlockFileProject.lock();

missingFileName = m_LastMissingBlockFilePath;

}

// if there are no projects open, don't show the warning (user has closed it)

if (offendingProject) {

offendingProject->Iconize(false);

offendingProject->Raise();

wxString errorMessage = wxString::Format(_(

"One or more external audio files could not be found.\n\

It is possible they were moved, deleted, or the drive they \

were on was unmounted.\n\

Silence is being substituted for the affected audio.\n\

The first detected missing file is:\n\

%s\n\

There may be additional missing files.\n\

Choose Help > Diagnostics > Check Dependencies to view a list of \

locations of the missing files."), missingFileName);

// if an old dialog exists, raise it if it is

if (offendingProject->GetMissingAliasFileDialog()) {

offendingProject->GetMissingAliasFileDialog()->Raise();

} else {

ShowAliasMissingDialog(offendingProject.get(), _("Files Missing"),

errorMessage, wxT(""), true);

}

}

// Only show this warning once per event (playback/menu item/etc).

SetMissingAliasedFileWarningShouldShow(false);

}

}

void AudacityApp::MarkAliasedFilesMissingWarning(const AliasBlockFile *b)

{

ODLocker locker { &m_LastMissingBlockFileLock };

if (b) {

size_t numProjects = gAudacityProjects.size();

for (size_t ii = 0; ii < numProjects; ++ii) {

// search each project for the blockfile

if (gAudacityProjects[ii]->GetDirManager()->ContainsBlockFile(b)) {

m_LastMissingBlockFileProject = gAudacityProjects[ii];

break;

}

}

}

else

m_LastMissingBlockFileProject = {};

if (b)

m_LastMissingBlockFilePath = b->GetAliasedFileName().GetFullPath();

else

m_LastMissingBlockFilePath = wxString{};

}

void AudacityApp::SetMissingAliasedFileWarningShouldShow(bool b)

{

// Note that this is can be called by both the main thread and other threads.

// I don't believe we need a mutex because we are checking zero vs non-zero,

// and the setting from other threads will always be non-zero (true), and the

// setting from the main thread is always false.

m_aliasMissingWarningShouldShow = b;

// reset the warnings as they were probably marked by a previous run

if (m_aliasMissingWarningShouldShow) {

MarkAliasedFilesMissingWarning( nullptr );

}

}

bool AudacityApp::ShouldShowMissingAliasedFileWarning()

{

ODLocker locker { &m_LastMissingBlockFileLock };

auto ptr = m_LastMissingBlockFileProject.lock();

return ptr && m_aliasMissingWarningShouldShow;

}

AudacityLogger *AudacityApp::GetLogger()

{

// Use dynamic_cast so that we get a NULL ptr if we haven't yet

// setup our logger.

return dynamic_cast<AudacityLogger *>(wxLog::GetActiveTarget());

}

#if defined(__WXMSW__)

#define WL(lang, sublang) (lang), (sublang),

#else

#define WL(lang,sublang)

#endif

#if wxCHECK_VERSION(3, 0, 1)

wxLanguageInfo userLangs[] =

{

// Bosnian is defined in wxWidgets already

// { wxLANGUAGE_USER_DEFINED, wxT("bs"), WL(0, SUBLANG_DEFAULT) wxT("Bosnian"), wxLayout_LeftToRight },

{ wxLANGUAGE_USER_DEFINED, wxT("eu"), WL(0, SUBLANG_DEFAULT) wxT("Basque"), wxLayout_LeftToRight },

};

#endif

wxString AudacityApp::InitLang( const wxString & lang )

{

wxString result = lang;

mLocale.reset();

#if defined(__WXMAC__)

// This should be reviewed again during the wx3 conversion.

// On OSX, if the LANG environment variable isn't set when

// using a language like Japanese, an assertion will trigger

// because conversion to Japanese from "?" doesn't return a