Project.h File Reference

#include "Audacity.h"
#include "Experimental.h"
#include "widgets/OverlayPanel.h"
#include "DirManager.h"
#include "SelectionState.h"
#include "ViewInfo.h"
#include "TrackPanelListener.h"
#include "AudioIOListener.h"
#include "commands/CommandManager.h"
#include "effects/EffectManager.h"
#include "xml/XMLTagHandler.h"
#include "toolbars/SelectionBarListener.h"
#include "toolbars/SpectralSelectionBarListener.h"
#include "MemoryX.h"
#include <wx/defs.h>
#include <wx/event.h>
#include <wx/log.h>
#include <wx/dragimag.h>
#include <wx/generic/dragimgg.h>
#include <wx/frame.h>
#include <wx/intl.h>
#include <wx/dcclient.h>
#include "import/ImportRaw.h"
#include "./commands/CommandFlag.h"
#include "../include/audacity/EffectInterface.h"
#include "Menus.h"

Go to the source code of this file.

Classes
class	ImportXMLTagHandler
class	AudacityProject
	AudacityProject provides the main window, with tools and tracks contained within it. More...
struct	AudacityProject::FoundTrack
struct	AudacityProject::FoundClip
struct	AudacityProject::FoundClipBoundary
class	AudacityProject::OnEffectFlags
class	AudacityProject::PlaybackScroller

Macros
#define	kAudacitySortByTime   (1 << 1)
#define	kAudacitySortByName   (1 << 2)

Typedefs
using	AProjectHolder = std::shared_ptr< AudacityProject >
using	AProjectArray = std::vector< AProjectHolder >
typedef wxArrayString	PluginIDList

Enumerations
enum	PlayMode : int { PlayMode::normalPlay, PlayMode::oneSecondPlay, PlayMode::loopedPlay }
enum	StatusBarField { stateStatusBarField = 1, mainStatusBarField = 2, rateStatusBarField = 3 }

Functions
AudacityProject *	CreateNewAudacityProject ()
AUDACITY_DLL_API AudacityProject *	GetActiveProject ()
void	RedrawAllProjects ()
void	RefreshCursorForAllProjects ()
AUDACITY_DLL_API void	CloseAllProjects ()
void	GetDefaultWindowRect (wxRect *defRect)
void	GetNextWindowPlacement (wxRect *nextRect, bool *pMaximized, bool *pIconized)
bool	IsWindowAccessible (wxRect *requestedRect)
	DECLARE_EXPORTED_EVENT_TYPE (AUDACITY_DLL_API, EVT_CAPTURE_KEY,-1)
	Custom events. More...

Variables
const int	AudacityProjectTimerID = 5200
AProjectArray	gAudacityProjects

Macro Definition Documentation

#define kAudacitySortByName   (1 << 2)

Definition at line 720 of file Project.h.

Referenced by AudacityProject::OnSortName(), and AudacityProject::SortTracks().

#define kAudacitySortByTime   (1 << 1)

Definition at line 719 of file Project.h.

Referenced by AudacityProject::OnSortTime(), and AudacityProject::SortTracks().

Typedef Documentation

using AProjectArray = std::vector< AProjectHolder >

Definition at line 120 of file Project.h.

using AProjectHolder = std::shared_ptr< AudacityProject >

Definition at line 119 of file Project.h.

typedef wxArrayString PluginIDList

Definition at line 160 of file Project.h.

Enumeration Type Documentation

enum PlayMode : int

strong

Enumerator
normalPlay
oneSecondPlay
loopedPlay

Definition at line 125 of file Project.h.

                    : int {
   normalPlay,
   oneSecondPlay, // Disables auto-scrolling
   loopedPlay // Disables auto-scrolling
};

enum StatusBarField

Enumerator
stateStatusBarField
mainStatusBarField
rateStatusBarField

Definition at line 131 of file Project.h.

                    {
   stateStatusBarField = 1,
   mainStatusBarField = 2,
   rateStatusBarField = 3
};

Function Documentation

AUDACITY_DLL_API void CloseAllProjects

(

)

Definition at line 611 of file Project.cpp.

References gAudacityOffsetInc, gAudacityPosInc, and gAudacityProjects.

{
   size_t len = gAudacityProjects.size();
   for (size_t i = 0; i < len; i++)
      gAudacityProjects[i]->Close();

   //Set the Offset and Position increments to 0
   gAudacityOffsetInc = 0;
   gAudacityPosInc = 0;
}

