ProjectFileManager Class Reference

#include <ProjectFileManager.h>

Inheritance diagram for ProjectFileManager:

Collaboration diagram for ProjectFileManager:

Classes
struct	ReadProjectResults

Public Types
using	ProjectChooserFn = std::function< AudacityProject &(bool)>
	A function that returns a project to use for opening a file; argument is true if opening a project file. More...

Public Member Functions
	ProjectFileManager (AudacityProject &project)
	ProjectFileManager (const ProjectFileManager &)=delete
ProjectFileManager &	operator= (const ProjectFileManager &)=delete
	~ProjectFileManager ()
bool	OpenProject ()
void	CloseProject ()
bool	OpenNewProject ()
void	CompactProjectOnClose ()
bool	Save ()
bool	SaveAs (bool allowOverwrite=false)
bool	SaveAs (const FilePath &newFileName, bool addToHistory=true)
bool	SaveFromTimerRecording (wxFileName fnFile)
bool	SaveCopy (const FilePath &fileName=wxT(""))
bool	Import (const FilePath &fileName, bool addToHistory=true)
bool	Import (wxArrayString fileNames, bool addToHistory=true)
void	Compact ()
void	AddImportedTracks (const FilePath &fileName, TrackHolders &&newTracks)
bool	GetMenuClose () const
void	SetMenuClose (bool value)
Public Member Functions inherited from ClientData::Base
virtual	~Base ()

Static Public Member Functions
static ProjectFileManager &	Get (AudacityProject &project)
static const ProjectFileManager &	Get (const AudacityProject &project)
static void	DiscardAutosave (const FilePath &filename)
static wxArrayString	ShowOpenDialog (FileNames::Operation op, const FileNames::FileType &extraType={})
	Show an open dialogue for opening audio files, and possibly other sorts of files. More...
static bool	IsAlreadyOpen (const FilePath &projPathName)
static AudacityProject *	OpenFile (const ProjectChooserFn &chooser, const FilePath &fileName, bool addtohistory=true)
static void	FixTracks (TrackList &tracks, const std::function< void(const TranslatableString &)> &onError, const std::function< void(const TranslatableString &)> &onUnlink)
	Attempts to find and fix problems in tracks. More...

Private Member Functions
bool	ImportAndRunTempoDetection (const std::vector< FilePath > &fileNames, bool addToHistory)
bool	DoImport (const FilePath &fileName, bool addToHistory, std::shared_ptr< ClipMirAudioReader > &resultingReader)
AudacityProject *	OpenProjectFile (const FilePath &fileName, bool addtohistory)
ReadProjectResults	ReadProjectFile (const FilePath &fileName, bool discardAutosave=false)
bool	DoSave (const FilePath &fileName, bool fromSaveAs)

Private Attributes
AudacityProject &	mProject
std::shared_ptr< TrackList >	mLastSavedTracks
bool	mMenuClose { false }

Detailed Description

Definition at line 32 of file ProjectFileManager.h.

Member Typedef Documentation

ProjectChooserFn

using ProjectFileManager::ProjectChooserFn = std::function<AudacityProject&(bool)>

A function that returns a project to use for opening a file; argument is true if opening a project file.

Definition at line 86 of file ProjectFileManager.h.

Constructor & Destructor Documentation

ProjectFileManager() [1/2]

ProjectFileManager::ProjectFileManager ( AudacityProject &  project )

explicit

Definition at line 110 of file ProjectFileManager.cpp.

: mProject{ project }
{
}

ProjectFileManager() [2/2]

ProjectFileManager::ProjectFileManager ( const ProjectFileManager &  )

delete

~ProjectFileManager()

ProjectFileManager::~ProjectFileManager ( )

default

Member Function Documentation

AddImportedTracks()

void ProjectFileManager::AddImportedTracks	(	const FilePath &	fileName,
		TrackHolders &&	newTracks
	)

Definition at line 1176 of file ProjectFileManager.cpp.

{
   auto &project = mProject;
   auto &history = ProjectHistory::Get( project );
   auto &projectFileIO = ProjectFileIO::Get( project );
   auto &tracks = TrackList::Get( project );
 
   std::vector<Track*> results;
 
   SelectUtilities::SelectNone( project );
 
   wxFileName fn(fileName);
 
   bool initiallyEmpty = tracks.empty();
   double newRate = 0;
   wxString trackNameBase = fn.GetName();
   int i = -1;
 
   // Fix the bug 2109.
   // In case the project had soloed tracks before importing,
   // all newly imported tracks are muted.
   const bool projectHasSolo =
      !(tracks.Any<PlayableTrack>() + &PlayableTrack::GetSolo).empty();
   if (projectHasSolo) {
      for (auto &group : newTracks)
         if (auto pTrack = dynamic_cast<PlayableTrack*>(group.get()))
            pTrack->SetMute(true);
   }
 
   for (auto &group : newTracks) {
      if (auto pTrack = dynamic_cast<WaveTrack*>(group.get()))
         results.push_back(pTrack);
      tracks.Add(group);
   }
   newTracks.clear();
 
   // Now name them
 
   // Add numbers to track names only if there is more than one (mono or stereo)
   // track (not necessarily, more than one channel)
   const bool useSuffix = results.size() > 1;
 
   for (const auto &newTrack : results) {
      ++i;
      newTrack->SetSelected(true);
      if (useSuffix)
         //i18n-hint Name default name assigned to a clip on track import
         newTrack->SetName(XC("%s %d", "clip name template")
            .Format(trackNameBase, i + 1).Translation());
      else
         newTrack->SetName(trackNameBase);
 
      newTrack->TypeSwitch([&](WaveTrack &wt) {
         if (newRate == 0)
            newRate = wt.GetRate();
         const auto trackName = wt.GetName();
         for (const auto &interval : wt.Intervals())
            interval->SetName(trackName);
      });
   }
 
   history.PushState(XO("Imported '%s'").Format( fileName ),
       XO("Import"));
 
#if defined(__WXGTK__)
   // See bug #1224
   // The track panel hasn't been fully created, so ZoomFitHorizontally() will not give
   // expected results due to a window width of zero.  Should be safe to yield here to
   // allow the creation to complete.  If this becomes a problem, it "might" be possible
   // to queue a dummy event to trigger ZoomFitHorizontally().
   wxEventLoopBase::GetActive()->YieldFor(wxEVT_CATEGORY_UI | wxEVT_CATEGORY_USER_INPUT);
#endif
 
   // If the project was clean and temporary (not permanently saved), then set
   // the filename to the just imported path.
   if (initiallyEmpty && projectFileIO.IsTemporary()) {
      project.SetProjectName(fn.GetName());
      project.SetInitialImportPath(fn.GetPath());
      projectFileIO.SetProjectTitle();
   }
 
   // Moved this call to higher levels to prevent flicker redrawing everything on each file.
   //   HandleResize();
}

References fn, ProjectFileIO::Get(), ProjectHistory::Get(), TrackList::Get(), Track::GetName(), WaveTrack::GetRate(), PlayableTrack::GetSolo(), WaveTrack::Intervals(), mProject, project, SelectUtilities::SelectNone(), tracks, XC, and XO().

Referenced by anonymous_namespace{FileMenus.cpp}::DoImport().

Here is the call graph for this function:

Here is the caller graph for this function:

CloseProject()

void ProjectFileManager::CloseProject

(

)

Definition at line 842 of file ProjectFileManager.cpp.

{
   auto &project = mProject;
   auto &projectFileIO = ProjectFileIO::Get(project);
 
   projectFileIO.CloseProject();
 
   // Blocks were locked in CompactProjectOnClose, so DELETE the data structure so that
   // there's no memory leak.
   if (mLastSavedTracks)
   {
      mLastSavedTracks->Clear();
      mLastSavedTracks.reset();
   }
}

References ProjectFileIO::Get(), mLastSavedTracks, mProject, and project.

Referenced by ApplyMacroDialog::OnApplyToFiles().

Here is the call graph for this function:

Here is the caller graph for this function:

Compact()

void ProjectFileManager::Compact

(

)

Definition at line 1640 of file ProjectFileManager.cpp.

