ProjectManager Class Reference

Object associated with a project for high-level management of the project's lifetime, including creation, destruction, opening from file, importing, pushing undo states, and reverting to saved states. More...

#include <ProjectManager.h>

Inheritance diagram for ProjectManager:

Collaboration diagram for ProjectManager:

Classes
class	ProjectChooser
	Callable object that supplies the chooser argument of ProjectFileManager::OpenFile. More...

Public Member Functions
	ProjectManager (AudacityProject &project)
	ProjectManager (const ProjectManager &)=delete
ProjectManager &	operator= (const ProjectManager &)=delete
	~ProjectManager () override
void	ResetProjectToEmpty ()
int	GetEstimatedRecordingMinsLeftOnDisk (long lCaptureChannels=0)
TranslatableString	GetHoursMinsString (int iMinutes)
void	SetStatusText (const TranslatableString &text, int number)
void	SetSkipSavePrompt (bool bSkip)
Public Member Functions inherited from ClientData::Base
virtual	~Base ()

Static Public Member Functions
static ProjectManager &	Get (AudacityProject &project)
static const ProjectManager &	Get (const AudacityProject &project)
static AudacityProject *	New ()
static void	OpenFiles (AudacityProject *proj)
static bool	SafeToOpenProjectInto (AudacityProject &proj)
	False when it is unsafe to overwrite proj with contents of an .aup3 file. More...
static AudacityProject *	OpenProject (AudacityProject *pGivenProject, const FilePath &fileNameArg, bool addtohistory, bool reuseNonemptyProject)
	Open a file into an AudacityProject, returning the project, or nullptr for failure. More...
static void	SaveWindowSize ()
static void	SetClosingAll (bool closing)

Private Member Functions
void	OnReconnectionFailure (ProjectFileIOMessage)
void	OnCloseWindow (wxCloseEvent &event)
void	OnTimer (wxTimerEvent &event)
void	OnStatusChange (StatusBarField field)
void	RestartTimer ()

Private Attributes
AudacityProject &	mProject
std::unique_ptr< wxTimer >	mTimer
Observer::Subscription	mProjectStatusSubscription
Observer::Subscription	mProjectFileIOSubscription

Static Private Attributes
static bool	sbWindowRectAlreadySaved = false
static bool	sbSkipPromptingForSave = false

Detailed Description

Object associated with a project for high-level management of the project's lifetime, including creation, destruction, opening from file, importing, pushing undo states, and reverting to saved states.

Definition at line 33 of file ProjectManager.h.

Constructor & Destructor Documentation

ProjectManager() [1/2]

ProjectManager::ProjectManager ( AudacityProject &  project )

explicit

Definition at line 88 of file ProjectManager.cpp.

   : mProject{ project }
   , mTimer{ std::make_unique<wxTimer>(this, AudacityProjectTimerID) }
{
   auto &window = ProjectWindow::Get( mProject );
   window.Bind( wxEVT_CLOSE_WINDOW, &ProjectManager::OnCloseWindow, this );
   mProjectStatusSubscription = ProjectStatus::Get(mProject)
      .Subscribe(*this, &ProjectManager::OnStatusChange);
   mProjectFileIOSubscription = ProjectFileIO::Get(mProject)
      .Subscribe(*this, &ProjectManager::OnReconnectionFailure);
}

References ProjectFileIO::Get(), ProjectStatus::Get(), ProjectWindow::Get(), mProject, mProjectFileIOSubscription, mProjectStatusSubscription, OnCloseWindow(), OnReconnectionFailure(), OnStatusChange(), and Observer::Publisher< Message, NotifyAll >::Subscribe().

Here is the call graph for this function:

ProjectManager() [2/2]

ProjectManager::ProjectManager ( const ProjectManager &  )

delete

~ProjectManager()

ProjectManager::~ProjectManager ( )

overridedefault

Member Function Documentation

Get() [1/2]

ProjectManager & ProjectManager::Get ( AudacityProject &  project )

static

Definition at line 78 of file ProjectManager.cpp.

{
   return project.AttachedObjects::Get< ProjectManager >( sProjectManagerKey );
}

References project, and sProjectManagerKey.

