ProjectWindow.cpp File Reference

#include "ProjectWindow.h"
#include "ActiveProject.h"
#include "AllThemeResources.h"
#include "AudioIO.h"
#include "Menus.h"
#include "Project.h"
#include "ProjectAudioIO.h"
#include "ProjectFileIO.h"
#include "ProjectWindows.h"
#include "ProjectStatus.h"
#include "ProjectSnap.h"
#include "RefreshCode.h"
#include "TrackPanelMouseEvent.h"
#include "TrackPanelAx.h"
#include "UndoManager.h"
#include "ViewInfo.h"
#include "WaveClip.h"
#include "WaveTrack.h"
#include "commands/CommandContext.h"
#include "prefs/ThemePrefs.h"
#include "prefs/TracksPrefs.h"
#include "toolbars/ToolManager.h"
#include "tracks/ui/Scrubbing.h"
#include "tracks/ui/ChannelView.h"
#include "wxPanelWrapper.h"
#include "WindowAccessible.h"
#include "ThemedWrappers.h"
#include <wx/app.h>
#include <wx/display.h>
#include <wx/scrolbar.h>
#include <wx/sizer.h>
#include <wx/splitter.h>
#include <wx/wupdlock.h>
#include "TrackPanel.h"

Include dependency graph for ProjectWindow.cpp:

Go to the source code of this file.

Classes
class	anonymous_namespace{ProjectWindow.cpp}::ScrollBar

Namespaces
namespace	anonymous_namespace{ProjectWindow.cpp}

Enumerations
enum	{ FirstID = 1000 , HSBarID , VSBarID , NextID }

Functions
int	ScreenContaining (wxRect &r)
bool	CornersOnScreen (wxRect &r)
bool	IsWindowAccessible (wxRect *requestedRect)
void	GetDefaultWindowRect (wxRect *defRect)
void	GetNextWindowPlacement (wxRect *nextRect, bool *pMaximized, bool *pIconized)

Variables
constexpr int	anonymous_namespace{ProjectWindow.cpp}::DEFAULT_WINDOW_WIDTH = 1120
constexpr int	anonymous_namespace{ProjectWindow.cpp}::DEFAULT_WINDOW_HEIGHT = 674
BoolSetting	ProjectWindowMaximized { L"/Window/Maximized", false }
BoolSetting	ProjectWindowIconized { L"/Window/Iconized", false }
IntSetting	ProjectWindowX { L"/Window/X", 0 }
IntSetting	ProjectWindowY { L"/Window/Y", 0 }
IntSetting	ProjectWindowWidth { L"/Window/Width", DEFAULT_WINDOW_WIDTH }
IntSetting	ProjectWindowHeight { L"/Window/Height", DEFAULT_WINDOW_HEIGHT }
IntSetting	ProjectWindowNormalX { L"/Window/Normal_X", 0 }
IntSetting	ProjectWindowNormalY { L"/Window/Normal_Y", 0 }
IntSetting	ProjectWindowNormalWidth { L"/Window/Normal_Width", DEFAULT_WINDOW_WIDTH }
IntSetting	ProjectWindowNormalHeight { L"/Window/Normal_Height", DEFAULT_WINDOW_HEIGHT }
static CommonTrackPanelCell::MouseWheelHook::Scope	anonymous_namespace{ProjectWindow.cpp}::scope
AttachedWindows::RegisteredFactory	anonymous_namespace{ProjectWindow.cpp}::sProjectWindowKey
const int	sbarHjump = 30
static ToolManager::TopPanelHook::Scope	scope

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
FirstID
HSBarID
VSBarID
NextID

Definition at line 590 of file ProjectWindow.cpp.

     {
   FirstID = 1000,
 
   // Window controls
 
   HSBarID,
   VSBarID,
 
   NextID,
};

Function Documentation

CornersOnScreen()

bool CornersOnScreen

(

wxRect &

r

)