{
   auto &project = mProject;
   auto &undoManager = UndoManager::Get(project);
   auto &clipboard = Clipboard::Get();
   auto &projectFileIO = ProjectFileIO::Get(project);
   bool isBatch = project.mBatchMode > 0;
 
   // Purpose of this is to remove the -wal file.
   projectFileIO.ReopenProject();
 
   auto savedState = undoManager.GetSavedState();
   const auto currentState = undoManager.GetCurrentState();
   if (savedState < 0) {
      undoManager.StateSaved();
      savedState = undoManager.GetSavedState();
      if (savedState < 0) {
         wxASSERT(false);
         savedState = 0;
      }
   }
   const auto least = std::min<size_t>(savedState, currentState);
   const auto greatest = std::max<size_t>(savedState, currentState);
   std::vector<const TrackList*> trackLists;
   auto fn = [&](const UndoStackElem& elem) {
      if (auto pTracks = UndoTracks::Find(elem))
         trackLists.push_back(pTracks);
   };
   undoManager.VisitStates(fn, least, 1 + least);
   if (least != greatest)
      undoManager.VisitStates(fn, greatest, 1 + greatest);
 
   int64_t total = projectFileIO.GetTotalUsage();
   int64_t used = projectFileIO.GetCurrentUsage(trackLists);
 
   auto before = wxFileName::GetSize(projectFileIO.GetFileName());
 
   CompactDialog dlg(
         XO("Compacting this project will free up disk space by removing unused bytes within the file.\n\n"
            "There is %s of free disk space and this project is currently using %s.\n"
            "\n"
            "If you proceed, the current Undo/Redo History and clipboard contents will be discarded "
            "and you will recover approximately %s of disk space.\n"
            "\n"
            "Do you want to continue?")
         .Format(Internat::FormatSize(projectFileIO.GetFreeDiskSpace()),
                  Internat::FormatSize(before.GetValue()),
                  Internat::FormatSize(total - used)));
   if (isBatch || dlg.ShowModal() == wxYES)
   {
      // We can remove redo states, if they are after the saved state.
      undoManager.RemoveStates(1 + greatest, undoManager.GetNumStates());
 
      // We can remove all states between the current and the last saved.
      if (least < greatest)
         undoManager.RemoveStates(least + 1, greatest);
 
      // We can remove all states before the current and the last saved.
      undoManager.RemoveStates(0, least);
 
      // And clear the clipboard, if needed
      if (&mProject == clipboard.Project().lock().get())
         clipboard.Clear();
 
      // Refresh the before space usage since it may have changed due to the
      // above actions.
      auto before = wxFileName::GetSize(projectFileIO.GetFileName());
 
      projectFileIO.Compact(trackLists, true);
 
      auto after = wxFileName::GetSize(projectFileIO.GetFileName());
 
      if (!isBatch)
      {
         AudacityMessageBox(
            XO("Compacting actually freed %s of disk space.")
            .Format(Internat::FormatSize((before - after).GetValue())),
            XO("Compact Project"));
      }
 
      undoManager.RenameState( undoManager.GetCurrentState(),
         XO("Compacted project file"),
         XO("Compact") );
   }
}

References AudacityMessageBox(), UndoTracks::Find(), fn, Internat::FormatSize(), Clipboard::Get(), ProjectFileIO::Get(), UndoManager::Get(), mProject, project, and XO().

Referenced by anonymous_namespace{FileMenus.cpp}::OnCompact().

Here is the call graph for this function:

Here is the caller graph for this function:

CompactProjectOnClose()

void ProjectFileManager::CompactProjectOnClose

(

)

Definition at line 787 of file ProjectFileManager.cpp.

{
   auto &project = mProject;
   auto &projectFileIO = ProjectFileIO::Get(project);
 
   // Lock all blocks in all tracks of the last saved version, so that
   // the sample blocks aren't deleted from the database when we destroy the
   // sample block objects in memory.
   if (mLastSavedTracks)
   {
      for (auto wt : mLastSavedTracks->Any<WaveTrack>())
         WaveTrackUtilities::CloseLock(*wt);
 
      // Attempt to compact the project
      projectFileIO.Compact({ mLastSavedTracks.get() });
 
      if (
         !projectFileIO.WasCompacted() &&
         UndoManager::Get(project).UnsavedChanges())
      {
         // If compaction failed, we must do some work in case of close
         // without save.  Don't leave the document blob from the last
         // push of undo history, when that undo state may get purged
         // with deletion of some new sample blocks.
         // REVIEW: UpdateSaved() might fail too.  Do we need to test
         // for that and report it?
         projectFileIO.UpdateSaved(mLastSavedTracks.get());
      }
   }
}

References WaveTrackUtilities::CloseLock(), ProjectFileIO::Get(), UndoManager::Get(), mLastSavedTracks, mProject, project, and UndoManager::UnsavedChanges().

Here is the call graph for this function:

DiscardAutosave()

void ProjectFileManager::DiscardAutosave ( const FilePath &  filename )

static

Definition at line 92 of file ProjectFileManager.cpp.

{
   InvisibleTemporaryProject tempProject;
   auto &project = tempProject.Project();
   auto &projectFileManager = Get(project);
   // Read the project, discarding autosave
   projectFileManager.ReadProjectFile(filename, true);
 
   if (projectFileManager.mLastSavedTracks) {
      for (auto wt : projectFileManager.mLastSavedTracks->Any<WaveTrack>())
         WaveTrackUtilities::CloseLock(*wt);
      projectFileManager.mLastSavedTracks.reset();
   }
 
   // Side-effect on database is done, and destructor of tempProject
   // closes the temporary project properly
}

References WaveTrackUtilities::CloseLock(), Get(), InvisibleTemporaryProject::Project(), and project.

Referenced by DiscardAllProjects().

Here is the call graph for this function:

Here is the caller graph for this function:

DoImport()

bool ProjectFileManager::DoImport ( const FilePath &  fileName, bool  addToHistory, std::shared_ptr< ClipMirAudioReader > &  resultingReader  )

private

Definition at line 1451 of file ProjectFileManager.cpp.

{
   auto &project = mProject;
   auto &projectFileIO = ProjectFileIO::Get(project);
   auto oldTags = Tags::Get( project ).shared_from_this();
   bool initiallyEmpty = TrackList::Get(project).empty();
   TrackHolders newTracks;
   TranslatableString errorMessage;
 
#ifdef EXPERIMENTAL_IMPORT_AUP3
   // Handle AUP3 ("project") files directly
   if (fileName.AfterLast('.').IsSameAs(wxT("aup3"), false)) {
      if (ImportProject(project, fileName)) {
         auto &history = ProjectHistory::Get(project);
 
         // If the project was clean and temporary (not permanently saved), then set
         // the filename to the just imported path.
         if (initiallyEmpty && projectFileIO.IsTemporary()) {
            wxFileName fn(fileName);
            project.SetProjectName(fn.GetName());
            project.SetInitialImportPath(fn.GetPath());
            projectFileIO.SetProjectTitle();
         }
 
         history.PushState(XO("Imported '%s'").Format(fileName), XO("Import"));
 
         if (addToHistory) {
            FileHistory::Global().Append(fileName);
         }
      }
      else {
         errorMessage = projectFileIO.GetLastError();
         if (errorMessage.empty()) {
            errorMessage = XO("Failed to import project");
         }
 
         // Additional help via a Help button links to the manual.
         ShowErrorDialog( *ProjectFramePlacement(&project),
            XO("Error Importing"),
            errorMessage, wxT("Importing_Audio"));
      }
 
      return false;
   }
#endif
 
   {
      // Backup Tags, before the import.  Be prepared to roll back changes.
      bool committed = false;
      auto cleanup = finally([&]{
         if ( !committed )
            Tags::Set( project, oldTags );
      });
      auto newTags = oldTags->Duplicate();
      Tags::Set( project, newTags );
 
#ifndef EXPERIMENTAL_IMPORT_AUP3
      // Handle AUP3 ("project") files specially
      if (fileName.AfterLast('.').IsSameAs(wxT("aup3"), false)) {
         BasicUI::ShowErrorDialog( *ProjectFramePlacement(&project),
            XO("Error Importing"),
            XO( "Cannot import AUP3 format.  Use File > Open instead"),
            wxT("File_Menu"));
         return false;
      }
#endif
 
      ImportProgress importProgress(project);
      std::optional<LibFileFormats::AcidizerTags> acidTags;
      bool success = Importer::Get().Import(
         project, fileName, &importProgress, &WaveTrackFactory::Get(project),
         newTracks, newTags.get(), acidTags, errorMessage);
      if (!errorMessage.empty()) {
         // Error message derived from Importer::Import
         // Additional help via a Help button links to the manual.
         BasicUI::ShowErrorDialog( *ProjectFramePlacement(&project),
            XO("Error Importing"), errorMessage, wxT("Importing_Audio"));
      }
      if (!success)
         return false;
 
      const auto projectTempo = ProjectTimeSignature::Get(project).GetTempo();
      for (auto track : newTracks)
         DoProjectTempoChange(*track, projectTempo);
 
      if (newTracks.size() == 1)
      {
         const auto waveTrack = dynamic_cast<WaveTrack*>(newTracks[0].get());
         // Also check that the track has a clip, as protection against empty
         // file import.
         if (waveTrack && !waveTrack->GetClipInterfaces().empty())
            resultingReader.reset(new ClipMirAudioReader {
               std::move(acidTags), fileName.ToStdString(),
               *waveTrack });
      }
 
      if (addToHistory) {
         FileHistory::Global().Append(fileName);
      }
 
      // no more errors, commit
      committed = true;
   }
 
   // for LOF ("list of files") files, do not import the file as if it
   // were an audio file itself
   if (fileName.AfterLast('.').IsSameAs(wxT("lof"), false)) {
      // PRL: don't redundantly do the steps below, because we already
      // did it in case of LOF, because of some weird recursion back to this
      // same function.  I think this should be untangled.
 
      // So Undo history push is not bypassed, despite appearances.
      return false;
   }
 
   // Handle AUP ("legacy project") files directly
   if (fileName.AfterLast('.').IsSameAs(wxT("aup"), false)) {
      // If the project was clean and temporary (not permanently saved), then set
      // the filename to the just imported path.
      if (initiallyEmpty && projectFileIO.IsTemporary()) {
         wxFileName fn(fileName);
         project.SetProjectName(fn.GetName());
         project.SetInitialImportPath(fn.GetPath());
         projectFileIO.SetProjectTitle();
      }
 
      auto &history = ProjectHistory::Get( project );
 
      history.PushState(XO("Imported '%s'").Format( fileName ), XO("Import"));
 
      return true;
   }
 
   // PRL: Undo history is incremented inside this:
   AddImportedTracks(fileName, std::move(newTracks));
 
   return true;
}