Referenced by Get(), InitProjectWindow(), New(), ApplyMacroDialog::OnApplyToFiles(), TimerRecordDialog::OnOK(), anonymous_namespace{FileMenus.cpp}::OnProjectReset(), and anonymous_namespace{TimerRecordDialog.cpp}::OnTimerRecord().

Here is the caller graph for this function:

Get() [2/2]

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

static

Definition at line 83 of file ProjectManager.cpp.

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

References Get(), and project.

Here is the call graph for this function:

GetEstimatedRecordingMinsLeftOnDisk()

int ProjectManager::GetEstimatedRecordingMinsLeftOnDisk

(

long

lCaptureChannels = 0

)

Definition at line 854 of file ProjectManager.cpp.

                                                                             {
   auto &project = mProject;
 
   // Obtain the current settings
   auto oCaptureFormat = QualitySettings::SampleFormatChoice();
   if (lCaptureChannels == 0)
      lCaptureChannels = AudioIORecordChannels.Read();
 
   // Find out how much free space we have on disk
   wxLongLong lFreeSpace = ProjectFileIO::Get( project ).GetFreeDiskSpace();
   if (lFreeSpace < 0) {
      return 0;
   }
 
   // Calculate the remaining time
   double dRecTime = 0.0;
   double bytesOnDiskPerSample = SAMPLE_SIZE_DISK(oCaptureFormat);
   dRecTime = lFreeSpace.GetHi() * 4294967296.0 + lFreeSpace.GetLo();
   dRecTime /= bytesOnDiskPerSample;   
   dRecTime /= lCaptureChannels;
   dRecTime /= ProjectRate::Get( project ).GetRate();
 
   // Convert to minutes before returning
   int iRecMins = (int)round(dRecTime / 60.0);
   return iRecMins;
}

References AudioIORecordChannels, ProjectFileIO::Get(), ProjectRate::Get(), ProjectFileIO::GetFreeDiskSpace(), ProjectRate::GetRate(), mProject, project, Setting< T >::Read(), fast_float::round(), SAMPLE_SIZE_DISK, and QualitySettings::SampleFormatChoice().

Referenced by OnTimer().

Here is the call graph for this function:

Here is the caller graph for this function:

GetHoursMinsString()

TranslatableString ProjectManager::GetHoursMinsString

(

int

iMinutes

)

Definition at line 832 of file ProjectManager.cpp.

{
   if (iMinutes < 1)
      // Less than a minute...
      return XO("Less than 1 minute");
 
   // Calculate
   int iHours = iMinutes / 60;
   int iMins = iMinutes % 60;
 
   auto sHours = XP( "%d hour", "%d hours", 0 )( iHours );
 
   auto sMins = XP( "%d minute", "%d minutes", 0 )( iMins );
 
   /* i18n-hint: A time in hours and minutes. Only translate the "and". */
   return XO("%s and %s.").Format( sHours, sMins );
}

References XO(), and XP.

Referenced by OnTimer().

Here is the call graph for this function:

Here is the caller graph for this function:

New()

AudacityProject * ProjectManager::New ( )

static

Definition at line 321 of file ProjectManager.cpp.

{
   wxRect wndRect;
   bool bMaximized = false;
   bool bIconized = false;
   GetNextWindowPlacement(&wndRect, &bMaximized, &bIconized);
   
   // Create and show a NEW project
   // Use a non-default deleter in the smart pointer!
   auto sp = AudacityProject::Create();
   AllProjects{}.Add( sp );
   auto p = sp.get();
   auto &project = *p;
   auto &projectHistory = ProjectHistory::Get( project );
   auto &projectManager = Get( project );
   auto &window = ProjectWindow::Get( *p );
 
   // Issue #2569
   // There is a dependency on the order of initialisation.
   // The menus must be created, and registered, before
   // InitProjectWindows can UpdateMenus.
   MenuCreator::Get(project).CreateMenusAndCommands();
 
   InitProjectWindow( window );
 
   // wxGTK3 seems to need to require creating the window using default position
   // and then manually positioning it.
   window.SetPosition(wndRect.GetPosition());
 
   auto &projectFileManager = ProjectFileManager::Get( *p );
 
   // This may report an error.
   projectFileManager.OpenNewProject();
 
   projectHistory.InitialState();
   projectManager.RestartTimer();
   
   if(bMaximized) {
      window.Maximize(true);
   }
   else if (bIconized) {
      // if the user close down and iconized state we could start back up and iconized state
      // window.Iconize(TRUE);
   }
   
   //Initialise the Listeners
   auto gAudioIO = AudioIO::Get();
   gAudioIO->SetListener(
      ProjectAudioManager::Get( project ).shared_from_this() );
 
   //Set the NEW project as active:
   SetActiveProject(p);
   
   // Okay, GetActiveProject() is ready. Now we can get its CommandManager,
   // and add the shortcut keys to the tooltips.
   ToolManager::Get( *p ).RegenerateTooltips();
   
   ModuleManager::Get().Dispatch(ProjectInitialized);
   
   window.Show(true);
   
   return p;
}