AudacityProject* CreateNewAudacityProject

(

)

Definition at line 549 of file Project.cpp.

References ModuleManager::Dispatch(), gAudacityProjects, gAudioIO, ModuleManager::Get(), GetNextWindowPlacement(), ProjectInitialized, safenew, SetActiveProject(), and AudioIO::SetListener().

Referenced by AudacityProject::OnCloseWindow(), AudacityApp::OnInit(), AudacityApp::OnMenuNew(), AudacityProject::OnNew(), and AudacityProject::OpenProject().

{
   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!
   gAudacityProjects.push_back( AProjectHolder {
      safenew AudacityProject(
         nullptr, -1,
         wxDefaultPosition,
         wxSize(wndRect.width, wndRect.height)
      ),
      Destroyer< AudacityProject > {}
   } );
   const auto p = gAudacityProjects.back().get();

   // wxGTK3 seems to need to require creating the window using default position
   // and then manually positioning it.
   p->SetPosition(wndRect.GetPosition());

   if(bMaximized) {
      p->Maximize(true);
   }
   else if (bIconized) {
      // if the user close down and iconized state we could start back up and iconized state
      // p->Iconize(TRUE);
   }

   //Initialise the Listener
   gAudioIO->SetListener(p);

   //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.
   p->GetToolManager()->RegenerateTooltips();

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

   p->Show(true);

   return p;
}

DECLARE_EXPORTED_EVENT_TYPE	(	AUDACITY_DLL_API	,
		EVT_CAPTURE_KEY	,
		-	1
	)

Custom events.

AUDACITY_DLL_API AudacityProject* GetActiveProject

(

)

Definition at line 308 of file Project.cpp.

{
   return gActiveProject;
}

void GetDefaultWindowRect

(

wxRect *

defRect

)

Definition at line 623 of file Project.cpp.

Referenced by GetNextWindowPlacement(), and SaveWindowSize().

{
   *defRect = wxGetClientDisplayRect();

   int width = 940;
   int height = 674;

   //These conditional values assist in improving placement and size
   //of NEW windows on different platforms.
#ifdef __WXGTK__
   height += 20;
#endif

#ifdef __WXMSW__
   height += 40;
#endif

#ifdef __WXMAC__
   height += 55;
#endif

   // Use screen size where it is smaller than the values we would like.
   // Otherwise use the values we would like, and centred.
   if (width < defRect->width)
   {
      defRect->x = (defRect->width - width)/2;
      defRect->width = width;
   }

   if (height < defRect->height)
   {
      defRect->y = (defRect->height - height)/2;
      // Bug 1119 workaround
      // Small adjustment for very small Mac screens.
      // If there is only a tiny space at the top
      // then instead of vertical centre, align to bottom.
      const int pixelsFormenu = 60;
      if( defRect->y < pixelsFormenu )
         defRect->y *=2;
      defRect->height = height;
   }
}

void GetNextWindowPlacement	(	wxRect *	nextRect,
		bool *	pMaximized,
		bool *	pIconized
	)

Definition at line 718 of file Project.cpp.

References CornersOnScreen(), gAudacityProjects, GetDefaultWindowRect(), gPrefs, IsWindowAccessible(), and ScreenContaining().

Referenced by CreateNewAudacityProject(), and AudacityApp::OnInit().