References FileHistory::Append(), DoProjectTempoChange(), TranslatableString::empty(), TrackList::empty(), fn, Importer::Get(), ProjectTimeSignature::Get(), ProjectFileIO::Get(), ProjectHistory::Get(), Tags::Get(), TrackList::Get(), WaveTrackFactory::Get(), ProjectTimeSignature::GetTempo(), FileHistory::Global(), Importer::Import(), anonymous_namespace{ProjectFileManager.cpp}::ImportProject(), mProject, project, ProjectFramePlacement(), Tags::Set(), BasicUI::ShowErrorDialog(), wxT(), and XO().

Here is the call graph for this function:

DoSave()

bool ProjectFileManager::DoSave ( const FilePath &  fileName, bool  fromSaveAs  )

private

Definition at line 342 of file ProjectFileManager.cpp.

{
   // See explanation above
   // ProjectDisabler disabler(this);
   auto &proj = mProject;
   auto &window = GetProjectFrame( proj );
   auto &projectFileIO = ProjectFileIO::Get( proj );
   const auto &settings = ProjectSettings::Get( proj );
 
   // Some confirmation dialogs
   {
      if (TempDirectory::FATFilesystemDenied(fileName, XO("Projects cannot be saved to FAT drives.")))
      {
         return false;
      }
 
      wxULongLong fileSize = wxFileName::GetSize(projectFileIO.GetFileName());
 
      wxDiskspaceSize_t freeSpace;
      if (wxGetDiskSpace(FileNames::AbbreviatePath(fileName), NULL, &freeSpace))
      {
         if (freeSpace.GetValue() <= fileSize.GetValue())
         {
            BasicUI::ShowErrorDialog( *ProjectFramePlacement( &proj ),
               XO("Insufficient Disk Space"),
               XO("The project size exceeds the available free space on the target disk.\n\n"
                  "Please select a different disk with more free space."),
               "Error:_Disk_full_or_not_writable"
               );
 
            return false;
         }
      }
   }
   // End of confirmations
 
   // Always save a backup of the original project file
   std::optional<ProjectFileIO::BackupProject> pBackupProject;
   if (fromSaveAs && wxFileExists(fileName))
   {
      pBackupProject.emplace(projectFileIO, fileName);
      if (!pBackupProject->IsOk())
         return false;
   }
 
   if (FileNames::IsOnFATFileSystem(fileName))
   {
      if (wxFileName::GetSize(projectFileIO.GetFileName()) > UINT32_MAX)
      {
         BasicUI::ShowErrorDialog( *ProjectFramePlacement( &proj ),
            XO("Error Saving Project"),
            XO("The project exceeds the maximum size of 4GB when writing to a FAT32 formatted filesystem."),
            "Error:_Unsuitable_drive"
            );
         return false;
      }
   }
 
   bool success = projectFileIO.SaveProject(fileName, mLastSavedTracks.get());
   if (!success)
   {
      // Show this error only if we didn't fail reconnection in SaveProject
      // REVIEW: Could HasConnection() be true but SaveProject() still have failed?
      if (!projectFileIO.HasConnection()) {
         using namespace BasicUI;
         ShowErrorDialog( *ProjectFramePlacement( &proj ),
            XO("Error Saving Project"),
            FileException::WriteFailureMessage(fileName),
            "Error:_Disk_full_or_not_writable",
            ErrorDialogOptions{ ErrorDialogType::ModalErrorReport } );
      }
      return false;
   }
 
   proj.SetProjectName(wxFileName(fileName).GetName());
   projectFileIO.SetProjectTitle();
 
   UndoManager::Get(proj).StateSaved();
   ProjectStatus::Get(proj).Set(XO("Saved %s").Format(fileName));
 
   if (mLastSavedTracks)
   {
      mLastSavedTracks->Clear();
   }
   mLastSavedTracks = TrackList::Create(nullptr);
 
   auto &tracks = TrackList::Get(proj);
   for (auto t : tracks)
      mLastSavedTracks->Add(t->Duplicate(Track::DuplicateOptions{}.Backup()));
 
   // If we get here, saving the project was successful, so we can DELETE
   // any backup project.
   if (pBackupProject)
      pBackupProject->Discard();
 
   return true;
}

References FileNames::AbbreviatePath(), Track::DuplicateOptions::Backup(), TrackList::Create(), TempDirectory::FATFilesystemDenied(), ProjectFileIO::Get(), UndoManager::Get(), ProjectStatus::Get(), TrackList::Get(), ProjectSettings::Get(), GetProjectFrame(), FileNames::IsOnFATFileSystem(), mLastSavedTracks, mProject, ProjectFramePlacement(), ProjectStatus::Set(), settings(), BasicUI::ShowErrorDialog(), UndoManager::StateSaved(), tracks, FileException::WriteFailureMessage(), and XO().

Referenced by Save(), SaveAs(), and SaveFromTimerRecording().

Here is the call graph for this function:

Here is the caller graph for this function:

FixTracks()

void ProjectFileManager::FixTracks ( TrackList &  tracks, const std::function< void(const TranslatableString &)> &  onError, const std::function< void(const TranslatableString &)> &  onUnlink  )

static

Attempts to find and fix problems in tracks.

Parameters

tracks	A list of tracks to be fixed
onError	Called each time unrepairable error has been found.
onUnlink	Called when tracks unlinked due to link inconsistency.

Definition at line 1035 of file ProjectFileManager.cpp.