References AllProjects::Add(), AudacityProject::Create(), MenuCreator::CreateMenusAndCommands(), ModuleManager::Dispatch(), AudioIO::Get(), ModuleManager::Get(), ProjectHistory::Get(), MenuCreator::Get(), ProjectAudioManager::Get(), ProjectFileManager::Get(), Get(), ProjectWindow::Get(), ToolManager::Get(), GetNextWindowPlacement(), InitProjectWindow(), project, ProjectInitialized, ToolManager::RegenerateTooltips(), and SetActiveProject().

Referenced by AudacityApp::InitPart2(), AudacityApp::MacNewFile(), OnCloseWindow(), AudacityApp::OnMenuNew(), anonymous_namespace{FileMenus.cpp}::OnNew(), and ProjectManager::ProjectChooser::operator()().

Here is the call graph for this function:

Here is the caller graph for this function:

OnCloseWindow()

void ProjectManager::OnCloseWindow ( wxCloseEvent &  event )

private

Definition at line 398 of file ProjectManager.cpp.

{
   auto &project = mProject;
   auto &projectFileIO = ProjectFileIO::Get( project );
   auto &projectFileManager = ProjectFileManager::Get( project );
   const auto &settings = ProjectSettings::Get( project );
   auto &projectAudioIO = ProjectAudioIO::Get( project );
   auto &tracks = TrackList::Get( project );
   auto &viewport = Viewport::Get(project);
   auto &window = ProjectWindow::Get( project );
   auto gAudioIO = AudioIO::Get();
 
   // We are called for the wxEVT_CLOSE_WINDOW, wxEVT_END_SESSION, and
   // wxEVT_QUERY_END_SESSION, so we have to protect against multiple
   // entries.  This is a hack until the whole application termination
   // process can be reviewed and reworked.  (See bug #964 for ways
   // to exercise the bug that instigated this hack.)
   if (window.IsBeingDeleted())
   {
      event.Skip();
      return;
   }
 
   if (event.CanVeto() && (::wxIsBusy() || project.mbBusyImporting))
   {
      event.Veto();
      return;
   }
 
   // Check to see if we were playing or recording
   // audio, and if so, make sure Audio I/O is completely finished.
   // The main point of this is to properly push the state
   // and flush the tracks once we've completely finished
   // recording NEW state.
   // This code is derived from similar code in
   // AudacityProject::~AudacityProject() and TrackPanel::OnTimer().
   if (projectAudioIO.GetAudioIOToken()>0 &&
       gAudioIO->IsStreamActive(projectAudioIO.GetAudioIOToken())) {
 
      // We were playing or recording audio, but we've stopped the stream.
      ProjectAudioManager::Get( project ).Stop();
 
      projectAudioIO.SetAudioIOToken(0);
      viewport.Redraw();
   }
   else if (gAudioIO->IsMonitoring()) {
      gAudioIO->StopStream();
   }
 
   // MY: Use routine here so other processes can make same check
   bool bHasTracks = !tracks.empty();
 
   // We may not bother to prompt the user to save, if the
   // project is now empty.
   if (!sbSkipPromptingForSave 
      && event.CanVeto() 
      && (settings.EmptyCanBeDirty() || bHasTracks)) {
      if ( UndoManager::Get( project ).UnsavedChanges() ) {
         TitleRestorer Restorer( window, project );// RAII
         /* i18n-hint: The first %s numbers the project, the second %s is the project name.*/
         auto Title = XO("%sSave changes to %s?")
            .Format( Restorer.sProjNumber, Restorer.sProjName );
         auto Message = XO("Save project before closing?");
         if( !bHasTracks )
         {
          Message += XO("\nIf saved, the project will have no tracks.\n\nTo save any previously open tracks:\nCancel, Edit > Undo until all tracks\nare open, then File > Save Project.");
         }
         int result = AudacityMessageBox(
            Message,
            Title,
            wxYES_NO | wxCANCEL | wxICON_QUESTION,
            &window);
 
         if (result == wxCANCEL || (result == wxYES &&
              !GuardedCall<bool>( [&]{ return projectFileManager.Save(); } )
         )) {
            event.Veto();
            return;
         }
      }
   }
#ifdef __WXMAC__
   // Fix bug apparently introduced into 2.1.2 because of wxWidgets 3:
   // closing a project that was made full-screen (as by clicking the green dot
   // or command+/; not merely "maximized" as by clicking the title bar or
   // Zoom in the Window menu) leaves the screen black.
   // Fix it by un-full-screening.
   // (But is there a different way to do this? What do other applications do?
   //  I don't see full screen windows of Safari shrinking, but I do see
   //  momentary blackness.)
   window.ShowFullScreen(false);
#endif
 
   // This achieves auto save on close of project before other important
   // project state is destroyed
   window.Publish(ProjectWindowDestroyedMessage {});
   ModuleManager::Get().Dispatch(ProjectClosing);
 
   // Stop the timer since there's no need to update anything anymore
   mTimer.reset();
 
   // DMM: Save the size of the last window the user closes
   //
   // LL: Save before doing anything else to the window that might make
   //     its size change.
   SaveWindowSize();
 
   window.SetIsBeingDeleted();
 
   // Mac: we never quit as the result of a close.
   // Other systems: we quit only when the close is the result of an external
   // command (on Windows, those are taskbar closes, "X" box, Alt+F4, etc.)
   bool quitOnClose;
#ifdef __WXMAC__
   quitOnClose = false;
#else
   quitOnClose = !projectFileManager.GetMenuClose();
#endif
 
   // DanH: If we're definitely about to quit, clear the clipboard.
   auto &clipboard = Clipboard::Get();
   if ((AllProjects{}.size() == 1) &&
      (quitOnClose || sbClosingAll))
      clipboard.Clear();
   else {
      auto clipboardProject = clipboard.Project().lock();
      if ( clipboardProject.get() == &mProject ) {
         // Closing the project from which content was cut or copied.
         // For 3.0.0, clear the clipboard, because accessing clipboard contents
         // would depend on a database connection to the closing project, but
         // that connection should closed now so that the project file can be
         // freely moved.
         // Notes:
         // 1) maybe clipboard contents could be saved by migrating them to
         // another temporary database, but that extra effort is beyond the
         // scope of 3.0.0.
         // 2) strictly speaking this is necessary only when the clipboard
         // contains WaveTracks.
         clipboard.Clear();
      }
   }
 
   // JKC: For Win98 and Linux do not detach the menu bar.
   // We want wxWidgets to clean it up for us.
   // TODO: Is there a Mac issue here??
   // SetMenuBar(NULL);
 
   // Compact the project.
   projectFileManager.CompactProjectOnClose();
 
   // Set (or not) the bypass flag to indicate that deletes that would happen during
   // the UndoManager::ClearStates() below are not necessary.
   projectFileIO.SetBypass();
 
   {
      // This can reduce reference counts of sample blocks in the project's
      // tracks.
      UndoManager::Get( project ).ClearStates();
 
      // Delete all the tracks to free up memory
      tracks.Clear();
   }
 
   // Some of the AdornedRulerPanel functions refer to the TrackPanel, so destroy this
   // before the TrackPanel is destroyed. This change was needed to stop Audacity
   // crashing when running with Jaws on Windows 10 1703.
   AdornedRulerPanel::Destroy( project );
 
   // Destroy the TrackPanel early so it's not around once we start
   // deleting things like tracks and such out from underneath it.
   // Check validity of mTrackPanel per bug 584 Comment 1.
   // Deeper fix is in the Import code, but this failsafes against crash.
   TrackPanel::Destroy( project );
   // Finalize the tool manager before the children since it needs
   // to save the state of the toolbars.
   ToolManager::Get( project ).Destroy();
 
   window.DestroyChildren();
 
   // Close project only now, because TrackPanel might have been holding
   // some shared_ptr to WaveTracks keeping SampleBlocks alive.
   // We're all done with the project file, so close it now
   projectFileManager.CloseProject();
 
   WaveTrackFactory::Destroy( project );
 
   // Remove self from the global array, but defer destruction of self
   auto pSelf = AllProjects{}.Remove( project );
   wxASSERT( pSelf );
 
   if (GetActiveProject().lock().get() == &project) {
      // Find a NEW active project
      if ( !AllProjects{}.empty() ) {
         SetActiveProject(AllProjects{}.begin()->get());
      }
      else {
         SetActiveProject(nullptr);
      }
   }
 
   // Since we're going to be destroyed, make sure we're not to
   // receive audio notifications anymore.
   // PRL:  Maybe all this is unnecessary now that the listener is managed
   // by a weak pointer.
   if ( gAudioIO->GetListener().get() == &ProjectAudioManager::Get( project ) ) {
      auto active = GetActiveProject().lock();
      gAudioIO->SetListener(
         active
            ? ProjectAudioManager::Get( *active ).shared_from_this()
            : nullptr
      );
   }
 
   if (AllProjects{}.empty() && !sbClosingAll) {
 
#if !defined(__WXMAC__)
      if (quitOnClose) {
         // Simulate the application Exit menu item
         wxCommandEvent evt{ wxEVT_MENU, wxID_EXIT };
         wxTheApp->AddPendingEvent( evt );
      }
      else {
         sbWindowRectAlreadySaved = false;
         // For non-Mac, always keep at least one project window open
         (void) New();
      }
#endif
   }
 
   window.Destroy();
 
   // Destroys this
   pSelf.reset();
}