Definition at line 89 of file ProjectWindow.cpp.

                                  {
   if( wxDisplay::GetFromPoint( r.GetTopLeft()  ) == wxNOT_FOUND) return false;
   if( wxDisplay::GetFromPoint( r.GetBottomRight()  ) == wxNOT_FOUND) return false;
   return true;
}

Referenced by GetNextWindowPlacement().

Here is the caller graph for this function:

GetDefaultWindowRect()

void GetDefaultWindowRect

(

wxRect *

defRect

)

Definition at line 122 of file ProjectWindow.cpp.

{
   *defRect = wxGetClientDisplayRect();
 
   int width = DEFAULT_WINDOW_WIDTH;
   int height = DEFAULT_WINDOW_HEIGHT;
 
   //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;
   }
}

References anonymous_namespace{ProjectWindow.cpp}::DEFAULT_WINDOW_HEIGHT, and anonymous_namespace{ProjectWindow.cpp}::DEFAULT_WINDOW_WIDTH.

Referenced by GetNextWindowPlacement(), ProjectWindow::Reset(), and ProjectManager::SaveWindowSize().

Here is the caller graph for this function:

GetNextWindowPlacement()

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

Definition at line 169 of file ProjectWindow.cpp.

{
   int inc = 25;
 
   wxRect defaultRect;
   GetDefaultWindowRect(&defaultRect);
 
   *pMaximized = ProjectWindowMaximized.Read();
   *pIconized = ProjectWindowIconized.Read();
 
   wxRect windowRect;
   windowRect.x = ProjectWindowX.ReadWithDefault(defaultRect.x);
   windowRect.y = ProjectWindowY.ReadWithDefault(defaultRect.y);
   windowRect.width = ProjectWindowWidth.ReadWithDefault(defaultRect.width);
   windowRect.height = ProjectWindowHeight.ReadWithDefault(defaultRect.height);
 
   wxRect normalRect;
   normalRect.x = ProjectWindowNormalX.ReadWithDefault(defaultRect.x);
   normalRect.y = ProjectWindowNormalY.ReadWithDefault(defaultRect.y);
   normalRect.width = ProjectWindowNormalWidth.ReadWithDefault(defaultRect.width);
   normalRect.height = ProjectWindowNormalHeight.ReadWithDefault(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 (AllProjects{}.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;
   ProjectWindow * validProject = NULL;
   for ( auto iter = AllProjects{}.rbegin(), end = AllProjects{}.rend();
      iter != end; ++iter
   ) {
      auto pProject = *iter;
      if (!GetProjectFrame( *pProject ).IsIconized()) {
         validWindowSize = true;
         validProject = &ProjectWindow::Get( *pProject );
         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;
   }
}

References CornersOnScreen(), AllProjects::empty(), PackedArray::end(), ProjectWindow::Get(), GetDefaultWindowRect(), GetProjectFrame(), ProjectWindow::IsIconized(), IsWindowAccessible(), ProjectWindowHeight, ProjectWindowIconized, ProjectWindowMaximized, ProjectWindowNormalHeight, ProjectWindowNormalWidth, ProjectWindowNormalX, ProjectWindowNormalY, ProjectWindowWidth, ProjectWindowX, ProjectWindowY, AllProjects::rbegin(), Setting< T >::Read(), Setting< T >::ReadWithDefault(), AllProjects::rend(), and ScreenContaining().

Referenced by AudacityApp::InitPart2(), and ProjectManager::New().

Here is the call graph for this function:

Here is the caller graph for this function:

IsWindowAccessible()

bool IsWindowAccessible

(

wxRect *

requestedRect

)

Definition at line 96 of file ProjectWindow.cpp.

{
   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;
}

References monitor.

Referenced by GetNextWindowPlacement().

Here is the caller graph for this function:

ScreenContaining()

int ScreenContaining

(

wxRect &

r

)

Definition at line 74 of file ProjectWindow.cpp.

                                  {
   unsigned int n = wxDisplay::GetCount();
   for(unsigned int i = 0;i<n;i++){
      wxDisplay d(i);
      wxRect scr = d.GetClientArea();
      if( scr.Contains( r ) )
         return (int)i;
   }
   return -1;
}

Referenced by GetNextWindowPlacement().

Here is the caller graph for this function:

Variable Documentation

ProjectWindowHeight

IntSetting ProjectWindowHeight { L"/Window/Height", DEFAULT_WINDOW_HEIGHT }

Definition at line 67 of file ProjectWindow.cpp.

Referenced by GetNextWindowPlacement(), and anonymous_namespace{ProjectManager.cpp}::SaveWindowPreferences().

ProjectWindowIconized

BoolSetting ProjectWindowIconized { L"/Window/Iconized", false }

Definition at line 63 of file ProjectWindow.cpp.

Referenced by GetNextWindowPlacement(), and anonymous_namespace{ProjectManager.cpp}::SaveWindowPreferences().

ProjectWindowMaximized

BoolSetting ProjectWindowMaximized { L"/Window/Maximized", false }

Definition at line 62 of file ProjectWindow.cpp.

Referenced by GetNextWindowPlacement(), and anonymous_namespace{ProjectManager.cpp}::SaveWindowPreferences().

ProjectWindowNormalHeight

IntSetting ProjectWindowNormalHeight { L"/Window/Normal_Height", DEFAULT_WINDOW_HEIGHT }

Definition at line 71 of file ProjectWindow.cpp.

Referenced by GetNextWindowPlacement(), and anonymous_namespace{ProjectManager.cpp}::SaveWindowPreferences().

ProjectWindowNormalWidth

IntSetting ProjectWindowNormalWidth { L"/Window/Normal_Width", DEFAULT_WINDOW_WIDTH }

Definition at line 70 of file ProjectWindow.cpp.

Referenced by GetNextWindowPlacement(), and anonymous_namespace{ProjectManager.cpp}::SaveWindowPreferences().

ProjectWindowNormalX

IntSetting ProjectWindowNormalX { L"/Window/Normal_X", 0 }

Definition at line 68 of file ProjectWindow.cpp.

Referenced by GetNextWindowPlacement(), and anonymous_namespace{ProjectManager.cpp}::SaveWindowPreferences().

ProjectWindowNormalY

IntSetting ProjectWindowNormalY { L"/Window/Normal_Y", 0 }

Definition at line 69 of file ProjectWindow.cpp.

Referenced by GetNextWindowPlacement(), and anonymous_namespace{ProjectManager.cpp}::SaveWindowPreferences().

ProjectWindowWidth

IntSetting ProjectWindowWidth { L"/Window/Width", DEFAULT_WINDOW_WIDTH }

Definition at line 66 of file ProjectWindow.cpp.

Referenced by GetNextWindowPlacement(), and anonymous_namespace{ProjectManager.cpp}::SaveWindowPreferences().

ProjectWindowX

IntSetting ProjectWindowX { L"/Window/X", 0 }

Definition at line 64 of file ProjectWindow.cpp.

Referenced by GetNextWindowPlacement(), and anonymous_namespace{ProjectManager.cpp}::SaveWindowPreferences().

ProjectWindowY

IntSetting ProjectWindowY { L"/Window/Y", 0 }

Definition at line 65 of file ProjectWindow.cpp.

Referenced by GetNextWindowPlacement(), and anonymous_namespace{ProjectManager.cpp}::SaveWindowPreferences().

sbarHjump

const int sbarHjump = 30

Definition at line 807 of file ProjectWindow.cpp.

Referenced by ProjectWindow::OnScrollLeft(), ProjectWindow::OnScrollLeftButton(), ProjectWindow::OnScrollRight(), and ProjectWindow::OnScrollRightButton().

scope

ToolManager::TopPanelHook::Scope scope

static

Initial value:

{
[]( wxWindow &window ){
   auto pProjectWindow = dynamic_cast< ProjectWindow* >( &window );
   return pProjectWindow ? pProjectWindow->GetTopPanel() : nullptr;
} }

Definition at line 2010 of file ProjectWindow.cpp.