{
   int inc = 25;

   wxRect defaultRect;
   GetDefaultWindowRect(&defaultRect);

   gPrefs->Read(wxT("/Window/Maximized"), pMaximized, false);
   gPrefs->Read(wxT("/Window/Iconized"), pIconized, false);

   wxRect windowRect;
   gPrefs->Read(wxT("/Window/X"), &windowRect.x, defaultRect.x);
   gPrefs->Read(wxT("/Window/Y"), &windowRect.y, defaultRect.y);
   gPrefs->Read(wxT("/Window/Width"), &windowRect.width, defaultRect.width);
   gPrefs->Read(wxT("/Window/Height"), &windowRect.height, defaultRect.height);

   wxRect normalRect;
   gPrefs->Read(wxT("/Window/Normal_X"), &normalRect.x, defaultRect.x);
   gPrefs->Read(wxT("/Window/Normal_Y"), &normalRect.y, defaultRect.y);
   gPrefs->Read(wxT("/Window/Normal_Width"), &normalRect.width, defaultRect.width);
   gPrefs->Read(wxT("/Window/Normal_Height"), &normalRect.height, defaultRect.height);

   // Workaround 2.1.1 and earlier bug on OSX...affects only normalRect, but let's just
   // validate for all rects and plats
   if (normalRect.width == 0 || normalRect.height == 0) {
      normalRect = defaultRect;
   }
   if (windowRect.width == 0 || windowRect.height == 0) {
      windowRect = defaultRect;
   }


   wxRect screenRect( wxGetClientDisplayRect());
#if defined(__WXMAC__)

   // On OSX, the top of the window should never be less than the menu height,
   // so something is amiss if it is
   if (normalRect.y < screenRect.y) {
      normalRect = defaultRect;
   }
   if (windowRect.y < screenRect.y) {
      windowRect = defaultRect;
   }
#endif

   // IF projects empty, THEN it's the first window.
   // It lands where the config says it should, and can straddle screen.
   if (gAudacityProjects.empty()) {
      if (*pMaximized || *pIconized) {
         *nextRect = normalRect;
      }
      else {
         *nextRect = windowRect;
      }
      // Resize, for example if one monitor that was on is now off.
      if (!CornersOnScreen( wxRect(*nextRect).Deflate( 32, 32 ))) {
         *nextRect = defaultRect;
      }
      if (!IsWindowAccessible(nextRect)) {
         *nextRect = defaultRect;
      }
      // Do not trim the first project window down.
      // All corners are on screen (or almost so), and 
      // the rect may straddle screens.
      return;
   }


   // ELSE a subsequent NEW window.  It will NOT straddle screens.

   // We don't mind being 32 pixels off the screen in any direction.
   // Make sure initial sizes (pretty much) fit within the display bounds
   // We used to trim the sizes which could result in ridiculously small windows.
   // contributing to bug 1243.
   // Now instead if the window significantly doesn't fit the screen, we use the default 
   // window instead, which we know does.
   if (ScreenContaining( wxRect(normalRect).Deflate( 32, 32 ))<0) {
      normalRect = defaultRect;
   }
   if (ScreenContaining( wxRect(windowRect).Deflate( 32, 32 ) )<0) {
      windowRect = defaultRect;
   }

   bool validWindowSize = false;
   AudacityProject * validProject = NULL;
   size_t numProjects = gAudacityProjects.size();
   for (int i = numProjects; i > 0 ; i--) {
      if (!gAudacityProjects[i-1]->IsIconized()) {
            validWindowSize = true;
            validProject = gAudacityProjects[i-1].get();
            break;
      }
   }
   if (validWindowSize) {
      *nextRect = validProject->GetRect();
      *pMaximized = validProject->IsMaximized();
      *pIconized = validProject->IsIconized();
      // Do not straddle screens.
      if (ScreenContaining( wxRect(*nextRect).Deflate( 32, 32 ) )<0) {
         *nextRect = defaultRect;
      }
   }
   else {
      *nextRect = normalRect;
   }

   //Placement depends on the increments
   nextRect->x += inc;
   nextRect->y += inc;

   // defaultrect is a rectangle on the first screen.  It's the right fallback to 
   // use most of the time if things are not working out right with sizing.
   // windowRect is a saved rectangle size.
   // normalRect seems to be a substitute for windowRect when iconized or maximised.

   // Windows can say that we are off screen when actually we are not.
   // On Windows 10 I am seeing miscalculation by about 6 pixels.
   // To fix this we allow some sloppiness on the edge being counted as off screen.
   // This matters most when restoring very carefully sized windows that are maximised
   // in one dimension (height or width) but not both.
   const int edgeSlop = 10;

   // Next four lines are getting the rectangle for the screen that contains the
   // top left corner of nextRect (and defaulting to rect of screen 0 otherwise).
   wxPoint p = nextRect->GetLeftTop();
   int scr = std::max( 0, wxDisplay::GetFromPoint( p ));
   wxDisplay d( scr );
   screenRect = d.GetClientArea();

   // Now we (possibly) start trimming our rectangle down.
   // Have we hit the right side of the screen?
   wxPoint bottomRight = nextRect->GetBottomRight();
   if (bottomRight.x > (screenRect.GetRight()+edgeSlop)) {
      int newWidth = screenRect.GetWidth() - nextRect->GetLeft();
      if (newWidth < defaultRect.GetWidth()) {
         nextRect->x = windowRect.x;
         nextRect->y = windowRect.y;
         nextRect->width = windowRect.width;
      }
      else {
         nextRect->width = newWidth;
      }
   }

   // Have we hit the bottom of the screen?
   bottomRight = nextRect->GetBottomRight();
   if (bottomRight.y > (screenRect.GetBottom()+edgeSlop)) {
      nextRect->y -= inc;
      bottomRight = nextRect->GetBottomRight();
      if (bottomRight.y > (screenRect.GetBottom()+edgeSlop)) {
         nextRect->SetBottom(screenRect.GetBottom());
      }
   }

   // After all that we could have a window that does not have a visible
   // top bar.  [It is unlikely, but something might have gone wrong]
   // If so, use the safe fallback size.
   if (!IsWindowAccessible(nextRect)) {
      *nextRect = defaultRect;
   }
}