References AudacityMessageBox(), AllProjects::begin(), UndoManager::ClearStates(), ToolManager::Destroy(), WaveTrackFactory::Destroy(), AdornedRulerPanel::Destroy(), TrackPanel::Destroy(), ModuleManager::Dispatch(), AllProjects::empty(), AudioIO::Get(), ModuleManager::Get(), Clipboard::Get(), ProjectAudioIO::Get(), ProjectFileIO::Get(), UndoManager::Get(), TrackList::Get(), Viewport::Get(), ProjectAudioManager::Get(), ProjectFileManager::Get(), ProjectSettings::Get(), ProjectWindow::Get(), ToolManager::Get(), GetActiveProject(), anonymous_namespace{TrackSelectHandle.cpp}::Message(), mProject, mTimer, New(), project, ProjectClosing, AllProjects::Remove(), SaveWindowSize(), sbClosingAll, sbSkipPromptingForSave, sbWindowRectAlreadySaved, SetActiveProject(), settings(), AllProjects::size(), TitleRestorer::sProjName, TitleRestorer::sProjNumber, ProjectAudioManager::Stop(), tracks, and XO().

Referenced by ProjectManager().

Here is the call graph for this function:

Here is the caller graph for this function:

OnReconnectionFailure()

void ProjectManager::OnReconnectionFailure ( ProjectFileIOMessage  message )