{
   // This is successively assigned the left member of each pair that
   // becomes unlinked
   Track::Holder unlinkedTrack;
   // Beware iterator invalidation, because stereo channels get zipped,
   // replacing WaveTracks
   for (auto iter = tracks.begin(); iter != tracks.end();) {
      auto t = (*iter++)->SharedPointer();
      const auto linkType = t->GetLinkType();
      // Note, the next function may have an important upgrading side effect,
      // and return no error; or it may find a real error and repair it, but
      // that repaired track won't be used because opening will fail.
      if (!t->LinkConsistencyFix()) {
         onError(XO("A channel of a stereo track was missing."));
         unlinkedTrack = nullptr;
      }
      if (!unlinkedTrack) {
         if (linkType != ChannelGroup::LinkType::None &&
            t->NChannels() == 1) {
            // The track became unlinked.
            // It should NOT have been replaced with a "zip"
            assert(t->GetOwner().get() == &tracks);
            // Wait until LinkConsistencyFix is called on the second track
            unlinkedTrack = t;
            // Fix the iterator, which skipped the right channel before the
            // unlinking
            iter = tracks.Find(t.get());
            ++iter;
         }
      }
      else {
         //Not an elegant way to deal with stereo wave track linking
         //compatibility between versions
         if (const auto left = dynamic_cast<WaveTrack*>(unlinkedTrack.get())) {
            if (const auto right = dynamic_cast<WaveTrack*>(t.get())) {
               // As with the left, it should not have vanished from the list
               assert(right->GetOwner().get() == &tracks);
               left->SetPan(-1.0f);
               right->SetPan(1.0f);
               RealtimeEffectList::Get(*left).Clear();
               RealtimeEffectList::Get(*right).Clear();
 
               if(left->GetRate() != right->GetRate())
                  //i18n-hint: explains why opened project was auto-modified
                  onUnlink(XO("This project contained stereo tracks with different sample rates per channel."));
               if(left->GetSampleFormat() != right->GetSampleFormat())
                  //i18n-hint: explains why opened project was auto-modified
                  onUnlink(XO("This project contained stereo tracks with different sample formats in channels."));
               //i18n-hint: explains why opened project was auto-modified
               onUnlink(XO("This project contained stereo tracks with non-aligned content."));
            }
         }
         unlinkedTrack = nullptr;
      }
 
      if (const auto message = t->GetErrorOpening()) {
         wxLogWarning(
            wxT("Track %s had error reading clip values from project file."),
            t->GetName());
         onError(*message);
      }
   }
}

References RealtimeEffectList::Clear(), RealtimeEffectList::Get(), ChannelGroup::None, tracks, wxT(), and XO().

Referenced by AUPImportFileHandle::Import().

Here is the call graph for this function:

Here is the caller graph for this function:

Get() [1/2]

ProjectFileManager & ProjectFileManager::Get ( AudacityProject &  project )

static

Definition at line 82 of file ProjectFileManager.cpp.

{
   return project.AttachedObjects::Get< ProjectFileManager >( sFileManagerKey );
}

References project, and sFileManagerKey.

Referenced by ImportCommand::Apply(), SaveProjectCommand::Apply(), SaveCopyCommand::Apply(), DiscardAutosave(), anonymous_namespace{FileMenus.cpp}::DoImport(), TimerRecordDialog::ExecutePostRecordActions(), Get(), AUPImportFileHandle::HandleImport(), AUPImportFileHandle::HandleProject(), Import(), ProjectManager::New(), ApplyMacroDialog::OnApplyToFiles(), anonymous_namespace{FileMenus.cpp}::OnClose(), ProjectManager::OnCloseWindow(), anonymous_namespace{FileMenus.cpp}::OnCompact(), anonymous_namespace{EditMenus.cpp}::OnPaste(), anonymous_namespace{FileMenus.cpp}::OnSave(), anonymous_namespace{FileMenus.cpp}::OnSaveAs(), anonymous_namespace{FileMenus.cpp}::OnSaveCopy(), OpenFile(), audacity::cloud::audiocom::sync::ResaveLocally(), ProjectManager::ResetProjectToEmpty(), and audacity::cloud::audiocom::sync::SaveToCloud().

Here is the caller graph for this function:

Get() [2/2]

const ProjectFileManager & ProjectFileManager::Get ( const AudacityProject &  project )

static

Definition at line 87 of file ProjectFileManager.cpp.

{
   return Get( const_cast< AudacityProject & >( project ) );
}

References Get(), and project.

Here is the call graph for this function:

GetMenuClose()

bool ProjectFileManager::GetMenuClose ( ) const

inline

Definition at line 106 of file ProjectFileManager.h.

{ return mMenuClose; }

Import() [1/2]

bool ProjectFileManager::Import	(	const FilePath &	fileName,
		bool	addToHistory = true
	)

Definition at line 1346 of file ProjectFileManager.cpp.

{
   wxArrayString fileNames;
   fileNames.Add(fileName);
   return Import(std::move(fileNames), addToHistory);
}

References Import().

Referenced by ImportCommand::Apply(), anonymous_namespace{FileMenus.cpp}::DoImport(), AUPImportFileHandle::HandleImport(), Import(), ApplyMacroDialog::OnApplyToFiles(), anonymous_namespace{EditMenus.cpp}::OnPaste(), and OpenFile().

Here is the call graph for this function:

Here is the caller graph for this function:

Import() [2/2]

bool ProjectFileManager::Import	(	wxArrayString	fileNames,
		bool	addToHistory = true
	)

Definition at line 1353 of file ProjectFileManager.cpp.

{
   fileNames.Sort(FileNames::CompareNoCase);
   if (!ProjectFileManager::Get(mProject).ImportAndRunTempoDetection(
          std::vector<wxString> { fileNames.begin(), fileNames.end() },
          addToHistory))
      return false;
   // Last track in the project is the one that was just added. Use it for
   // focus, etc.
   Track* lastTrack = nullptr;
   const auto range = TrackList::Get(mProject).Any<Track>();
   assert(!range.empty());
   if(range.empty())
      return false;
   lastTrack = *(range.rbegin());
   BasicUI::CallAfter([wTrack = lastTrack->weak_from_this(), wProject = mProject.weak_from_this()] {
      const auto project = wProject.lock();
      const auto track = wTrack.lock();
      if (!project || !track)
         return;
      auto& viewPort = Viewport::Get(*project);
      TrackFocus::Get(*project).Set(track.get(), true);
      viewPort.ZoomFitHorizontally();
      viewPort.ShowTrack(*track);
      viewPort.HandleResize(); // Adjust scrollers for NEW track sizes.
   });
   return true;
}

References TrackList::Any(), BasicUI::CallAfter(), FileNames::CompareNoCase(), TrackList::Get(), Get(), ImportAndRunTempoDetection(), and mProject.

Here is the call graph for this function:

ImportAndRunTempoDetection()

bool ProjectFileManager::ImportAndRunTempoDetection ( const std::vector< FilePath > &  fileNames, bool  addToHistory  )

private

Definition at line 1420 of file ProjectFileManager.cpp.

{
   const auto projectWasEmpty =
      TrackList::Get(mProject).Any<WaveTrack>().empty();
   std::vector<std::shared_ptr<ClipMirAudioReader>> resultingReaders;
   const auto success = std::all_of(
      fileNames.begin(), fileNames.end(), [&](const FilePath& fileName) {
         std::shared_ptr<ClipMirAudioReader> resultingReader;
         const auto success = DoImport(fileName, addToHistory, resultingReader);
         if (success && resultingReader)
            resultingReaders.push_back(std::move(resultingReader));
         return success;
      });
   // At the moment, one failing import doesn't revert the project state, hence
   // we still run the analysis on what was successfully imported.
   // TODO implement reverting of the project state on failure.
   if (!resultingReaders.empty())
   {
      const auto pProj = mProject.shared_from_this();
      BasicUI::CallAfter([=] {
         AudacityMirProject mirInterface { *pProj };
         const auto analyzedClips =
            RunTempoDetection(resultingReaders, mirInterface, projectWasEmpty);
         MIR::SynchronizeProject(analyzedClips, mirInterface, projectWasEmpty);
      });
   }
   return success;
}

References TrackList::Any(), BasicUI::CallAfter(), TrackList::Get(), mProject, anonymous_namespace{ProjectFileManager.cpp}::RunTempoDetection(), and MIR::SynchronizeProject().

Referenced by Import().

Here is the call graph for this function:

Here is the caller graph for this function:

IsAlreadyOpen()

bool ProjectFileManager::IsAlreadyOpen ( const FilePath &  projPathName )

static

Definition at line 901 of file ProjectFileManager.cpp.