bool IsWindowAccessible

(

wxRect *

requestedRect

)

Definition at line 667 of file Project.cpp.

References monitor.

Referenced by GetNextWindowPlacement().

{
   wxDisplay display;
   wxRect targetTitleRect(requestedRect->GetLeftTop(), requestedRect->GetBottomRight());
   // Hackery to approximate a window top bar size from a window size.
   // and exclude the open/close and borders.
   targetTitleRect.x += 15;
   targetTitleRect.width -= 100;
   if (targetTitleRect.width <  165) targetTitleRect.width = 165;
   targetTitleRect.height = 15;
   int targetBottom = targetTitleRect.GetBottom();
   int targetRight = targetTitleRect.GetRight();
   // This looks like overkill to check each and every pixel in the ranges.
   // and decide that if any is visible on screen we are OK.
   for (int i =  targetTitleRect.GetLeft(); i < targetRight; i++) {
      for (int j = targetTitleRect.GetTop(); j < targetBottom; j++) {
         int monitor = display.GetFromPoint(wxPoint(i, j));
         if (monitor != wxNOT_FOUND) {
            return TRUE;
         }
      }
   }
   return FALSE;
}

void RedrawAllProjects

(

)

Definition at line 597 of file Project.cpp.

References gAudacityProjects.

Referenced by ToolsToolBar::OnTool().

{
   size_t len = gAudacityProjects.size();
   for (size_t i = 0; i < len; i++)
      gAudacityProjects[i]->RedrawProject();
}

void RefreshCursorForAllProjects

(

)

Definition at line 604 of file Project.cpp.

References gAudacityProjects.

Referenced by ToolsToolBar::SetCurrentTool().

{
   size_t len = gAudacityProjects.size();
   for (size_t i = 0; i < len; i++)
      gAudacityProjects[i]->RefreshCursor();
}

Variable Documentation

const int AudacityProjectTimerID = 5200

Definition at line 49 of file Project.h.

Referenced by AudacityProject::AudacityProject().

AProjectArray gAudacityProjects

Definition at line 303 of file Project.cpp.

Referenced by Theme::ApplyUpdatedImages(), CloseAllProjects(), AudacityProject::CountUnnamed(), CreateNewAudacityProject(), ODTask::DoSome(), Exporter::GetFilename(), GetNextWindowPlacement(), AudacityProject::GetOpenProjectCount(), AudacityProject::IsAlreadyOpen(), AudacityApp::MarkAliasedFilesMissingWarning(), AudacityProject::ModifyAllProjectToolbarMenus(), DeviceToolBar::OnChoice(), AudacityProject::OnCloseWindow(), AudacityApp::OnEndSession(), AudacityProject::OnIconize(), AudacityProject::OnMacBringAllToFront(), AudacityProject::OnMacMinimizeAll(), AudacityApp::OnMenuExit(), AudacityApp::OnMenuNew(), AudacityApp::OnMenuOpen(), AudacityApp::OnMenuPreferences(), PrefsDialog::OnOK(), AudacityProject::OnPlayStop(), AudacityProject::OnPreferences(), AudacityProject::OnReloadPreferences(), NyquistEffect::Process(), QuitAudacity(), AudacityProject::RebuildAllMenuBars(), RedrawAllProjects(), AudacityProject::RefreshAllTitles(), RefreshCursorForAllProjects(), DeviceManager::Rescan(), AudacityProject::SaveAs(), and SaveWindowSize().