private

Definition at line 385 of file ProjectManager.cpp.

{
   if (message == ProjectFileIOMessage::ReconnectionFailure)
      ProjectWindow::Get(mProject).Close(true);
}

References ProjectWindow::Get(), mProject, and ReconnectionFailure.

Referenced by ProjectManager().

Here is the call graph for this function:

Here is the caller graph for this function:

OnStatusChange()

void ProjectManager::OnStatusChange ( StatusBarField  field )

private

Definition at line 798 of file ProjectManager.cpp.

{
   auto &project = mProject;
 
   // Be careful to null-check the window.  We might get to this function
   // during shut-down, but a timer hasn't been told to stop sending its
   // messages yet.
   auto pWindow = ProjectWindow::Find( &project );
   if ( !pWindow )
      return;
   auto &window = *pWindow;
 
   window.UpdateStatusWidths();
 
   const auto &msg = ProjectStatus::Get( project ).Get( field );
   SetStatusText( msg, field );
   
   if ( field == mainStatusBarField )
      // When recording, let the NEW status message stay at least as long as
      // the timer interval (if it is not replaced again by this function),
      // before replacing it with the message about remaining disk capacity.
      RestartTimer();
}

References field, ProjectWindow::Find(), ProjectStatus::Get(), mainStatusBarField, mProject, project, RestartTimer(), and SetStatusText().