{
   const wxFileName newProjPathName(projPathName);
   auto start = AllProjects{}.begin(), finish = AllProjects{}.end(),
   iter = std::find_if( start, finish,
      [&]( const AllProjects::value_type &ptr ){
         return newProjPathName.SameAs(wxFileNameWrapper{ ProjectFileIO::Get(*ptr).GetFileName() });
      } );
   if (iter != finish) {
      auto errMsg =
      XO("%s is already open in another window.")
         .Format( newProjPathName.GetName() );
      wxLogError(errMsg.Translation()); //Debug?
      AudacityMessageBox(
         errMsg,
         XO("Error Opening Project"),
         wxOK | wxCENTRE);
      return true;
   }
   return false;
}

References AudacityMessageBox(), AllProjects::begin(), AllProjects::end(), ProjectFileIO::Get(), ProjectFileIO::GetFileName(), and XO().

Referenced by EVT_MENU_RANGE(), AudacityApp::OnMRUFile(), OpenFile(), and ProjectManager::OpenFiles().

Here is the call graph for this function:

Here is the caller graph for this function:

OpenFile()

AudacityProject * ProjectFileManager::OpenFile ( const ProjectChooserFn &  chooser, const FilePath &  fileName, bool  addtohistory = true  )

static

Opens files of many kinds. In case of import (sound, MIDI, or .aup), the undo history is pushed.

Parameters

chooser	told whether opening a project file; decides which project to open into
fileName	the name and contents are examined to decide a type and open appropriately
addtohistory	whether to add .aup3 files to the MRU list (but always done for imports)

Returns

if something was successfully opened, the project containing it; else null

Definition at line 923 of file ProjectFileManager.cpp.

{
   // On Win32, we may be given a short (DOS-compatible) file name on rare
   // occasions (e.g. stuff like "C:\PROGRA~1\AUDACI~1\PROJEC~1.AUP"). We
   // convert these to long file name first.
   auto fileName = PlatformCompatibility::GetLongFileName(fileNameArg);
 
   // Make sure it isn't already open.
   // Vaughan, 2011-03-25: This was done previously in AudacityProject::OpenFiles()
   //    and AudacityApp::MRUOpen(), but if you open an aup file by double-clicking it
   //    from, e.g., Win Explorer, it would bypass those, get to here with no check,
   //    then open a NEW project from the same data with no warning.
   //    This was reported in http://bugzilla.audacityteam.org/show_bug.cgi?id=137#c17,
   //    but is not really part of that bug. Anyway, prevent it!
   if (IsAlreadyOpen(fileName))
      return nullptr;
 
   // Data loss may occur if users mistakenly try to open ".aup3.bak" files
   // left over from an unsuccessful save or by previous versions of Audacity.
   // So we always refuse to open such files.
   if (fileName.Lower().EndsWith(wxT(".aup3.bak")))
   {
      AudacityMessageBox(
         XO(
"You are trying to open an automatically created backup file.\nDoing this may result in severe data loss.\n\nPlease open the actual Audacity project file instead."),
         XO("Warning - Backup File Detected"),
         wxOK | wxCENTRE,
         nullptr);
      return nullptr;
   }
 
   if (!::wxFileExists(fileName)) {
      AudacityMessageBox(
         XO("Could not open file: %s").Format( fileName ),
         XO("Error Opening File"),
         wxOK | wxCENTRE,
         nullptr);
      return nullptr;
   }
 
   // Following block covers cases other than a project file:
   {
      wxFFile ff(fileName, wxT("rb"));
 
      auto cleanup = finally([&]
      {
         if (ff.IsOpened())
         {
            ff.Close();
         }
      });
 
      if (!ff.IsOpened()) {
         AudacityMessageBox(
            XO("Could not open file: %s").Format( fileName ),
            XO("Error opening file"),
            wxOK | wxCENTRE,
            nullptr);
         return nullptr;
      }
 
      char buf[7];
      auto numRead = ff.Read(buf, 6);
      if (numRead != 6) {
         AudacityMessageBox(
            XO("File may be invalid or corrupted: \n%s").Format( fileName ),
            XO("Error Opening File or Project"),
            wxOK | wxCENTRE,
            nullptr);
         return nullptr;
      }
 
      if (wxStrncmp(buf, "SQLite", 6) != 0)
      {
         // Not a database
#ifdef EXPERIMENTAL_DRAG_DROP_PLUG_INS
         // Is it a plug-in?
         if (PluginManager::Get().DropFile(fileName)) {
            MenuCreator::RebuildAllMenuBars();
            // Plug-in installation happened, not really opening of a file,
            // so return null
            return nullptr;
         }
#endif
         auto &project = chooser(false);
         // Undo history is incremented inside this:
         if (Get(project).Import(fileName))
         {
            // Undo history is incremented inside this:
            // Bug 2743: Don't zoom with lof.
            if (!fileName.AfterLast('.').IsSameAs(wxT("lof"), false))
               Viewport::Get(project).ZoomFitHorizontallyAndShowTrack(nullptr);
            return &project;
         }
         return nullptr;
      }
   }
 
   // Disallow opening of .aup3 project files from FAT drives, but only such
   // files, not importable types.  (Bug 2800)
   if (TempDirectory::FATFilesystemDenied(fileName,
      XO("Project resides on FAT formatted drive.\n"
        "Copy it to another drive to open it.")))
   {
      return nullptr;
   }
 
   auto &project = chooser(true);
   return Get(project).OpenProjectFile(fileName, addtohistory);
}

References AudacityMessageBox(), TempDirectory::FATFilesystemDenied(), PluginManager::Get(), Viewport::Get(), Get(), PlatformCompatibility::GetLongFileName(), Import(), IsAlreadyOpen(), OpenProjectFile(), project, MenuCreator::RebuildAllMenuBars(), wxT(), XO(), and Viewport::ZoomFitHorizontallyAndShowTrack().

Referenced by OpenProjectCommand::Apply(), and ProjectManager::OpenProject().

Here is the call graph for this function:

Here is the caller graph for this function:

OpenNewProject()

bool ProjectFileManager::OpenNewProject

(

)

Definition at line 826 of file ProjectFileManager.cpp.

{
   auto &project = mProject;
   auto &projectFileIO = ProjectFileIO::Get(project);
 
   bool bOK = OpenProject();
   if( !bOK )
   {
       auto tmpdir = wxFileName(TempDirectory::UnsavedProjectFileName()).GetPath();
 
       UnwritableLocationErrorDialog dlg(nullptr, tmpdir);
       dlg.ShowModal();
   }
   return bOK;
}

References ProjectFileIO::Get(), mProject, OpenProject(), project, and TempDirectory::UnsavedProjectFileName().

Here is the call graph for this function:

OpenProject()

bool ProjectFileManager::OpenProject

(

)

Definition at line 818 of file ProjectFileManager.cpp.

{
   auto &project = mProject;
   auto &projectFileIO = ProjectFileIO::Get(project);
 
   return projectFileIO.OpenProject();
}

References ProjectFileIO::Get(), mProject, and project.

Referenced by ApplyMacroDialog::OnApplyToFiles(), and OpenNewProject().

Here is the call graph for this function:

Here is the caller graph for this function:

OpenProjectFile()

AudacityProject * ProjectFileManager::OpenProjectFile ( const FilePath &  fileName, bool  addtohistory  )

private

Parameters

fileName	a path assumed to exist and contain an .aup3 project
addtohistory	whether to add the file to the MRU list

Returns

if something was successfully opened, the project containing it; else null

Definition at line 1102 of file ProjectFileManager.cpp.