Referenced by ProjectManager().

Here is the call graph for this function:

Here is the caller graph for this function:

OnTimer()

void ProjectManager::OnTimer ( wxTimerEvent &  event )

private

Definition at line 768 of file ProjectManager.cpp.

{
   auto &project = mProject;
   auto &projectAudioIO = ProjectAudioIO::Get( project );
   auto meterToolBars = MeterToolBar::GetToolBars( project );
 
   for (auto& meterToolBar : meterToolBars)
      meterToolBar.get().UpdateControls();
   
   auto gAudioIO = AudioIO::Get();
   // gAudioIO->GetNumCaptureChannels() should only be positive
   // when we are recording.
   if (projectAudioIO.GetAudioIOToken() > 0 && gAudioIO->GetNumCaptureChannels() > 0) {
      wxLongLong freeSpace = ProjectFileIO::Get(project).GetFreeDiskSpace();
      if (freeSpace >= 0) {
 
         int iRecordingMins = GetEstimatedRecordingMinsLeftOnDisk(gAudioIO->GetNumCaptureChannels());
         auto sMessage = XO("Disk space remaining for recording: %s")
            .Format( GetHoursMinsString(iRecordingMins) );
 
         // Do not change mLastMainStatusMessage
         SetStatusText(sMessage, mainStatusBarField);
      }
   }
 
   // As also with the TrackPanel timer:  wxTimer may be unreliable without
   // some restarts
   RestartTimer();
}

References AudioIO::Get(), ProjectAudioIO::Get(), ProjectFileIO::Get(), GetEstimatedRecordingMinsLeftOnDisk(), ProjectFileIO::GetFreeDiskSpace(), GetHoursMinsString(), MeterToolBar::GetToolBars(), mainStatusBarField, mProject, project, RestartTimer(), SetStatusText(), and XO().

Here is the call graph for this function:

OpenFiles()

void ProjectManager::OpenFiles ( AudacityProject *  proj )

static

Definition at line 634 of file ProjectManager.cpp.

{
   auto selectedFiles =
      ProjectFileManager::ShowOpenDialog(FileNames::Operation::Open);
   if (selectedFiles.size() == 0) {
      Importer::SetLastOpenType({});
      return;
   }
 
   //first sort selectedFiles.
   selectedFiles.Sort(FileNames::CompareNoCase);
 
   auto cleanup = finally( [] {
      Importer::SetLastOpenType({});
   } );
 
   for (const auto &fileName : selectedFiles) {
      // Make sure it isn't already open.
      if (ProjectFileManager::IsAlreadyOpen(fileName))
         continue; // Skip ones that are already open.
 
      proj = OpenProject( proj, fileName,
         true /* addtohistory */, false /* reuseNonemptyProject */ );
   }
}

References FileNames::CompareNoCase(), ProjectFileManager::IsAlreadyOpen(), OpenProject(), Importer::SetLastOpenType(), and ProjectFileManager::ShowOpenDialog().

Referenced by OpenProjectCommand::Apply(), AudacityApp::OnMenuOpen(), and anonymous_namespace{FileMenus.cpp}::OnOpen().

Here is the call graph for this function:

Here is the caller graph for this function:

OpenProject()

AudacityProject * ProjectManager::OpenProject ( AudacityProject *  pGivenProject, const FilePath &  fileNameArg, bool  addtohistory, bool  reuseNonemptyProject  )

static

Open a file into an AudacityProject, returning the project, or nullptr for failure.

If an exception escapes this function, no projects are created.

Parameters