{
   // Allow extensions to update the project before opening it.
   if (ProjectFileIOExtensionRegistry::OnOpen(
          mProject, audacity::ToUTF8(fileName)) == OnOpenAction::Cancel)
      return nullptr;
 
   auto &project = mProject;
   auto &history = ProjectHistory::Get( project );
   auto &tracks = TrackList::Get( project );
   auto &trackPanel = TrackPanel::Get( project );
   auto &projectFileIO = ProjectFileIO::Get( project );
   auto &viewport = Viewport::Get( project );
 
   auto results = ReadProjectFile( fileName );
   const bool bParseSuccess = results.parseSuccess;
   const auto &errorStr = results.errorString;
   const bool err = results.trackError;
 
   if (bParseSuccess && !err) {
      Viewport::Get(project).ReinitScrollbars();
 
      ProjectHistory::Get( project ).InitialState();
      TrackFocus::Get(project).Set(*tracks.begin());
      viewport.HandleResize();
      trackPanel.Refresh(false);
 
      // ? Old rationale in this comment no longer applies in 3.0.0, with no
      // more on-demand loading:
      trackPanel.Update(); // force any repaint to happen now,
      // else any asynch calls into the blockfile code will not have
      // finished logging errors (if any) before the call to ProjectFSCK()
 
      if (addtohistory)
         FileHistory::Global().Append(fileName);
   }
 
   if (bParseSuccess && !err) {
      if (projectFileIO.IsRecovered())
      {
         // PushState calls AutoSave(), so no longer need to do so here.
         history.PushState(XO("Project was recovered"), XO("Recover"));
      }
      return &project;
   }
   else {
      // Vaughan, 2011-10-30:
      // See first topic at http://bugzilla.audacityteam.org/show_bug.cgi?id=451#c16.
      // Calling mTracks->Clear() with deleteTracks true results in data loss.
 
      // PRL 2014-12-19:
      // I made many changes for wave track memory management, but only now
      // read the above comment.  I may have invalidated the fix above (which
      // may have spared the files at the expense of leaked memory).  But
      // here is a better way to accomplish the intent, doing like what happens
      // when the project closes:
      for (auto pTrack : tracks.Any<WaveTrack>())
         WaveTrackUtilities::CloseLock(*pTrack);
 
      tracks.Clear(); //tracks.Clear(true);
 
      wxLogError(wxT("Could not parse file \"%s\". \nError: %s"), fileName, errorStr.Debug());
 
      projectFileIO.ShowError( *ProjectFramePlacement(&project),
         XO("Error Opening Project"),
         errorStr,
         results.helpUrl);
 
      return nullptr;
   }
}

References FileHistory::Append(), Cancel, WaveTrackUtilities::CloseLock(), TrackFocus::Get(), ProjectFileIO::Get(), ProjectHistory::Get(), TrackList::Get(), Viewport::Get(), TrackPanel::Get(), FileHistory::Global(), ProjectHistory::InitialState(), mProject, ProjectFileIOExtensionRegistry::OnOpen(), project, ProjectFramePlacement(), ReadProjectFile(), Viewport::ReinitScrollbars(), audacity::ToUTF8(), tracks, wxT(), and XO().

Referenced by OpenFile().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

ProjectFileManager & ProjectFileManager::operator= ( const ProjectFileManager &  )

delete

ReadProjectFile()

auto ProjectFileManager::ReadProjectFile ( const FilePath &  fileName, bool  discardAutosave = false  )

private

Parse project file

Definition at line 165 of file ProjectFileManager.cpp.

{
   auto &project = mProject;
   auto &projectFileIO = ProjectFileIO::Get( project );
   auto &window = GetProjectFrame( project );
 
   auto parseResult = projectFileIO.LoadProject(fileName, discardAutosave);
   const bool bParseSuccess = parseResult.has_value();
 
   bool err = false;
   std::optional<TranslatableString> linkTypeChangeReason;
 
   TranslatableString otherError;
 
   if (bParseSuccess)
   {
      auto& tracks = TrackList::Get(project);
      // By making a duplicate set of pointers to the existing blocks
      // on disk, we add one to their reference count, guaranteeing
      // that their reference counts will never reach zero and thus
      // the version saved on disk will be preserved until the
      // user selects Save().
      // Do this before FixTracks might delete zero-length clips!
      mLastSavedTracks = TrackList::Create( nullptr );
      WaveTrack *leader{};
      tracks.Any().Visit(
         [&](WaveTrack& track) {
            // A rare place where TrackList::Channels remains necessary, to
            // visit the right channels of stereo tracks not yet "zipped",
            // otherwise later, CloseLock() will be missed for some sample
            // blocks and corrupt the project
            for (const auto pChannel : TrackList::Channels(&track))
            {
               auto left = leader;
               auto newTrack =
                  pChannel->Duplicate(Track::DuplicateOptions {}.Backup());
               leader = left ? nullptr // now visiting the right channel
                        :
                        (pChannel->GetLinkType() == Track::LinkType::None) ?
                               nullptr // now visiting a mono channel
                               :
                               static_cast<WaveTrack*>(newTrack.get())
                  // now visiting a left channel
                  ;
               mLastSavedTracks->Add(newTrack);
               if (left)
                  // Zip clips allowing misalignment -- this may be a legacy
                  // project.  This duplicate track will NOT be used for normal
                  // editing, but only later to visit all the sample blocks that
                  // existed at last save time.
                  left->ZipClips(false);
            }
         },
         [this](Track& track) {
            mLastSavedTracks->Add(
               track.Duplicate(Track::DuplicateOptions {}.Backup()));
         });
 
      FixTracks(
         tracks,
         // Keep at most one of the error messages
         [&](const auto& errorMessage) { otherError = errorMessage; err = true; },
         [&](const auto& unlinkReason) { linkTypeChangeReason = unlinkReason; });
 
      if (!err) {
         if(linkTypeChangeReason && !discardAutosave)
         {
            BasicUI::ShowMessageBox(XO(
//i18n-hint: Text of the message dialog that may appear on attempt
//to open a project created by Audacity version prior to 3.4.
//%s will be replaced with an explanation of the actual reason of
//project modification.
"%s\n"
"This feature is not supported in Audacity versions past 3.3.3.\n"
"These stereo tracks have been split into mono tracks.\n"
"As a result, some realtime effects may be missing.\n"
"Please verify that everything works as intended before saving."
            ).Format(linkTypeChangeReason->Translation()));
         }
 
         parseResult->Commit();
         if (discardAutosave)
            // REVIEW: Failure OK?
            projectFileIO.AutoSaveDelete();
         else if (projectFileIO.IsRecovered()) {
            bool resaved = false;
 
            if (!projectFileIO.IsTemporary() &&
               !linkTypeChangeReason)
            {
               // Re-save non-temporary project to its own path.  This
               // might fail to update the document blob in the database.
               resaved = projectFileIO.SaveProject(fileName, nullptr);
            }
 
            AudacityMessageBox(
               resaved
                  ? XO(
"This project was not saved properly the last time Audacity ran.\n\n"
"It has been recovered to the last snapshot.")
                  : XO(
"This project was not saved properly the last time Audacity ran.\n\n"
"It has been recovered to the last snapshot, but you must save it\n"
"to preserve its contents."),
               XO("Project Recovered"),
               wxICON_WARNING,
               &window);
         }
      }
 
      ProjectFileIOExtensionRegistry::OnLoad(mProject);
   }
 
   return {
      bParseSuccess,
      err,
      (bParseSuccess ? otherError : projectFileIO.GetLastError()),
      FindHelpUrl(projectFileIO.GetLibraryError())
   };
}

References AudacityMessageBox(), Track::DuplicateOptions::Backup(), TrackList::Channels(), TrackList::Create(), Track::Duplicate(), ProjectFileIO::Get(), TrackList::Get(), GetProjectFrame(), ChannelGroup::None, ProjectFileIOExtensionRegistry::OnLoad(), project, BasicUI::ShowMessageBox(), tracks, XO(), and WaveTrack::ZipClips().

Referenced by OpenProjectFile().

Here is the call graph for this function:

Here is the caller graph for this function:

Save()

bool ProjectFileManager::Save

(

)

Definition at line 291 of file ProjectFileManager.cpp.

{
   auto &projectFileIO = ProjectFileIO::Get(mProject);
 
   if (auto action = ProjectFileIOExtensionRegistry::OnSave(
          mProject, [this](auto& path, bool rename)
          { return DoSave(audacity::ToWXString(path), rename); });
      action != OnSaveAction::Continue)
      return action == OnSaveAction::Handled;
 
   // Prompt for file name?
   if (projectFileIO.IsTemporary())
   {
      return SaveAs(true);
   }
 
   return DoSave(projectFileIO.GetFileName(), false);
}

References Continue, DoSave(), ProjectFileIO::Get(), Handled, mProject, ProjectFileIOExtensionRegistry::OnSave(), SaveAs(), and audacity::ToWXString().

Referenced by audacity::cloud::audiocom::sync::SaveToCloud().

Here is the call graph for this function:

Here is the caller graph for this function:

SaveAs() [1/2]

bool ProjectFileManager::SaveAs

(

bool

allowOverwrite = false

)

Definition at line 471 of file ProjectFileManager.cpp.