pGivenProject	if not null, a project that may be reused
fileNameArg	path to the file to open; not always an Audacity project file, may be an import
addtohistory	whether to add .aup3 files to the MRU list (but always done for imports)
reuseNonemptyProject	if true, may reuse the given project when nonempty, but only if importing (not for a project file)

Definition at line 717 of file ProjectManager.cpp.

{
   ProjectManager::ProjectChooser chooser{ pGivenProject, reuseNonemptyProject };
   if (auto pProject = ProjectFileManager::OpenFile(
      std::ref(chooser), fileNameArg, addtohistory )) {
      chooser.Commit();
 
      auto &projectFileIO = ProjectFileIO::Get( *pProject );
      if( projectFileIO.IsRecovered() ) {
         auto &viewport = Viewport::Get(*pProject);
         viewport.Zoom(viewport.GetZoomOfToFit());
         // "Project was recovered" replaces "Create new project" in Undo History.
         auto &undoManager = UndoManager::Get( *pProject );
         undoManager.RemoveStates(0, 1);
      }
      return pProject;
   }
   return nullptr;
}

References ProjectFileIO::Get(), UndoManager::Get(), Viewport::Get(), and ProjectFileManager::OpenFile().

Referenced by EVT_MENU_RANGE(), LOFImportFileHandle::lofOpenFiles(), OpenFiles(), and RecoverAllProjects().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

ProjectManager & ProjectManager::operator= ( const ProjectManager &  )

delete

ResetProjectToEmpty()

void ProjectManager::ResetProjectToEmpty

(

)

Definition at line 740 of file ProjectManager.cpp.

                                         {
   auto &project = mProject;
   auto &projectFileIO = ProjectFileIO::Get( project );
   auto &projectFileManager = ProjectFileManager::Get( project );
   auto &projectHistory = ProjectHistory::Get( project );
   auto &viewInfo = ViewInfo::Get( project );
 
   SelectUtilities::DoSelectAll( project );
   TrackUtilities::DoRemoveTracks( project );
 
   WaveTrackFactory::Reset( project );
 
   // InitialState will reset UndoManager
   projectHistory.InitialState();
   projectHistory.SetDirty(false);
 
   projectFileManager.CloseProject();
   projectFileManager.OpenProject();
}

References TrackUtilities::DoRemoveTracks(), SelectUtilities::DoSelectAll(), ProjectFileIO::Get(), ProjectHistory::Get(), ViewInfo::Get(), ProjectFileManager::Get(), mProject, project, and WaveTrackFactory::Reset().

Referenced by ApplyMacroDialog::OnApplyToFiles(), and anonymous_namespace{FileMenus.cpp}::OnProjectReset().

Here is the call graph for this function:

Here is the caller graph for this function:

RestartTimer()

void ProjectManager::RestartTimer ( )

private

Definition at line 760 of file ProjectManager.cpp.

{
   if (mTimer) {
      // mTimer->Stop(); // not really needed
      mTimer->Start( 3000 ); // Update messages as needed once every 3 s.
   }
}

References mTimer.

Referenced by OnStatusChange(), and OnTimer().

Here is the caller graph for this function:

SafeToOpenProjectInto()

bool ProjectManager::SafeToOpenProjectInto ( AudacityProject &  proj )

static

False when it is unsafe to overwrite proj with contents of an .aup3 file.

Definition at line 660 of file ProjectManager.cpp.

{
   // DMM: If the project is dirty, that means it's been touched at
   // all, and it's not safe to open a fresh project directly in its
   // place.  Only if the project is brandnew 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 fresh project inside the current window when
   // there are no tracks, but there's an Undo history, etc, then
   // bad things can happen, including orphan blocks, or tracks
   // referring to non-existent blocks
   if (
      ProjectHistory::Get( proj ).GetDirty() ||
      !TrackList::Get( proj ).empty()
   )
      return false;
   // 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 its window.
   return true;
}

References ProjectHistory::Get(), and TrackList::Get().

Referenced by ProjectManager::ProjectChooser::operator()().

Here is the call graph for this function:

Here is the caller graph for this function:

SaveWindowSize()

void ProjectManager::SaveWindowSize ( )

static

Definition at line 109 of file ProjectManager.cpp.