{
   auto &project = mProject;
   auto &projectFileIO = ProjectFileIO::Get( project );
   auto &window = GetProjectFrame( project );
   TitleRestorer Restorer( window, project ); // RAII
   wxFileName filename;
   FilePath defaultSavePath = FileNames::FindDefaultPath(FileNames::Operation::Save);
 
   if (projectFileIO.IsTemporary()) {
      filename.SetPath(defaultSavePath);
      filename.SetName(project.GetProjectName());
   }
   else {
      filename = projectFileIO.GetFileName();
   }
 
   // Bug 1304: Set a default file path if none was given.  For Save/SaveAs/SaveCopy
   if( !FileNames::IsPathAvailable( filename.GetPath( wxPATH_GET_VOLUME| wxPATH_GET_SEPARATOR) ) ){
      filename.SetPath(defaultSavePath);
   }
 
   TranslatableString title = XO("%sSave Project \"%s\" As...")
      .Format( Restorer.sProjNumber, Restorer.sProjName );
 
   bool bPrompt = (project.mBatchMode == 0) || (projectFileIO.GetFileName().empty());
   FilePath fName;
   bool bOwnsNewName;
 
   do {
      if (bPrompt) {
         // JKC: I removed 'wxFD_OVERWRITE_PROMPT' because we are checking
         // for overwrite ourselves later, and we disallow it.
         fName = SelectFile(FileNames::Operation::Save,
            title,
            filename.GetPath(),
            filename.GetFullName(),
            wxT("aup3"),
            { FileNames::AudacityProjects },
            wxFD_SAVE | wxRESIZE_BORDER,
            &window);
 
         if (fName.empty())
            return false;
 
         filename = fName;
      };
 
      filename.SetExt(wxT("aup3"));
 
      if ((!bPrompt || !allowOverwrite) && filename.FileExists()) {
         // Saving a copy of the project should never overwrite an existing project.
         AudacityMessageDialog m(
            nullptr,
            XO("The project was not saved because the file name provided would overwrite another project.\nPlease try again and select an original name."),
            XO("Error Saving Project"),
            wxOK|wxICON_ERROR );
         m.ShowModal();
         return false;
      }
 
      fName = filename.GetFullPath();
 
      bOwnsNewName = !projectFileIO.IsTemporary() && ( projectFileIO.GetFileName() == fName );
      // Check to see if the project file already exists, and if it does
      // check that the project file 'belongs' to this project.
      // otherwise, prompt the user before overwriting.
      if (!bOwnsNewName && filename.FileExists()) {
         // Ensure that project of same name is not open in another window.
         // fName is the destination file.
         // mFileName is this project.
         // It is possible for mFileName == fName even when this project is not
         // saved to disk, and we then need to check the destination file is not
         // open in another window.
         int mayOverwrite = ( projectFileIO.GetFileName() == fName ) ? 2 : 1;
         for ( auto p : AllProjects{} ) {
            const wxFileName openProjectName{ ProjectFileIO::Get(*p).GetFileName() };
            if (openProjectName.SameAs(fName)) {
               mayOverwrite -= 1;
               if (mayOverwrite == 0)
                  break;
            }
         }
 
         if (mayOverwrite > 0) {
            /* i18n-hint: In each case, %s is the name
             of the file being overwritten.*/
            auto Message = XO("\
   Do you want to overwrite the project:\n\"%s\"?\n\n\
   If you select \"Yes\" the project\n\"%s\"\n\
   will be irreversibly overwritten.").Format( fName, fName );
 
            // For safety, there should NOT be an option to hide this warning.
            int result = AudacityMessageBox(
               Message,
               /* i18n-hint: Heading: A warning that a project is about to be overwritten.*/
               XO("Overwrite Project Warning"),
               wxYES_NO | wxNO_DEFAULT | wxICON_WARNING,
               &window);
            if (result == wxNO) {
               continue;
            }
            if (result == wxCANCEL) {
               return false;
            }
         }
         else {
            // Overwrite disallowed. The destination project is open in another window.
            AudacityMessageDialog m(
               nullptr,
               XO("The project was not saved because the selected project is open in another window.\nPlease try again and select an original name."),
               XO("Error Saving Project"),
               wxOK|wxICON_ERROR );
            m.ShowModal();
            continue;
         }
      }
 
      break;
   } while (bPrompt);
 
 
   // Pretend that we are closing the project
   if (!bOwnsNewName)
   {
      if (
         ProjectFileIOExtensionRegistry::OnClose(mProject) ==
         OnCloseAction::Veto)
         return false;
   }
 
   auto success = DoSave(fName, !bOwnsNewName);
   if (success) {
      FileHistory::Global().Append( projectFileIO.GetFileName() );
   }
 
   return(success);
}

References FileHistory::Append(), AudacityMessageBox(), FileNames::AudacityProjects, DoSave(), FileNames::FindDefaultPath(), ProjectFileIO::Get(), ProjectFileIO::GetFileName(), GetProjectFrame(), FileHistory::Global(), FileNames::IsPathAvailable(), anonymous_namespace{TrackSelectHandle.cpp}::Message(), mProject, ProjectFileIOExtensionRegistry::OnClose(), project, SelectFile(), TitleRestorer::sProjName, TitleRestorer::sProjNumber, title, Veto, wxT(), and XO().

Referenced by audacity::cloud::audiocom::sync::ResaveLocally(), and Save().

Here is the call graph for this function:

Here is the caller graph for this function:

SaveAs() [2/2]

bool ProjectFileManager::SaveAs	(	const FilePath &	newFileName,
		bool	addToHistory = true
	)

Definition at line 442 of file ProjectFileManager.cpp.

{
   auto &project = mProject;
   auto &projectFileIO = ProjectFileIO::Get( project );
 
   auto oldFileName = projectFileIO.GetFileName();
 
   bool bOwnsNewName = !projectFileIO.IsTemporary() && (oldFileName == newFileName);
   //check to see if the NEW project file already exists.
   //We should only overwrite it if this project already has the same name, where the user
   //simply chose to use the save as command although the save command would have the effect.
   if( !bOwnsNewName && wxFileExists(newFileName)) {
      AudacityMessageDialog m(
         nullptr,
         XO("The project was not saved because the file name provided would overwrite another project.\nPlease try again and select an original name."),
         XO("Error Saving Project"),
         wxOK|wxICON_ERROR );
      m.ShowModal();
      return false;
   }
 
   auto success = DoSave(newFileName, !bOwnsNewName);
   if (success && addToHistory) {
      FileHistory::Global().Append( projectFileIO.GetFileName() );
   }
 
   return(success);
}

References FileHistory::Append(), DoSave(), ProjectFileIO::Get(), FileHistory::Global(), mProject, project, and XO().

Here is the call graph for this function:

SaveCopy()

bool ProjectFileManager::SaveCopy

(

const FilePath &

fileName = wxT("")

)

Definition at line 610 of file ProjectFileManager.cpp.

{
   auto &project = mProject;
   auto &projectFileIO = ProjectFileIO::Get(project);
   auto &window = GetProjectFrame(project);
   TitleRestorer Restorer(window, project); // RAII
   wxFileName filename = fileName;
   FilePath defaultSavePath = FileNames::FindDefaultPath(FileNames::Operation::Save);
 
   if (fileName.empty())
   {
      if (projectFileIO.IsTemporary())
      {
         filename.SetPath(defaultSavePath);
      }
      else
      {
         filename = projectFileIO.GetFileName();
      }
   }
 
   // Bug 1304: Set a default file path if none was given.  For Save/SaveAs/SaveCopy
   if (!FileNames::IsPathAvailable(filename.GetPath(wxPATH_GET_VOLUME | wxPATH_GET_SEPARATOR)))
   {
      filename.SetPath(defaultSavePath);
   }
 
   TranslatableString title =
      XO("%sSave Copy of Project \"%s\" As...")
         .Format(Restorer.sProjNumber, Restorer.sProjName);
 
   bool bPrompt = (project.mBatchMode == 0) || (projectFileIO.GetFileName().empty());
   FilePath fName;
 
   do
   {
      if (bPrompt)
      {
         // JKC: I removed 'wxFD_OVERWRITE_PROMPT' because we are checking
         // for overwrite ourselves later, and we disallow it.
         // Previously we disallowed overwrite because we would have had
         // to DELETE the many smaller files too, or prompt to move them.
         // Maybe we could allow it now that we have aup3 format?
         fName = SelectFile(FileNames::Operation::Export,
                                       title,
                                       filename.GetPath(),
                                       filename.GetFullName(),
                                       wxT("aup3"),
                                       { FileNames::AudacityProjects },
                                       wxFD_SAVE | wxRESIZE_BORDER,
                                       &window);
 
         if (fName.empty())
         {
            return false;
         }
 
         filename = fName;
      };
 
      filename.SetExt(wxT("aup3"));
 
      if (TempDirectory::FATFilesystemDenied(filename.GetFullPath(), XO("Projects cannot be saved to FAT drives.")))
      {
         if (project.mBatchMode)
         {
            return false;
         }
 
         continue;
      }
 
      if (filename.FileExists())
      {
         // Saving a copy of the project should never overwrite an existing project.
         AudacityMessageDialog m(nullptr,
                                 XO("Saving a copy must not overwrite an existing saved project.\nPlease try again and select an original name."),
                                 XO("Error Saving Copy of Project"),
                                 wxOK | wxICON_ERROR);
         m.ShowModal();
 
         if (project.mBatchMode)
         {
            return false;
         }
 
         continue;
      }
 
      wxULongLong fileSize = wxFileName::GetSize(projectFileIO.GetFileName());
 
      wxDiskspaceSize_t freeSpace;
      if (wxGetDiskSpace(FileNames::AbbreviatePath(filename.GetFullPath()), NULL, &freeSpace))
      {
         if (freeSpace.GetValue() <= fileSize.GetValue())
         {
            BasicUI::ShowErrorDialog( *ProjectFramePlacement( &project ),
               XO("Insufficient Disk Space"),
               XO("The project size exceeds the available free space on the target disk.\n\n"
                  "Please select a different disk with more free space."),
               "Error:_Unsuitable_drive"
               );
 
            continue;
         }
      }
 
      if (FileNames::IsOnFATFileSystem(filename.GetFullPath()))
      {
         if (fileSize > UINT32_MAX)
         {
            BasicUI::ShowErrorDialog( *ProjectFramePlacement( &project ),
               XO("Error Saving Project"),
               XO("The project exceeds the maximum size of 4GB when writing to a FAT32 formatted filesystem."),
               "Error:_Unsuitable_drive"
               );
 
            if (project.mBatchMode)
            {
               return false;
            }
 
            continue;
         }
      }
 
      fName = filename.GetFullPath();
      break;
   } while (bPrompt);
 
   if (!projectFileIO.SaveCopy(fName))
   {
      auto msg = FileException::WriteFailureMessage(fName);
      AudacityMessageDialog m(
         nullptr, msg, XO("Error Saving Project"), wxOK | wxICON_ERROR);
 
      m.ShowModal();
 
      return false;
   }
 
   return true;
}

References FileNames::AbbreviatePath(), FileNames::AudacityProjects, TempDirectory::FATFilesystemDenied(), FileNames::FindDefaultPath(), ProjectFileIO::Get(), GetProjectFrame(), FileNames::IsOnFATFileSystem(), FileNames::IsPathAvailable(), mProject, project, ProjectFramePlacement(), SelectFile(), BasicUI::ShowErrorDialog(), TitleRestorer::sProjName, TitleRestorer::sProjNumber, title, FileException::WriteFailureMessage(), wxT(), and XO().

Here is the call graph for this function:

SaveFromTimerRecording()

bool ProjectFileManager::SaveFromTimerRecording

(

wxFileName

fnFile

)

Definition at line 754 of file ProjectFileManager.cpp.

{
   auto &project = mProject;
   auto &projectFileIO = ProjectFileIO::Get( project );
 
   // MY: Will save the project to a NEW location a-la Save As
   // and then tidy up after itself.
 
   wxString sNewFileName = fnFile.GetFullPath();
 
   // MY: To allow SaveAs from Timer Recording we need to check what
   // the value of mFileName is before we change it.
   FilePath sOldFilename;
   if (!projectFileIO.IsModified()) {
      sOldFilename = projectFileIO.GetFileName();
   }
 
   // MY: If the project file already exists then bail out
   // and send populate the message string (pointer) so
   // we can tell the user what went wrong.
   if (wxFileExists(sNewFileName)) {
      return false;
   }
 
   auto success = DoSave(sNewFileName, true);
 
   if (success) {
      FileHistory::Global().Append( projectFileIO.GetFileName() );
   }
 
   return success;
}

References FileHistory::Append(), DoSave(), ProjectFileIO::Get(), FileHistory::Global(), mProject, and project.

Here is the call graph for this function:

SetMenuClose()

void ProjectFileManager::SetMenuClose ( bool  value )

inline

Definition at line 107 of file ProjectFileManager.h.

{ mMenuClose = value; }

Referenced by anonymous_namespace{FileMenus.cpp}::OnClose().

Here is the caller graph for this function:

ShowOpenDialog()

wxArrayString ProjectFileManager::ShowOpenDialog ( FileNames::Operation  op, const FileNames::FileType &  extraType = {}  )

static

Show an open dialogue for opening audio files, and possibly other sorts of files.

The file type filter will automatically contain:

• "All files" with any extension or none,
• "All supported files" based on the file formats supported in this build of Audacity,
• All of the individual formats specified by the importer plug-ins which are built into this build of Audacity, each with the relevant file extensions for that format. The dialogue will start in the DefaultOpenPath directory read from the preferences, failing that the working directory. The file format filter will be set to the DefaultOpenType from the preferences, failing that the first format specified in the dialogue. These two parameters will be saved to the preferences once the user has chosen a file to open.

  Parameters

  extraType

  Specify an additional format to allow opening in this dialogue.

  Returns

  Array of file paths which the user selected to open (multiple selections allowed).

Definition at line 859 of file ProjectFileManager.cpp.

{
   // Construct the filter
   const auto fileTypes = Importer::Get().GetFileTypes( extraType );
 
   // Retrieve saved path
   auto path = FileNames::FindDefaultPath(op);
 
   // Construct and display the file dialog
   wxArrayString selected;
 
   FileDialogWrapper dlog(nullptr,
      XO("Select one or more files"),
      path,
      wxT(""),
      fileTypes,
      wxFD_OPEN | wxFD_MULTIPLE | wxRESIZE_BORDER);
 
   dlog.SetFilterIndex( Importer::SelectDefaultOpenType( fileTypes ) );
 
   int dialogResult = dlog.ShowModal();
 
   // Convert the filter index to type and save
   auto index = dlog.GetFilterIndex();
   const auto &saveType = fileTypes[ index ];
 
   Importer::SetDefaultOpenType( saveType );
   Importer::SetLastOpenType( saveType );
 
   if (dialogResult == wxID_OK) {
      // Return the selected files
      dlog.GetPaths(selected);
 
      // Remember the directory
      FileNames::UpdateDefaultPath(op, ::wxPathOnly(dlog.GetPath()));
   }
 
   return selected;
}

References FileNames::FindDefaultPath(), Importer::Get(), Importer::GetFileTypes(), FileDialog::GetFilterIndex(), FileDialog::GetPath(), FileDialog::GetPaths(), Importer::SelectDefaultOpenType(), Importer::SetDefaultOpenType(), FileDialog::SetFilterIndex(), Importer::SetLastOpenType(), FileDialog::ShowModal(), FileNames::UpdateDefaultPath(), wxT(), and XO().

Referenced by anonymous_namespace{FileMenus.cpp}::DoImport(), and ProjectManager::OpenFiles().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

mLastSavedTracks

std::shared_ptr<TrackList> ProjectFileManager::mLastSavedTracks

private

Definition at line 149 of file ProjectFileManager.h.

Referenced by CloseProject(), CompactProjectOnClose(), and DoSave().

mMenuClose

bool ProjectFileManager::mMenuClose { false }

private

Definition at line 152 of file ProjectFileManager.h.

mProject

AudacityProject& ProjectFileManager::mProject

private

Definition at line 147 of file ProjectFileManager.h.

Referenced by AddImportedTracks(), CloseProject(), Compact(), CompactProjectOnClose(), DoImport(), DoSave(), Import(), ImportAndRunTempoDetection(), OpenNewProject(), OpenProject(), OpenProjectFile(), Save(), SaveAs(), SaveCopy(), and SaveFromTimerRecording().

---

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

• ProjectFileManager.h
• ProjectFileManager.cpp