{
   if (sbWindowRectAlreadySaved)
   {
      return;
   }
   bool validWindowForSaveWindowSize = FALSE;
   ProjectWindow * validProject = nullptr;
   bool foundIconizedProject = FALSE;
   for ( auto pProject : AllProjects{} )
   {
      auto &window = ProjectWindow::Get( *pProject );
      if (!window.IsIconized()) {
         validWindowForSaveWindowSize = TRUE;
         validProject = &window;
         break;
      }
      else
         foundIconizedProject =  TRUE;
   }
 
   if (validWindowForSaveWindowSize)
   {
      wxRect windowRect = validProject->GetRect();
      wxRect normalRect = validProject->GetNormalizedWindowState();
      bool wndMaximized = validProject->IsMaximized();
 
      SaveWindowPreferences(windowRect, normalRect, wndMaximized, false);
   }
   else
   {
      if (foundIconizedProject) {
         validProject = &ProjectWindow::Get( **AllProjects{}.begin() );
         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
         SaveWindowPreferences(normalRect, normalRect, wndMaximized, 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);
         SaveWindowPreferences(defWndRect, defWndRect, false, false);
      }
   }
   sbWindowRectAlreadySaved = true;
}

References AllProjects::begin(), ProjectWindow::Get(), GetDefaultWindowRect(), ProjectWindow::GetNormalizedWindowState(), and anonymous_namespace{ProjectManager.cpp}::SaveWindowPreferences().

Referenced by OnCloseWindow(), AudacityApp::OnEndSession(), and QuitAudacity().

Here is the call graph for this function:

Here is the caller graph for this function:

SetClosingAll()

void ProjectManager::SetClosingAll ( bool  closing )

static

Definition at line 393 of file ProjectManager.cpp.

{
   sbClosingAll = closing;
}

References sbClosingAll.

Referenced by CloseAllProjects().

Here is the caller graph for this function:

SetSkipSavePrompt()

void ProjectManager::SetSkipSavePrompt ( bool  bSkip )

inline

Definition at line 114 of file ProjectManager.h.

{ sbSkipPromptingForSave = bSkip; };

Referenced by anonymous_namespace{TimerRecordDialog.cpp}::OnTimerRecord().

Here is the caller graph for this function:

SetStatusText()

void ProjectManager::SetStatusText	(	const TranslatableString &	text,
		int	number
	)

Definition at line 822 of file ProjectManager.cpp.

{
   auto &project = mProject;
   auto pWindow = ProjectWindow::Find( &project );
   if ( !pWindow )
      return;
   auto &window = *pWindow;
   window.GetStatusBar()->SetStatusText(text.Translation(), number);
}

References ProjectWindow::Find(), mProject, project, and TranslatableString::Translation().

Referenced by InitProjectWindow(), OnStatusChange(), and OnTimer().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

mProject

AudacityProject& ProjectManager::mProject

private

Definition at line 127 of file ProjectManager.h.

Referenced by GetEstimatedRecordingMinsLeftOnDisk(), OnCloseWindow(), OnReconnectionFailure(), OnStatusChange(), OnTimer(), ProjectManager(), ResetProjectToEmpty(), and SetStatusText().

mProjectFileIOSubscription

Observer::Subscription ProjectManager::mProjectFileIOSubscription

private

Definition at line 132 of file ProjectManager.h.

Referenced by ProjectManager().

mProjectStatusSubscription

Observer::Subscription ProjectManager::mProjectStatusSubscription

private

Definition at line 131 of file ProjectManager.h.

Referenced by ProjectManager().

mTimer

std::unique_ptr<wxTimer> ProjectManager::mTimer

private

Definition at line 129 of file ProjectManager.h.

Referenced by OnCloseWindow(), and RestartTimer().

sbSkipPromptingForSave

bool ProjectManager::sbSkipPromptingForSave = false

staticprivate

Definition at line 137 of file ProjectManager.h.

Referenced by OnCloseWindow().

sbWindowRectAlreadySaved

bool ProjectManager::sbWindowRectAlreadySaved = false

staticprivate

Definition at line 136 of file ProjectManager.h.

Referenced by OnCloseWindow().

---

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

• ProjectManager.h
• ProjectManager.cpp